Second, the use of fragment

Reprint Please specify source: http://blog.csdn.net/guolin_blog/article/details/8881711

We all know that the interface display on Android is implemented through activity, activity is too often used, I believe we are already very familiar with, here will not repeat.

But activity also has its limitations, the same interface on the phone may look good, on the tablet is not necessarily, because the tablet screen is very large, the phone's interface on the tablet may be excessively stretched, the control spacing is too large, and so on. This is a better time to experience the effect of embedding "small activity" in activity, and then each "small activity" can have its own layout. Therefore, our protagonist fragment debut today.

Preliminary study on fragment

To allow the interface to be better displayed on the tablet, Android introduced the Fragment (fragmentation) feature in version 3.0, which is very similar to activity and can include layouts like activity. Fragment is usually nested in the activity, now imagine this scenario: there are two Fragment,fragment 1 contains a ListView, each line shows the title of a book. Fragment 2 contains TextView and ImageView to show the details and pictures of the book.

If the program is now running in portrait mode on a tablet or phone, Fragment 1 may be embedded in one activity, while Fragment 2 may be embedded in another activity, as shown in:

And if the program is now running on a flat screen mode, two fragment can be embedded in the same activity as shown:

As you can see, using fragment allows us to make the most of our tablet's screen space, and here we explore how to use fragment.

The first thing to note is that fragment was introduced in version 3.0, and if you are using a system before 3.0, you need to import the ANDROID-SUPPORT-V4 jar package before you can use the fragment feature.

Create a new project called Fragments, and then create a new layout file named Fragment1.xml under the Layout folder:

[HTML] view plain copy

1. <linearlayout xmlns:android= "Http://schemas.android.com/apk/res/android"
2. Android:layout_width= "Match_parent"
3. android:layout_height= "Match_parent"
4. android:background= "#00ff00" >
6. <textview
7. Android:layout_width= "Wrap_content"
8. android:layout_height= "Wrap_content"
9. Android:text= "This is fragment 1"
10. Android:textcolor= "#000000"
11. Android:textsize= "25SP"/>
13. </LinearLayout>

As you can see, this layout file is very simple and there is only one linearlayout, which adds a textview. We create a new fragment2.xml:

[HTML] view plain copy

1. <linearlayout xmlns:android= "Http://schemas.android.com/apk/res/android"
2. Android:layout_width= "Match_parent"
3. android:layout_height= "Match_parent"
4. android:background= "#ffff00" >
6. <textview
7. Android:layout_width= "Wrap_content"
8. android:layout_height= "Wrap_content"
9. Android:text= "This is Fragment 2"
10. Android:textcolor= "#000000"
11. Android:textsize= "25SP"/>
13. </LinearLayout>

Then create a new class Fragment1, this class is inherited from the fragment:

[Java] view plain copy

1. public class Fragment1 extends Fragment {
3. @Override
4. Public View Oncreateview (layoutinflater inflater, ViewGroup container, Bundle savedinstancestate) {
5. Return Inflater.inflate (R.layout.fragment1, container, false);
6. }
8. }

As we can see, this class is also very simple, mostly loading the fragment1.xml layout file we just wrote and returning it. In the same way, we'll write the Fragment2 again:

[Java] view plain copy

1. public class Fragment2 extends Fragment {
3. @Override
4. Public View Oncreateview (layoutinflater inflater, ViewGroup container, Bundle savedinstancestate) {
5. Return Inflater.inflate (R.layout.fragment2, container, false);
6. }
8. }

Then open or create a new activity_main.xml as the main activity layout file, add two fragment references, use the Android:name prefix to refer to the specific fragment:

[HTML] view plain copy

1. <linearlayout xmlns:android= "Http://schemas.android.com/apk/res/android"
2. Android:layout_width= "Match_parent"
3. android:layout_height= "Match_parent"
4. Android:baselinealigned= "false" >
6. <fragment
7. Android:id= "@+id/fragment1"
8. Android:name= "Com.example.fragmentdemo.Fragment1"
9. Android:layout_width= "0dip"
10. android:layout_height= "Match_parent"
11. android:layout_weight= "1"/>
13. <fragment
14. Android:id= "@+id/fragment2"
15. Android:name= "Com.example.fragmentdemo.Fragment2"
16. Android:layout_width= "0dip"
17. android:layout_height= "Match_parent"
18. android:layout_weight= "1"/>
20. </LinearLayout>

