fragment重叠问题

在用Fragment做Tab页面，发现有时候进入应用会同时显示多个Tab内容，UI发生重叠。

直接back键退出应用再进入时，则没有出现该问题。

后面才知道，当应用被强行关闭后（通过手机管家软件手动强关，或系统为节省内存自动关闭应用），再次进入应用时，每次都有这现象。

如下图：

页面1：

页面3：

强关应用后进入应用，发生页面重叠：

该界面有一个Activity，三个Tab对应有三个Fragment, 第一次进入应用时，根据选择的tab分别创建对应的Fragment，之后每次选择页面时隐藏其他tab内容

Activity代码：

[java]  view plain copy

1. public class TestFragmentTab extends FragmentActivity {  
2.       
3.     private static final String TAG = "TestFragmentTab";  
4.       
5.     private int tabIds[] = new int[]{  
6.             R.id.home_tab_main,  
7.             R.id.home_tab_search,  
8.             R.id.home_tab_category,  
9.     };  
10.       
11.     private FragmentTab1 mTab1;  
12.     private FragmentTab2 mTab2;  
13.     private FragmentTab3 mTab3;  
14.   
15.     @Override  
16.     public void onAttachFragment(Fragment fragment) {  
17.         // TODO Auto-generated method stub  
18.         super.onAttachFragment(fragment);  
19.         Log.d(TAG,"onAttachFragment");  
20.     }  
21.   
22.     @Override  
23.     protected void onDestroy() {  
24.         // TODO Auto-generated method stub  
25.         super.onDestroy();  
26.         Log.d(TAG,"onDestroy");  
27.     }  
28.   
29.     @Override  
30.     protected void onPause() {  
31.         // TODO Auto-generated method stub  
32.         super.onPause();  
33.         Log.d(TAG,"onPause");  
34.     }  
35.   
36.     @Override  
37.     protected void onResume() {  
38.         // TODO Auto-generated method stub  
39.         super.onResume();  
40.         Log.d(TAG,"onResume");  
41.     }  
42.   
43.     @Override  
44.     protected void onStart() {  
45.         // TODO Auto-generated method stub  
46.         super.onStart();  
47.         Log.d(TAG,"onStart");  
48.     }  
49.   
50.     @Override  
51.     protected void onStop() {  
52.         // TODO Auto-generated method stub  
53.         super.onStop();  
54.         Log.d(TAG,"onStop");  
55.     }  
56.   
57.     @Override  
58.     protected void onCreate(Bundle savedInstanceState) {  
59.         // TODO Auto-generated method stub  
60.         super.onCreate(savedInstanceState);  
61.         Log.d(TAG,"onCreate");  
62.         setContentView(R.layout.layout_test_fragment_tab);  
63.           
64.         RadioGroup tabButtonGroup = (RadioGroup) findViewById(R.id.bottom_bar);  
65.         tabButtonGroup.setOnCheckedChangeListener(new OnCheckedChangeListener() {  
66.               
67.             @Override  
68.             public void onCheckedChanged(RadioGroup group, int checkedId) {  
69.                 // TODO Auto-generated method stub  
70.                 for (int i = 0; i < tabIds.length; i++) {  
71.                     if (tabIds[i] == checkedId) {  
72.                         setSelection(i);  
73.                         break;  
74.                     }  
75.                 }  
76.             }  
77.         });  
78.           
79.         setSelection(0);  
80.     }  
81.       
82.     private void setSelection(int position){  
83.           
84.         FragmentManager fm = getSupportFragmentManager();  
85.         FragmentTransaction ft = fm.beginTransaction();  
86.         hideAllFragments(ft);  
87.           
88.         switch (position) {  
89.         case 0:  
90.             if (mTab1 == null) {  
91.                 mTab1 = new FragmentTab1();  
92.                 ft.add(R.id.content, mTab1);  
93.             }else {  
94.                 ft.show(mTab1);  
95.             }  
96.             break;  
97.               
98.         case 1:  
99.             if (mTab2 == null) {  
100.                 mTab2 = new FragmentTab2();  
101.                 ft.add(R.id.content, mTab2);  
102.             }else {  
103.                 ft.show(mTab2);  
104.             }  
105.             break;  
106.               
107.         case 2:  
108.             if (mTab3 == null) {  
109.                 mTab3 = new FragmentTab3();  
110.                 ft.add(R.id.content, mTab3);  
111.             }else {  
112.                 ft.show(mTab3);  
113.             }  
114.             break;  
115.   
116.         default:  
117.             break;  
118.         }  
119.           
120.         ft.commit();  
121.     }  
122.       
123.     private void hideAllFragments(FragmentTransaction ft){  
124.         if (mTab1 != null) {  
125.             ft.hide(mTab1);  
126.         }  
127.           
128.         if (mTab2 != null) {  
129.             ft.hide(mTab2);  
130.         }  
131.           
132.         if (mTab3 != null) {  
133.             ft.hide(mTab3);  
134.         }  
135.     }  
136.   
137. }  

通过分析发现，正常back键退出应用时，Activity及Fragment对象会被销毁，因此再次进入时会在切换到Tab时创建对应的Fragment对象。

但是当强行关闭应用后，Activity虽然被回收，但Fragment对象仍然保持，再次进入应用时，系统会分别调用Fragment的onAttach方法将其附加到Activity上，

02-08 12:41:24.107: D/FragmentTab1(7032): onAttach

02-08 12:41:24.107: D/FragmentTab3(7032): onAttach

这里对应的就是强行关闭应用前的fragment对象，

后面会分别调用两个fragment的onCreateView方法，因此这两个Fragment对应的View层次结构都会加到Activity的View层次中。

虽然setSelection方法会把所有fragment先隐藏再显示选中的对象，但由于此时Activity中Fragment对象的成员变量还未初始化，因此会再次实例化fragment对象，

之后add、show及hide的都是在第二次创建的对象上操作的，而之前被保持的fragment对象的视图层次已经反映到Activity视图中并且不会被hide，因此发生了上述重叠现象。

解决方法：

在Activity的onAttachFragment方法中，有一个fragment参数，它就是onAttach方法对应的Fragment对象，

通过判断这个fragment对象，如果属于我们的FragmentTabX类并且该类还未被实例化过，则将Activity的成员变量mFragmentTabX指向该fragment对象，这样就可以在原来的fragment对象上操作add/show/hide，因此不会有重叠现象

[java]  view plain copy

1. @Override  
2.     public void onAttachFragment(Fragment fragment) {  
3.         // TODO Auto-generated method stub  
4.         super.onAttachFragment(fragment);  
5.         Log.d(TAG,"onAttachFragment");  
6.           
7.         if (mTab1 == null && fragment instanceof FragmentTab1) {  
8.             mTab1 = (FragmentTab1)fragment;  
9.         }else if (mTab2 == null && fragment instanceof FragmentTab2) {  
10.             mTab2 = (FragmentTab2)fragment;  
11.         }else if (mTab3 == null && fragment instanceof FragmentTab3) {  
12.             mTab3 = (FragmentTab3)fragment;  
13.         }  
14.     }  

通过以上也可知，某些情况当系统需要将Activity回收以便节省内存时，Activity内部保持的fragment不会被销毁，可用于保存/恢复数据。