Fragment详解之六——如何监听fragment中的回退事件与怎样保存fragment状态

经过前几篇，大家应该对Fragment认识的已经足够多了，有关Fragment的基础知识在前几篇基本就讲完了，这篇给大家讲两个可能会用到的知识点。这两点理解起来可能有点难度，大家可要耐着点性子哈。

一、如何监听Fragment中的回退事件

1、问题阐述

在Activity中监听回退事件是件非常容易的事，因为直接重写onBackPressed()函数就好了，但当大家想要监听Fragment中的回退事件时，想当然的也想着重写onBackPressed()方法，这时候你会发现：Fragment中根本就没有onBackPressed()方法给你重写。这可怎么破！

想想，在前面的例子中，我们在Activity的一个fragment_container里依次Add进fragment1,fragment2,fragment3,fragment4，在我们点击回退栈时，会将Transaction回退栈中的fragment操作一个个出栈！那，这些回退事件Fragment是从哪来的？

首先，回退事件总是发给Activity的！在发给Activity以后再由Activity自己处理。比如它将Fragment回退栈中的内容一个个出栈这种操作。
其次：大家要知道：Fragment只是Activity中的一个控件而已，虽然我们可能把他做成了像Activity一样大小覆盖整个页面，看起来跟Activity样子上没什么区别，但他还是个控件！系统怎么会给一个控件分发回退事件呢？这当然是不可能的。

2、解决方案

既然清楚了Fragment只是一个控件，而回退事件也只能在Activity中拦截。那我们就可以想办法了。
首先，我们可以在Fragment类中咱们自己写一个onBackPressed()方法来处理回调事件。
然后，可以利用回调，将要处理回退事件的fragment实例，传给Activity。
最后，在拿到fragment实例以后，就可以在Activity的onBackPress()方法中，调用这个fragment实例的onBackPressed()方法了。
这样，我们就在fragment中拦截了回退事件了。

3、实例

下面，我们就通过一个例子来看下效果。
效果图如下：

大家从下面的效果图中也可以看到，当fragment3中点击返回按钮时，捕捉了返回事件，并将fragment3上的TextView显示为”ragment3捕捉到了回退事件哦！”，但我只捕捉一次，当第二次点击时，就退出执行默认操作：即Transaction出栈。

下面看下具体的实现过程：
有关MainActivity布局及fragment的添加就不再讲了，下面直接从回调开始
1、在Fragment3中定义onBackPress()函数及处理：

[java] view plaincopy

1. public class Fragment3 extends Fragment {  
2.     private boolean mHandledPress = false;  
3.     TextView tv;  
4.       
5.      …………  
6.     @Override  
7.     public void onActivityCreated(Bundle savedInstanceState) {  
8.         super.onActivityCreated(savedInstanceState);  
9.         tv = (TextView)getView().findViewById(R.id.fragment3_tv);  
10.     }  
11.   
12.     public boolean onBackPressed(){  
13.         if (!mHandledPress){  
14.             tv.setText("Fragment3 \n 捕捉到了回退事件哦！");  
15.             mHandledPress = true;  
16.             return true;  
17.         }  
18.         return false;  
19.     }  
20. }  

上面的代码，没什么难度，就是定义了一个onBackPressed()函数,其返回一个布尔值;意思是,如果对返回事件进行了处理就返回TRUE,如果不做处理就返回FALSE,让上层进行处理。
变量mHandledPress用来指定只处理一次，当处理一次以后这里的onBackPressed()就返回FALSE了.
2、在Fragment3中定义回调函数，将自己实例的引用传出去
（1）、先定义一个接口用做回调，以及对应的变量：

[java] view plaincopy

1. protected BackHandlerInterface backHandlerInterface;  
2. public interface BackHandlerInterface {  
3.     public void setSelectedFragment(Fragment3 backHandledFragment);  
4. }  