Finally open or new mainactivity as the main activity of the program, the code inside is very simple, are automatically generated:

[Java] view plain copy

1. public class Mainactivity extends Activity {
3. @Override
4. protected void OnCreate (Bundle savedinstancestate) {
5. Super.oncreate (savedinstancestate);
6. Setcontentview (R.layout.activity_main);
7. }
9. }

Now let's run the program once, and we'll see that an activity contains two fragment, two fragment split the entire screen, as follows:

Add fragment Dynamically

You've learned how to use fragment in XML, but this is just the simplest feature of fragment. The real strength of fragment is that it can be dynamically added to the activity, so that's what you have to master. When you learn to add fragment to the activity while the program is running, the interface of the program can be customized more varied. Now we'll see how to add fragment dynamically.

Or on the basis of the previous section of the code to modify, open activity_ Main.xml, the reference to fragment is deleted, only the outermost linearlayout is preserved, and an ID is added to it, because we want to add fragment dynamically, without adding it in the XML, the following code is removed:

[HTML] view plain copy

1. <linearlayout xmlns:android= "Http://schemas.android.com/apk/res/android"
2. Android:id= "@+id/main_layout"
3. Android:layout_width= "Match_parent"
4. android:layout_height= "Match_parent"
5. Android:baselinealigned= "false" >
7. </LinearLayout>

Then open mainactivity and modify the code as follows:

[Java] view plain copy

2. public class Mainactivity extends Activity {
6. @Override
8. protected void OnCreate (Bundle savedinstancestate) {
10. Super.oncreate (savedinstancestate);
12. Setcontentview (R.layout.activity_main);
14. Display display = Getwindowmanager (). Getdefaultdisplay ();
16. if (Display.getwidth () > Display.getheight ()) {
18. Fragment1 fragment1 = new Fragment1 ();
20. Getfragmentmanager (). BeginTransaction (). replace (R.id.main_layout, fragment1). commit ();
22. } else {
24. Fragment2 Fragment2 = new Fragment2 ();
26. Getfragmentmanager (). BeginTransaction (). replace (R.id.main_layout, Fragment2). commit ();
28. }
30. }
34. }

First, we want to get the width and height of the screen, and then judge if the screen width is greater than the height of the add fragment1, if the height is greater than the width of the add Fragment2. Dynamically adding fragment is divided into 4 main steps:

1. Access to Fragmentmanager, which can be obtained directly through Getfragmentmanager in the activity.

2. Open a transaction by calling the BeginTransaction method.

3. Adding fragment to the container, typically implemented with the Replace method, requires passing in the ID of the container and an instance of fragment.

4. Commit the transaction and invoke the Commit method commit.

Now run the program with the effect as shown:

If you are running with the emulator, press CTRL + F11 to switch to portrait mode. The effect is as follows:

The life cycle of fragment

Like activity, fragment has its own life cycle, it is important to understand the life cycle of fragment, and we look at how the life cycle of fragment is based on code:

[Java] view plain copy

2. public class Fragment1 extends Fragment {
4. public static final String TAG = "Fragment1";
8. @Override
10. Public View Oncreateview (layoutinflater inflater, ViewGroup container, Bundle savedinstancestate) {
12. LOG.D (TAG, "Oncreateview");
14. Return Inflater.inflate (R.layout.fragment1, container, false);
16. }
20. @Override
22. public void Onattach (activity activity) {
24. Super.onattach (activity);
26. LOG.D (TAG, "Onattach");
28. }
32. @Override
34. public void OnCreate (Bundle savedinstancestate) {
36. Super.oncreate (savedinstancestate);
38. LOG.D (TAG, "onCreate");
40. }
44. @Override
46. public void onactivitycreated (Bundle savedinstancestate) {
48. Super.onactivitycreated (savedinstancestate);
50. LOG.D (TAG, "onactivitycreated");
52. }
56. @Override
58. public void OnStart () {
60. Super.onstart ();
62. LOG.D (TAG, "OnStart");
64. }
68. @Override
70. public void Onresume () {
72. Super.onresume ();
74. LOG.D (TAG, "Onresume");
76. }
80. @Override
82. public void OnPause () {
84. Super.onpause ();
86. LOG.D (TAG, "onPause");
88. }
92. @Override
94. public void OnStop () {
96. Super.onstop ();
98. LOG.D (TAG, "onStop");
100. }
104. @Override
106. public void Ondestroyview () {
108. Super.ondestroyview ();
110. LOG.D (TAG, "Ondestroyview");
112. }
116. @Override
118. public void OnDestroy () {
120. Super.ondestroy ();
122. LOG.D (TAG, "OnDestroy");
124. }
128. @Override
130. public void Ondetach () {
132. Super.ondetach ();
134. LOG.D (TAG, "Ondetach");
136. }
140. }