注意，在回调中传进去的是Fragment3的实例！因为我们要在主Activity处理onBackPress()时，调用我们在Fragment3中自己写的onBackPressed()函数,所以我们要传进去Fragment3的实例
（2）、然后是给backHandlerInterface变量赋值
跟上篇一样，我们要强制Activity实现这个接口，所以我们使用强制转换的方式来赋值。在上篇中，我们在onAttach()函数中进行的强制转换，代码如下：

[java] view plaincopy

1. public void onAttach(Activity activity) {  
2.     super.onAttach(activity);  
3.     try{  
4.         backHandlerInterface = (BackHandlerInterface) getActivity();  
5.     }catch (Exception e){  
6.         throw new ClassCastException("Hosting activity must implement BackHandlerInterface");  
7.     }  
8. }  

其实在onAttach()回调时就已经把Fragment与Activity绑定在了一起，所以只要生命流程在onAttach()之后的任意一个生命周期,我们都可以通过getActivity来获取Activity的实例，来进行强制转换，所以在这里我们就换个地方，在onCreate()函数中来做：

[java] view plaincopy

1. public void onCreate(Bundle savedInstanceState) {  
2.     super.onCreate(savedInstanceState);  
3.     if (!(getActivity() instanceof BackHandlerInterface)) {  
4.         throw new ClassCastException("Hosting activity must implement BackHandlerInterface");  
5.     } else {  
6.         backHandlerInterface = (BackHandlerInterface) getActivity();  
7.     }  
8. }  

这里抛出异常也没有使用try...catch...来做，而是直接利用instanceof来判断当前Activity是不是BackHandlerInterface的实例，即是否已经派生了BackHandlerInterface，如果没有就直接抛异常，如果派生了就强制转换赋值。
（3）、在适当的位置将自己的实例通过回调传过去。代码如下：

[java] view plaincopy

1. backHandlerInterface.setSelectedFragment(this);  

有关这个设置Fragment3实例的代码，只要在生命周期中Fragment3实例已经产生了都可以设置，即可以放在生命周期在onCreate()后的函数里，即onCreate()、onCreateView()、onActivityCreated()、onStart()；虽然经过我测试，放在这几个函数中的任意一个都是可行的，但onActivityCreated()后才是Activity最终onCreate()执行完，所以放在onActivityCreated()或onStart()中是最保险的。所以这里放在了onStart()中来处理，代码如下：

[java] view plaincopy

1. public void onStart() {  
2.     super.onStart();  
3.     backHandlerInterface.setSelectedFragment(this);  
4. }  

所以完整的代码逻辑是这样的：

[java] view plaincopy

1. public class Fragment3 extends Fragment {  
2.     //定义回调函数及变量  
3.     protected BackHandlerInterface backHandlerInterface;  
4.     public interface BackHandlerInterface {  
5.         public void setSelectedFragment(Fragment3 backHandledFragment);  
6.     }  
7.      
8.     @Override  
9.     public void onCreate(Bundle savedInstanceState) {  
10.         super.onCreate(savedInstanceState);  
11.         //回调函数赋值  
12.         if(!(getActivity()  instanceof BackHandlerInterface)) {  
13.             throw new ClassCastException("Hosting activity must implement BackHandlerInterface");  
14.         } else {  
15.             backHandlerInterface = (BackHandlerInterface) getActivity();  
16.         }  
17.     }  
18.   
19.     @Override  
20.     public void onStart() {  
21.         super.onStart();  
22.         //将自己的实例传出去  
23.         backHandlerInterface.setSelectedFragment(this);  
24.     }  
25. }  

3、在MainActivity中，回退拦截，代码如下：

[java] view plaincopy

1. public class MainActivity extends FragmentActivity implements Fragment3.BackHandlerInterface {  
2.     private Fragment3 selectedFragment;  
3.     …………  
4.     @Override  
5.     public void setSelectedFragment(Fragment3 backHandledFragment) {  
6.         this.selectedFragment = backHandledFragment;  
7.     }  
8.   
9.     @Override  
10.     public void onBackPressed() {  
11.         if(selectedFragment == null || !selectedFragment.onBackPressed()) {  
12.             super.onBackPressed();  
13.         }  
14.     }  
15.   
16. }  

（1）、首先，将MainActivity实现Fragment3.BackHandlerInterface接口
在这里实现setSelectedFragment（）函数，代码如下：

[java] view plaincopy

1. public class MainActivity extends FragmentActivity implements Fragment3.BackHandlerInterface {  
2.     private Fragment3 selectedFragment;  
3.     …………  
4.     @Override  
5.     public void setSelectedFragment(Fragment3 backHandledFragment) {  
6.         this.selectedFragment = backHandledFragment;  
7.     }  
8. }  

（2）、然后在onBackPressed()回调中进行回退拦截

[java] view plaincopy

1. public void onBackPressed() {  
2.     if(selectedFragment == null || !selectedFragment.onBackPressed()) {  
3.         super.onBackPressed();  
4.     }  
5. }  

注意这里的逻辑，在调用super.onBackPressed();的前提是selectedFragment.onBackPressed()返回FALSE，即Fragment3中的onBackPressed()返回FALSE，即不再拦截回退事件，才会执行默认的操作。

源码在文章底部给出

二、执行Replace操作后，怎样保存fragment状态

首先，我们先阐述一个现象，大家先看下面这个DEMO：

这个过程是这样的：
1、首先在Fragment1的EditText中先几个字
2、然后如果调用addFragment()添加Fragment2，然后当从fragment2返回时，发现这几个字还是有的。
3、但如果我们通过调用replace()添加Fragment2的话，会发现，当返回的时候，那几个字没了！

这说明了一个问题，调用addFragment添加的fragment的View会保存到视图树（ViewTree）中，其中各个控件的状态都会被保存。但如果调用replace()来添加fragment，我们前面讲到过，replace()的实现是将同一个container中的所有fragment视图从ViewTree中全部清空！然后再添加指定的fragment。由于repalce操作会把以前的所有视图全部清空，所以当使用Transaction回退时，也就只有重建每一个fragment视图，所以就导致从replace操作回退回来，所有的控件都被重建，以前的用户输入全部没了。

到这里，大家首先要明白一个问题，repalce()操作，会清空同一个container中的所有fragment视图！注意用词：请空的是fragment的VIEW！fragment的实例并不会被销毁！因为fragment的实例是通过FragmentManager来管理的。当fragment的VIEW被销毁时，fragment实例并不会被销毁。他们两个不是同时的，即在fragment中定义的变量，所上次运行中被赋予的值是一直存在的。那fragment实例什么时候会被销毁呢，当然是在不会被用到的时候才会被销毁。那什么时候不会被用到呢，即不可能再回退到这个操作的时候，就会被销毁。
在上面的例子中，fragment1虽然被fragment2的repalce操作把它的视图给销毁了，但在执行replace操作时，将操作加入到了回退栈，这时候，FragmentManager就知道，用户还可能通过回退再次用到fragment1，所以就会保留fragment1的实例。相反，如果，在执行repalce操作时，没有加入到回退栈，那FragmentManager就肯定也知道，用户不可能再回到上次那个Fragment1界面了，所以它的fragment实例就会在清除fragment1视图的同时也被清除了。

说了那么多，现在如果我们想在利用repace操作的时候，同时保存上一个fragment界面的状态，那要怎么办？

方法一：控件状态保存与还原

上面我们讲到，在清除Fragment视图的时候，如果我们将操作同时加入到回退栈，那么它的VIEW虽然从ViewTree中清除了，但它的实例会被保存在FragmentManager中，那它的变量也会一直保存着，直到下次回来。但视图在回来的时候会重建。
那第一个方法来了，我们可以用一个变量来保存EditText当前字符串，在replace前将EditText中的值保存在这个变量中，当返回来再次创建视图时，再次给EditTxt赋值不就好了。
代码如下：

[java] view plaincopy