As you can see, the above code prints the log in every life cycle method, and then we run the program and see the print log as follows:

At this point, click the Home button, print the log as follows:

If you re-enter the program again, print the log as follows:

Then click the Back button to exit the program, print the log as follows:

Seeing here, I believe most of my friends are very clear, because it is too similar to the life cycle of the activity. There are only a few new methods that are not available in the activity, so here are some highlights:

• Onattach method: Called when fragment is associated with an activity.
• Oncreateview method: Called when the layout is loaded for fragment.
• Onactivitycreated method: Called when the OnCreate method in the activity finishes executing.
• Ondestroyview method: Called when the layout in the fragment is removed.
• Ondetach method: Called when fragment and activity are disassociate.

Communication between the fragment

Typically, the activity will contain multiple fragment, so how to communicate between multiple fragment is a very important issue. Let's look at an example of how to access another fragment view in one fragment.

Or on the basis of the first section of the code to modify, first open fragment2.xml, in this layout to add a button:

[HTML] view plain copy

1. <linearlayout xmlns:android= "Http://schemas.android.com/apk/res/android"
2. Android:layout_width= "Match_parent"
3. android:layout_height= "Match_parent"
4. android:orientation= "Vertical"
5. android:background= "#ffff00" >
7. <textview
8. Android:layout_width= "Wrap_content"
9. android:layout_height= "Wrap_content"
10. Android:text= "This is Fragment 2"
11. Android:textcolor= "#000000"
12. Android:textsize= "25SP"/>
14. <button
15. Android:id= "@+id/button"
16. Android:layout_width= "Wrap_content"
17. android:layout_height= "Wrap_content"
18. android:text= "Get fragment1 text"
19. />
21. </LinearLayout>

Then open Fragment1.xml and add an ID for TextView:

[HTML] view plain copy

1. <linearlayout xmlns:android= "Http://schemas.android.com/apk/res/android"
2. Android:layout_width= "Match_parent"
3. android:layout_height= "Match_parent"
4. android:background= "#00ff00" >
6. <textview
7. Android:id= "@+id/fragment1_text"
8. Android:layout_width= "Wrap_content"
9. android:layout_height= "Wrap_content"
10. Android:text= "This is fragment 1"
11. Android:textcolor= "#000000"
12. Android:textsize= "25SP"/>
14. </LinearLayout>

Then open Fragment2.java, add the Onactivitycreated method, and handle the button's Click event:

[Java] view plain copy

2. public class Fragment2 extends Fragment {
6. @Override
8. Public View Oncreateview (layoutinflater inflater, ViewGroup container, Bundle savedinstancestate) {
10. Return Inflater.inflate (R.layout.fragment2, container, false);
12. }
16. @Override
18. public void onactivitycreated (Bundle savedinstancestate) {
20. Super.onactivitycreated (savedinstancestate);
22. Button button = (button) getactivity (). Findviewbyid (R.id.button);
24. Button.setonclicklistener (New Onclicklistener () {
26. @Override
28. public void OnClick (View v) {
30. TextView TextView = (TextView) getactivity (). Findviewbyid (R.id.fragment1_text);
32. Toast.maketext (Getactivity (), Textview.gettext (), Toast.length_long). Show ();
34. }
36. });
38. }
42. }

Now run the program and click on the button on the Fragment2, as shown in the results:

We can see that the view in Fragment1 was successfully obtained in Fragment2 and the toast was popped. How is this going to be achieved? Mainly through the Getactivity this method is implemented. The Getactivity method allows fragment to obtain the associated activity and then invoke the Findviewbyid method of the activity to obtain a view of the other fragment associated with the activity.

Well, that's all you need to know about fragment. If you want to experience the actual combat of fragment, please continue to read the Android phone tablet, using fragment to achieve compatible mobile phone and tablet programs and Android fragment application combat, use fragments to say goodbye to Activitygroup.

First time to get blog update reminders, as well as more technical information sharing, welcome to follow my public number, sweep the QR code below or search number Guolin_blog, you can pay attention to.

Second, the use of fragment