1. public class Fragment1 extends Fragment {  
2.     private String mEditStr;  
3.     private EditText editText;  
4.     @Override  
5.     public View onCreateView(LayoutInflater inflater, ViewGroup container,  
6.             Bundle savedInstanceState) {  
7.         View rootView = inflater.inflate(R.layout.fragment1, container, false);  
8.         editText = (EditText)rootView.findViewById(R.id.fragment1_edittext);  
9.         editText.setText(mEditStr);  
10.         return rootView;  
11.     }  
12.   
13.     @Override  
14.     public void onActivityCreated(Bundle savedInstanceState) {  
15.         super.onActivityCreated(savedInstanceState);  
16.         Button btnReplace = (Button)getView().findViewById(R.id.fragment1_repalce);  
17.         btnReplace.setOnClickListener(new View.OnClickListener() {  
18.             @Override  
19.             public void onClick(View v) {  
20.                 mEditStr = editText.getText().toString();  
21.                   
22.                 …………  
23.             }  
24.         });  
25.         …………  
26.     }  
27. }  

上面的代码总是就是两步：
第一步：在repalce前保存状态

[java] view plaincopy

1. mEditStr = editText.getText().toString();  

第二步：在创建时还原状态

[java] view plaincopy

1. editText.setText(mEditStr);  

这虽然能完成工作，但如果我们的控件非常多呢？内容非常复杂呢？这将不是一个好办法。因为很多变量的初始化及赋值将会使代码看的异常丑陋难懂。

方法二：只需要为控件添加ID值

在实时中还遇到一个解决方法，就是给EditText控件添加上id，只要给EditText控件添加上id，不需要上面的那些replace前的值的保存即创建时的还原，它的内容就会被保存。不知道其它控件是否也可以通过添加ID值的方式来保存用户的输入值，即：

[html] view plaincopy

1. <EditText  
2.     android:id="@+id/fragment1_edittext"  
3.     android:layout_width="match_parent"  
4.     android:layout_height="match_parent"  
5.     android:gravity="top|left"  
6.     android:background="#ffffff"  
7.     android:hint="这里是EditText,在这里输入文字哦"/>  

方法三：保存FragmentView视图

方法一和方法二感觉都还是太靠谱的解决方法，既然fragment中的变量都会被保存，那我们直接将Fragment的视图直接保存到变量中，在系统在利用onCreateView()创建视图的时候，我们直接返回保存的视图不就得了。
基于上面的想法，代码上我们这样做：
1、创建一个变量，保存Fragment的视图：

[java] view plaincopy

1. private View rootView;  

2、然后来看onCreateView的实现

[java] view plaincopy

1. public View onCreateView(LayoutInflater inflater, ViewGroup container,  
2.         Bundle savedInstanceState) {  
3.     return getPersistentView(inflater, container, savedInstanceState, R.layout.fragment1);  
4. }  

可以看到，相比以前直接返回inflater.inflate(R.layout.fragment1, container,false);重建视图，这里返回的是一个getPersistentView()函数，下面看看这个函数的实现：

[java] view plaincopy

1. public View getPersistentView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState, int layout) {  
2.     if (rootView == null) {  
3.         // Inflate the layout for this fragment  
4.         rootView = inflater.inflate(layout, container,false);  
5.     } else {  
6.         ((ViewGroup) rootView.getParent()).removeView(rootView);  
7.     }  
8.     return rootView;  
9. }  

这段代码就是返回rootView的。即当rootView==null，即第一次创建时，就利用inflater.inflate()来创建初始化状态的视图，当下次再进到这个界面时,比如下面的通过回退操作进入到fragment1时，这时候的rootView就不再是空了。但在onCreateView()中返回的视图是要添加到ViewTree中去的。而这里的rootView视图在上次已经添加到里面去了，一个视图实例不能被add两次，不然就会被下面这个错误！所以，我们针对这种情况，如果rootView已经存在于ViewTree中的时候，要先从ViewTree中移除。

好了，到这里就讲完了，源码都会在下面给出。下面先来看看最终的效果图吧：

本文参考文章：

1、《Handling back button press Inside Fragments》

2、《Fragment view state retention: A dirty solution》

如果本文有帮到你，记得加关注哦

源码下载地址：http://download.csdn.net/detail/harvic880925/8590299

请大家尊重原创者版权，转载请标明出处：http://blog.csdn.net/harvic880925/article/details/45013501，谢谢