Android fragment源码全解析

Fragment 相信基本上每个android developer都用过，但是知晓其原理 用的好的还是不多，今天就从源码的角度上来带着大家分析一下Fragment的源码，对fragment有了更深层次的认识以后相信

写出来的代码也会越来越好看。

首先，我们来看第一个流程，fragment是怎么加载到界面上的，借着这个流程分析，能读完绝大多数fragment的源码。

一般我们显示一个fragment的时候 喜欢如下这种做法：

1    blankFragment=new BlankFragment();2         fm=getFragmentManager();3         FragmentTransaction ft=fm.beginTransaction();4         ft.replace(R.id.rootView,blankFragment);5         ft.commit();

 

这段代码相信大家都很熟悉了，我们就来一步步跟进去看看 ，2-5 执行结束以后 是怎么把fragment界面显示到手机屏幕上的。

 1 //下面的代码 来自于activity里面！！！！！！！！！！！！！！！ 2     public FragmentManager getFragmentManager() { 3         //到这里能发现是mFragments返回给我们的FragmentManager 4         return mFragments.getFragmentManager(); 5     } 6  7 //继续往下跟 就会发现mFragments是由FragmentController的createController函数 构造出来的一个对象， 8 //并且这个函数 需要传进去一个HostCallBack的对象 9     final FragmentController mFragments = FragmentController.createController(new HostCallbacks());10 11 12 13 //下面的代码就来自于FragmentController 这个类！！！！！14    private final FragmentHostCallback<?> mHost;15 16     //从这个函数就能看出来HostCallbacks 这个类肯定是FragmentHostCallback的子类了17     public static final FragmentController createController(FragmentHostCallback<?> callbacks) {18         return new FragmentController(callbacks);19     }20 21     private FragmentController(FragmentHostCallback<?> callbacks) {22         mHost = callbacks;23     }24 25    //所以这个getFragmentManager返回的就是FragmentManager这个对象，并且这个对象是mHost的getFragmentManagerImpl函数返回的。26     //这里结合构造函数一看就明白了，这个mHost就是我们在activity代码里面，第12行那里传进去的HostCallbacks这个对象来帮助初始化的27     public FragmentManager getFragmentManager() {28         return mHost.getFragmentManagerImpl();29     }30 31 32  //下面的代码在activity里33 //这个地方一目了然 果然我们这个HostCallbacks 这个类是继承自FragmentHostCallback的，并且能看出来，我们这里把activity的引用也传进去了。34 //所以能马上得出一个结论就是一个activity对应着一个HostCallbacks对象 这个对象持有本身这个activity的引用。传进去以后就代表FragmentController35 //这个类的成员mHost 也持有了activity的引用36  class HostCallbacks extends FragmentHostCallback<Activity> {37         public HostCallbacks() {38             super(Activity.this /*activity*/);39         }40 41         @Override42         public void onDump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {43             Activity.this.dump(prefix, fd, writer, args);44         }45         .................略过余下代码46  }47 48  //下面的代码来源自 FragmentHostCallback<E> 这个抽象类49 50   public FragmentHostCallback(Context context, Handler handler, int windowAnimations) {51         this(null /*activity*/, context, handler, windowAnimations);52     }53 54     FragmentHostCallback(Activity activity) {55         this(activity, activity /*context*/, activity.mHandler, 0 /*windowAnimations*/);56     }57 58     //到这里就能看到FragmentHostCallback 持有了acitivty的引用 并且连activity的handler都一并持有！59     FragmentHostCallback(Activity activity, Context context, Handler handler,60             int windowAnimations) {61         mActivity = activity;62         mContext = context;63         mHandler = handler;64         mWindowAnimations = windowAnimations;65     }

上面 初步分析了getFragmentManager这个方法的由来。那继续看这个方法到底是返回的什么？

1 //下面的代码来源自抽象类FragmentHostCallback2  FragmentManagerImpl getFragmentManagerImpl() {3         return mFragmentManager;4     }5  //所以就能看出来 我们在activity中调用的getFragmentManger这个方法最终返回的是FragmentManagerImpl 这个类的对象了6  final FragmentManagerImpl mFragmentManager = new FragmentManagerImpl();

再进去看看 这个对象的begin方法返回的是什么

 1  //源码来自于抽象类 FragmentManager 2     public FragmentTransaction beginTransaction() { 3         //可以看出来 返回的是BackStackRecord 这个类的对象 4         return new BackStackRecord(this); 5     } 6 //下面的代码来自于BackStackState这个类 7 //可以看到这个类是一个final类  8 final class BackStackState implements Parcelable { 9 }10 11 //注意BackStackRecord这个类 和BackStackState 是在同一个文件内的 12 //可以看一下BackStackRecord 是FragmentTransaction的子类 并且实现了13 //BackStackEntry, Runnable这两个接口14 final class BackStackRecord extends FragmentTransaction implements15         FragmentManager.BackStackEntry, Runnable {16     static final String TAG = FragmentManagerImpl.TAG;17 18     final FragmentManagerImpl mManager;19 }20 21 //下面的这个class就是在BackStackRecord这个类的源码里面的，这里Op22 //实际上就是一个双向链表结构23  static final class Op {24         Op next;25         Op prev;26         int cmd;27         Fragment fragment;28         int enterAnim;29         int exitAnim;30         int popEnterAnim;31         int popExitAnim;32         ArrayList<Fragment> removed;33     }34     

你看 所以begintranscation返回的最终就是backstackrecord对象了。

我们继续看看这个对象的操作

  1 //以下代码来源自backstackrecord 源码  2 public FragmentTransaction replace(int containerViewId, Fragment fragment) {  3         return replace(containerViewId, fragment, null);  4     }  5   6 //你看这里replace操作 你如果没有传进去一个有效的id的话 异常就会在这里出现了  7     public FragmentTransaction replace(int containerViewId, Fragment fragment, String tag) {  8         if (containerViewId == 0) {  9             throw new IllegalArgumentException("Must use non-zero containerViewId"); 10         } 11  12         //最终都是调用的doaAdddop这个方法来完成操作的 13         doAddOp(containerViewId, fragment, tag, OP_REPLACE); 14         return this; 15     } 16  17 //这个方法说白了 就是拼装下这个双向链表 18      private void doAddOp(int containerViewId, Fragment fragment, String tag, int opcmd) { 19         fragment.mFragmentManager = mManager; 20  21         if (tag != null) { 22             if (fragment.mTag != null && !tag.equals(fragment.mTag)) { 23                 throw new IllegalStateException("Can't change tag of fragment " 24                         + fragment + ": was " + fragment.mTag 25                         + " now " + tag); 26             } 27             fragment.mTag = tag; 28         } 29  30         if (containerViewId != 0) { 31             if (fragment.mFragmentId != 0 && fragment.mFragmentId != containerViewId) { 32                 throw new IllegalStateException("Can't change container ID of fragment " 33                         + fragment + ": was " + fragment.mFragmentId 34                         + " now " + containerViewId); 35             } 36             fragment.mContainerId = fragment.mFragmentId = containerViewId; 37         } 38  39         Op op = new Op(); 40         op.cmd = opcmd; 41         op.fragment = fragment; 42         addOp(op); 43     } 44  45 //所以我们看到 replace操作或者是add remove这种操作 就是操作双向链表的 除此之外没有任何有意义的举动，最终反应到用户能感知的层面上全都是要走 46  //commit这个函数的 47      public int commit() { 48         return commitInternal(false); 49     } 50 //构造函数再看一遍 51  52  public BackStackRecord(FragmentManagerImpl manager) { 53         mManager = manager; 54     } 55 int commitInternal(boolean allowStateLoss) { 56         if (mCommitted) { 57             throw new IllegalStateException("commit already called"); 58         } 59         if (FragmentManagerImpl.DEBUG) { 60             Log.v(TAG, "Commit: " + this); 61             LogWriter logw = new LogWriter(Log.VERBOSE, TAG); 62             PrintWriter pw = new FastPrintWriter(logw, false, 1024); 63             dump("  ", null, pw, null); 64             pw.flush(); 65         } 66         mCommitted = true; 67         if (mAddToBackStack) { 68             mIndex = mManager.allocBackStackIndex(this); 69         } else { 70             mIndex = -1; 71         }  72         //这个对象就是     final FragmentManagerImpl mManager; 我们在调用begin函数的时候传进去一个this指针 就是用来初始化他的 73         mManager.enqueueAction(this, allowStateLoss); 74         return mIndex; 75     } 76  77  //所以下面就是FragmentManagerImpl 的源码了 final class FragmentManagerImpl extends FragmentManager implements LayoutInflater.Factory2 78  79 //这个函数就很关键了，这个mHost 前文介绍过 持有了activity的引用，所以这里你看 就是用activity的handler 去执行了mExecCommit  80 //注意是在activity的主线程去执行的mExecCommit 这个线程 81   public void enqueueAction(Runnable action, boolean allowStateLoss) { 82         if (!allowStateLoss) { 83             checkStateLoss(); 84         } 85         synchronized (this) { 86             if (mDestroyed || mHost == null) { 87                 throw new IllegalStateException("Activity has been destroyed"); 88             } 89             if (mPendingActions == null) { 90                 mPendingActions = new ArrayList<Runnable>(); 91             } 92             mPendingActions.add(action); 93             if (mPendingActions.size() == 1) { 94                 mHost.getHandler().removeCallbacks(mExecCommit); 95                 mHost.getHandler().post(mExecCommit); 96             } 97         } 98     } 99 //这个线程执行的execPendingActions 就是这个方法 这个方法也是在FragmentManagerImpl 里的。并不在activity里。所以commit操作就是最终让activity的主线程去执行了FragmentManagerImpl100 //execPendingActions方法101 Runnable mExecCommit = new Runnable() {102         @Override103         public void run() {104             execPendingActions();105         }106     };107 108   /**109      * 所以这个方法是只能在主线程里面做的110      */111     public boolean execPendingActions() {112         if (mExecutingActions) {113             throw new IllegalStateException("Recursive entry to executePendingTransactions");114         }115         116         if (Looper.myLooper() != mHost.getHandler().getLooper()) {117             throw new IllegalStateException("Must be called from main thread of process");118         }119 120         boolean didSomething = false;121 122         while (true) {123             int numActions;124             125             synchronized (this) {126                 if (mPendingActions == null || mPendingActions.size() == 0) {127                     break;128                 }129                 130                 numActions = mPendingActions.size();131                 if (mTmpActions == null || mTmpActions.length < numActions) {132                     mTmpActions = new Runnable[numActions];133                 }134                 mPendingActions.toArray(mTmpActions);135                 mPendingActions.clear();136                 mHost.getHandler().removeCallbacks(mExecCommit);137             }138             139             mExecutingActions = true;140             for (int i=0; i<numActions; i++) {141                 //你看这里run方法 回过头去 我们应该还能想起来backstackrecord这个类是继承了runnable这个接口的，所以最终我们还是要看看backstackrecord 的run方法里面都做了什么142                 mTmpActions[i].run();143                 mTmpActions[i] = null;144             }145             mExecutingActions = false;146             didSomething = true;147         }148 149         if (mHavePendingDeferredStart) {150             boolean loadersRunning = false;151             for (int i=0; i<mActive.size(); i++) {152                 Fragment f = mActive.get(i);153                 if (f != null && f.mLoaderManager != null) {154                     loadersRunning |= f.mLoaderManager.hasRunningLoaders();155                 }156             }157             if (!loadersRunning) {158                 mHavePendingDeferredStart = false;159                 startPendingDeferredFragments();160             }161         }162         return didSomething;163     }

一直到这里 我们就知道，commit操作 最终执行的实际上是我们backstackrecord 这个类里的run方法。

  1 //以下代码就是backstackrecord里面的代码了  2 //这个run方法 其实就是取op这个双向链表然后分析op.cmd的值 然后根据  3 //这些不同的值 去调用FragmentManager里各种转换fragment  4  public void run() {  5         if (FragmentManagerImpl.DEBUG) {  6             Log.v(TAG, "Run: " + this);  7         }  8   9         if (mAddToBackStack) { 10             if (mIndex < 0) { 11                 throw new IllegalStateException("addToBackStack() called after commit()"); 12             } 13         } 14  15         bumpBackStackNesting(1); 16  17         SparseArray<Fragment> firstOutFragments = new SparseArray<Fragment>(); 18         SparseArray<Fragment> lastInFragments = new SparseArray<Fragment>(); 19         calculateFragments(firstOutFragments, lastInFragments); 20         beginTransition(firstOutFragments, lastInFragments, false); 21  22         Op op = mHead; 23         while (op != null) { 24             switch (op.cmd) { 25                 case OP_ADD: { 26                     Fragment f = op.fragment; 27                     f.mNextAnim = op.enterAnim; 28                     mManager.addFragment(f, false); 29                 } 30                 break; 31                 case OP_REPLACE: { 32                     Fragment f = op.fragment; 33                     int containerId = f.mContainerId; 34                     if (mManager.mAdded != null) { 35                         for (int i = 0; i < mManager.mAdded.size(); i++) { 36                             Fragment old = mManager.mAdded.get(i); 37                             if (FragmentManagerImpl.DEBUG) { 38                                 Log.v(TAG, 39                                         "OP_REPLACE: adding=" + f + " old=" + old); 40                             } 41                             if (old.mContainerId == containerId) { 42                                 if (old == f) { 43                                     op.fragment = f = null; 44                                 } else { 45                                     if (op.removed == null) { 46                                         op.removed = new ArrayList<Fragment>(); 47                                     } 48                                     op.removed.add(old); 49                                     old.mNextAnim = op.exitAnim; 50                                     if (mAddToBackStack) { 51                                         old.mBackStackNesting += 1; 52                                         if (FragmentManagerImpl.DEBUG) { 53                                             Log.v(TAG, "Bump nesting of " 54                                                     + old + " to " + old.mBackStackNesting); 55                                         } 56                                     } 57                                     mManager.removeFragment(old, mTransition, mTransitionStyle); 58                                 } 59                             } 60                         } 61                     } 62                     if (f != null) { 63                         f.mNextAnim = op.enterAnim; 64                         mManager.addFragment(f, false); 65                     } 66                 } 67                 break; 68                 case OP_REMOVE: { 69                     Fragment f = op.fragment; 70                     f.mNextAnim = op.exitAnim; 71                     mManager.removeFragment(f, mTransition, mTransitionStyle); 72                 } 73                 break; 74                 case OP_HIDE: { 75                     Fragment f = op.fragment; 76                     f.mNextAnim = op.exitAnim; 77                     mManager.hideFragment(f, mTransition, mTransitionStyle); 78                 } 79                 break; 80                 case OP_SHOW: { 81                     Fragment f = op.fragment; 82                     f.mNextAnim = op.enterAnim; 83                     mManager.showFragment(f, mTransition, mTransitionStyle); 84                 } 85                 break; 86                 case OP_DETACH: { 87                     Fragment f = op.fragment; 88                     f.mNextAnim = op.exitAnim; 89                     mManager.detachFragment(f, mTransition, mTransitionStyle); 90                 } 91                 break; 92                 case OP_ATTACH: { 93                     Fragment f = op.fragment; 94                     f.mNextAnim = op.enterAnim; 95                     mManager.attachFragment(f, mTransition, mTransitionStyle); 96                 } 97                 break; 98                 default: { 99                     throw new IllegalArgumentException("Unknown cmd: " + op.cmd);100                 }101             }102 103             op = op.next;104         }105         //我们也很容易就能看出来 最终都是走的 mManager.moveToState 这个方法106 //同时moveToState 也是fragment状态分发最重要的方法了107 108         mManager.moveToState(mManager.mCurState, mTransition,109                 mTransitionStyle, true);110 111         if (mAddToBackStack) {112             mManager.addBackStackState(this);113         }114     }

到这里应该就差不多了，最终的线索就是 只要搞明白moveToState这个函数就可以了。

  1 //下面的代码来自于fragmentmanager  2 //我们首先来看一下movetostate这个函数总共有一个  3 void moveToState(Fragment f)  4 void moveToState(int newState, boolean always)  5 void moveToState(int newState, int transit, int transitStyle, boolean always)  6 void moveToState(Fragment f, int newState, int transit, int transitionStyle,  7             boolean keepActive)  8   9 //可以看到movetoState总共4种。 10 //在详细介绍movetostate函数之前，我们先去看看这个函数的参数之一new state是什么 11  12 //下面代码来自于fragment 13 //其实new state 就是代表新的状态，总共他的值有7种 就全在这里了 预先都是定义好的 14     static final int INVALID_STATE = -1;   // Invalid state used as a null value. 15     static final int INITIALIZING = 0;     // Not yet created. 16     static final int CREATED = 1;          // Created. 17     static final int ACTIVITY_CREATED = 2; // The activity has finished its creation. 这个状态其实很好理解， 18     //就是fragement在oncreate函数结束的时候会调用dispatchActivityCreated 就是通知fragment 跟你绑定的宿主activity已经走完onCreate了 19     static final int STOPPED = 3;          // Fully created, not started. 20     static final int STARTED = 4;          // Created and started, not resumed. 21     static final int RESUMED = 5;          // Created started and resumed. 22  23  24 //下面我们可以模拟一个流程 帮助大家理解这个状态到底是干嘛的 有什么用。 25 //比如 我们先看看 fragmentactivity的源码， 26 //首先我们假设 我们想看看activity 发生onResumne事件的时候 对fragment有什么影响 27 protected void onResume() { 28         super.onResume(); 29         mHandler.sendEmptyMessage(MSG_RESUME_PENDING); 30         mResumed = true; 31         mFragments.execPendingActions(); 32     } 33 //继续追踪代码 发现最后是调用的onResumeFragments 这个方法 34   final Handler mHandler = new Handler() { 35         @Override 36         public void handleMessage(Message msg) { 37             switch (msg.what) { 38                 case MSG_REALLY_STOPPED: 39                     if (mStopped) { 40                         doReallyStop(false); 41                     } 42                     break; 43                 case MSG_RESUME_PENDING: 44                     onResumeFragments(); 45                     mFragments.execPendingActions(); 46                     break; 47                 default: 48                     super.handleMessage(msg); 49             } 50         } 51  52     }; 53 //原来当activity走onresume流程的时候 最终都是走到这里 54  55 protected void onResumeFragments() { 56         mFragments.dispatchResume(); 57     } 58 //前面已经分析过mFragements就是FragmentController的对象 59 //所以下面的代码 来自于FragmentController 60  public void dispatchResume() { 61      //前面的源码也分析过了mHost.mFragmentManager 就是 final FragmentManagerImpl mFragmentManager = new FragmentManagerImpl(); 62         mHost.mFragmentManager.dispatchResume(); 63     } 64  65 //下面的代码来自fragmentmanager 66 //一直追踪到这里就能明白 activity的声明周期 与fragment声明周期关联的时候 就是通过moveToState 这个函数来完成的 67 public void dispatchResume() { 68         mStateSaved = false; 69         moveToState(Fragment.RESUMED, false); 70     } 71  72 //movetostate这个函数前面已经说过总共有4种 不一样的声明 但是最终起效果的只有这一个 73 //这个函数非常的长 我就简单挑几个注意的点进行注释  代码我就不全部复制粘贴进来了。太长了 74 //有兴趣的同学可以自己跟进去看看 其实逻辑挺简单的 75 void moveToState(Fragment f, int newState, int transit, int transitionStyle, 76             boolean keepActive) { 77       ...... 78         if (f.mState < newState) { 79             // For fragments that are created from a layout, when restoring from 80             // state we don't want to allow them to be created until they are 81             // being reloaded from the layout. 82             if (f.mFromLayout && !f.mInLayout) { 83                 return; 84             }   85             if (f.mAnimatingAway != null) { 86                 // The fragment is currently being animated...  but!  Now we 87                 // want to move our state back up.  Give up on waiting for the 88                 // animation, move to whatever the final state should be once 89                 // the animation is done, and then we can proceed from there. 90                 f.mAnimatingAway = null; 91                 moveToState(f, f.mStateAfterAnimating, 0, 0, true); 92             } 93             switch (f.mState) { 94                 case Fragment.INITIALIZING: 95                  ......................................... 96                         } 97                     } 98                     f.mHost = mHost; 99                     f.mParentFragment = mParent;100                     f.mFragmentManager = mParent != null101                             ? mParent.mChildFragmentManager : mHost.getFragmentManagerImpl();102                     f.mCalled = false;103                     //这个地方相信很多人一看就明白了，这行代码就说明了在onAttach的时候 就能使用和fragment关联的activity了，这也是为什么104                     //fragment与activity通信时，我们喜欢定义接口来完成，并且在onAttach的时候绑定接口 的原因105                     f.onAttach(mHost.getContext());106                     if (!f.mCalled) {107                         throw new SuperNotCalledException("Fragment " + f108                                 + " did not call through to super.onAttach()");109                     }110                     if (f.mParentFragment == null) {111                         mHost.onAttachFragment(f);112                     }113 114                     if (!f.mRetaining) {115                         f.performCreate(f.mSavedFragmentState);116                     }117                     f.mRetaining = false;118                     if (f.mFromLayout) {119                         // For fragments that are part of the content view120                         // layout, we need to instantiate the view immediately121                         // and the inflater will take care of adding it.122                         f.mView = f.performCreateView(f.getLayoutInflater(123                                 f.mSavedFragmentState), null, f.mSavedFragmentState);124                         if (f.mView != null) {125                             f.mInnerView = f.mView;126                             if (Build.VERSION.SDK_INT >= 11) {127                                 ViewCompat.setSaveFromParentEnabled(f.mView, false);128                             } else {129                                 f.mView = NoSaveStateFrameLayout.wrap(f.mView);130                             }131                             if (f.mHidden) f.mView.setVisibility(View.GONE);132                             f.onViewCreated(f.mView, f.mSavedFragmentState);133                         } else {134                             f.mInnerView = null;135                         }136                     }137                 case Fragment.CREATED:138                 ......................139     }

一直分析到这里，相信大家就对fragment的源码基础知识有一个不错的理解了，在这里 就简单总结一下 上面的分析：

1.FragmentActivity 是具有支持fragment功能的最底层的activity。其他什么AppCompatActivity都是他的子类！

2.FragmentActivity主要负责就是生命周期的转发，比如onCreate onResume onDestroy等等，这就是为什么activity和fragment状态能统一的原因了！

当然了，分发的原因就是因为fragmentactivity源码里面持有一个fragmentController的实例！

3.其实将白了，fragmentController就是因为他自己有一个fragmenthostcallback，然后这个hostback还持有了fragmentmanger 所以这个controller 能分发activity的事件！

4.fragementhostcallback持有了activity的很多资源，context handler 是最主要的2个。fragmentmanger就是因为拿到了activty的这2个资源，所以才能和activty互相通信的！

5.fragmentmangerimple就是fragmentmanger的具体实现类。movetostate方法就是在这个里面实现的 

6.FragmentTransition 也是个抽象类，他主要就是提供对外的接口函数的 add replace move 这种。BackStackRecord 就是它的具体实现类。还额外实现了runnable接口。

所以BackStackRecord 里面会有个run方法 这个run方法就是根据不同的操作(所谓操作就是OP.CMD的那个值) 来分发不同的事件，从而调用fragmentmanger的各种转换fragment生命周期的方法！

 

最后在说一下 fragment的 缓存和恢复机制吧。

 1 //保存fragment状态的 主要是靠FragmentState 这个类来完成的 2 final class FragmentState implements Parcelable  3 //可以看一下这个类的构造函数 4  public FragmentState(Fragment frag) { 5         mClassName = frag.getClass().getName(); 6         mIndex = frag.mIndex; 7         mFromLayout = frag.mFromLayout; 8         mFragmentId = frag.mFragmentId; 9         mContainerId = frag.mContainerId;10         mTag = frag.mTag;11         mRetainInstance = frag.mRetainInstance;12         mDetached = frag.mDetached;13         mArguments = frag.mArguments;14     }15 16 //再看一下这个类： 这里保存了3个数组 并且这3个数组元素都实现了Parcelable 接口17 //这意味着他们都可以被序列化18 final class FragmentManagerState implements Parcelable {19     FragmentState[] mActive;20     int[] mAdded;21     BackStackState[] mBackStack;22     23     public FragmentManagerState() {24     }25     26     public FragmentManagerState(Parcel in) {27         mActive = in.createTypedArray(FragmentState.CREATOR);28         mAdded = in.createIntArray();29         mBackStack = in.createTypedArray(BackStackState.CREATOR);30     }31     32     public int describeContents() {33         return 0;34     }35 36     public void writeToParcel(Parcel dest, int flags) {37         dest.writeTypedArray(mActive, flags);38         dest.writeIntArray(mAdded);39         dest.writeTypedArray(mBackStack, flags);40     }41     42     public static final Parcelable.Creator<FragmentManagerState> CREATOR43             = new Parcelable.Creator<FragmentManagerState>() {44         public FragmentManagerState createFromParcel(Parcel in) {45             return new FragmentManagerState(in);46         }47         48         public FragmentManagerState[] newArray(int size) {49             return new FragmentManagerState[size];50         }51     };52 }53 54 //上面那个类的3个属性 实际上对应保存着是fragemntmanager里的 三个成员55 ArrayList<Fragment> mActive;//他还保存了mBackStack所有相关的fragment 所以mAdder是mActive的子集56 ArrayList<Fragment> mAdded;57 ArrayList<BackStackRecord> mBackStack;//这个就是保存调用了addToBackStack方法的FragementTransaction，你看就是这个东西记录了58 //你commit的操作 所以当你调用了addToBackStack 以后再按返回键 就可以回到上一个fragment了

然后我们看一下 当我们的activity onstop以后 会给fragment带来什么？

 1  //下面代码来自于fragmentactivity 2  @Override 3     protected void onStop() { 4         super.onStop(); 5  6         mStopped = true; 7         mHandler.sendEmptyMessage(MSG_REALLY_STOPPED); 8  9         mFragments.dispatchStop();10     }11 12 //来自于fragmentcontroller13  public void dispatchStop() {14         mHost.mFragmentManager.dispatchStop();15     }16 17 //来自于fragemntmanager18  public void dispatchStop() {19         // See saveAllState() for the explanation of this.  We do this for20         // all platform versions, to keep our behavior more consistent between21         // them.22         mStateSaved = true;23         //你看这里就是转换了一下状态24         moveToState(Fragment.STOPPED, false);25     }26 27 //所以对应的你也能猜到了 当activity onresume的时候 这里也无非就是把fragement的状态 从stopped 变成resumed了。 fragement是实例并没有销毁 还在28  public void dispatchResume() {29         mStateSaved = false;30         moveToState(Fragment.RESUMED, false);31     }

我们再考虑一下另外一个场景：

比如说 我们旋转了屏幕。并且

setRetainInstance 为true的时候

看看fragment是怎么处理的（为false的情况 就是fragment和activity一样了 activity怎么做fragment就怎么做 没什么好讲的必要。。）

 

  1  //下面代码来自于fragmentmanager  2 //如果Fragment设置了fragment.setRetainInstance(true) 最终ams 会一步步调用到这个函数的  3 //所以你看 这里就是返回了mActive 数组的拷贝呀！  4  ArrayList<Fragment> retainNonConfig() {  5         ArrayList<Fragment> fragments = null;  6         if (mActive != null) {  7             for (int i=0; i<mActive.size(); i++) {  8                 Fragment f = mActive.get(i);  9                 if (f != null && f.mRetainInstance) { 10                     if (fragments == null) { 11                         fragments = new ArrayList<Fragment>(); 12                     } 13                     fragments.add(f); 14                     f.mRetaining = true; 15                     f.mTargetIndex = f.mTarget != null ? f.mTarget.mIndex : -1; 16                     if (DEBUG) Log.v(TAG, "retainNonConfig: keeping retained " + f); 17                 } 18             } 19         } 20         return fragments; 21     } 22  23 //上面说了保存fragment实例 下面肯定要说如何存储fragemnt的实例的 24 //下面代码来自于activity 25  26     NonConfigurationInstances retainNonConfigurationInstances() { 27         Object activity = onRetainNonConfigurationInstance(); 28         HashMap<String, Object> children = onRetainNonConfigurationChildInstances(); 29         List<Fragment> fragments = mFragments.retainNonConfig(); 30         ArrayMap<String, LoaderManager> loaders = mFragments.retainLoaderNonConfig(); 31         if (activity == null && children == null && fragments == null && loaders == null 32                 && mVoiceInteractor == null) { 33             return null; 34         } 35         //这里nci你看就知道了 看下类的源码你看他保存的东西 并没有做什么序列化反序列化的操作， 36         //所以他可以保存任何东西！当然了，这个nci 是最终保存在activitythread对象里的， 37         //activitytheread对象里有个键值对叫mActivies。他有个数据结构叫activityclientrecord 38         //有兴趣的人可以去看下activitytheread的源码 这里不深入展开了。 39         NonConfigurationInstances nci = new NonConfigurationInstances(); 40         //注意 nci.activity这个地方 可不是activity，他是activity源码中onRetainNonConfigurationInstance方法返回的对象咯，看63行就知道了 41         nci.activity = activity; 42         nci.children = children; 43         nci.fragments = fragments; 44         nci.loaders = loaders; 45         if (mVoiceInteractor != null) { 46             mVoiceInteractor.retainInstance(); 47             nci.voiceInteractor = mVoiceInteractor; 48         } 49         return nci; 50     }. 51  52 //所以看到这里就应该明白，如果你的setRetainInstance设置了true的话，当activity重新recreate的时候，虽然activity生成了一个全新的，fragmentmanger也是一个全新的， 53  //但是你的fragment实际上还是旧的，生命周期会有一些不同的，不会有oncreate和ondestroy了。他会走85行那里的restoreAllState方法了 54      static final class NonConfigurationInstances { 55         Object activity; 56         HashMap<String, Object> children; 57         List<Fragment> fragments; 58         ArrayMap<String, LoaderManager> loaders; 59         VoiceInteractor voiceInteractor; 60     } 61  62  63 //下面这个方法在fragemntactitivy源码里 64      public final Object onRetainNonConfigurationInstance() { 65         if (mStopped) { 66             doReallyStop(true); 67         } 68  69         Object custom = onRetainCustomNonConfigurationInstance(); 70  71         List<Fragment> fragments = mFragments.retainNonConfig(); 72         SimpleArrayMap<String, LoaderManager> loaders = mFragments.retainLoaderNonConfig(); 73  74         if (fragments == null && loaders == null && custom == null) { 75             return null; 76         } 77  78         NonConfigurationInstances nci = new NonConfigurationInstances(); 79         nci.custom = custom; 80         nci.fragments = fragments; 81         nci.loaders = loaders; 82         return nci; 83     } 84  85  //以下代码来自于fragmentmanger restoreAllState这个方法就是恢复保存的fragment实例的 86      void restoreAllState(Parcelable state, List<Fragment> nonConfig) { 87         // If there is no saved state at all, then there can not be 88         // any nonConfig fragments either, so that is that. 89         if (state == null) return; 90         FragmentManagerState fms = (FragmentManagerState)state; 91         if (fms.mActive == null) return; 92          93         // First re-attach any non-config instances we are retaining back 94         // to their saved state, so we don't try to instantiate them again. 95         if (nonConfig != null) { 96             for (int i=0; i<nonConfig.size(); i++) { 97                 Fragment f = nonConfig.get(i); 98                 if (DEBUG) Log.v(TAG, "restoreAllState: re-attaching retained " + f); 99                 FragmentState fs = fms.mActive[f.mIndex];100                 fs.mInstance = f;101                 f.mSavedViewState = null;102                 f.mBackStackNesting = 0;103                 f.mInLayout = false;104                 f.mAdded = false;105                 f.mTarget = null;106                 if (fs.mSavedFragmentState != null) {107                     fs.mSavedFragmentState.setClassLoader(mHost.getContext().getClassLoader());108                     f.mSavedViewState = fs.mSavedFragmentState.getSparseParcelableArray(109                             FragmentManagerImpl.VIEW_STATE_TAG);110                     f.mSavedFragmentState = fs.mSavedFragmentState;111                 }112             }113         }114         115      .................................116     }

最后再考虑一种场景，假设我们的宿主activity 在后台挂起的时候，因为内存不足 被系统杀掉了。fragment会发生什么？

其实也很简单啊，源码就不贴了，大家自己看，我说下简单的流程：

1.首先要明确 activity的onSaveInstanceState的方法，是在onPause以后 onStop以前调用的。

2.activty放到后台的时候会调用onstop方法，但是onSaveInstanceState是在这之前被调用的

3.所以实际上FragmentManager保存的那3个数组mActive、mAdded、mBackStack都被提前保存到FragmentManagerState里面了

4.等到activity重新回到前台 走oncreate的时候，会获得savedInstanceState这个实例，通过他去创建新的FragmentManager实例和新的fragment对象。

5.此时不管fragment是否setRetainInstance(true)，Fragment实例都会重新被创建，原因如下：

retainNonConfig是在Activity在onDestroy被保存的，有人会说，你上面被系统回收了不是也要最终走ondestroy吗，但是要注意的是：

只有被relaunch的activity在destroy时才会在ActivityThread代码中被调用retainNonConfig去通知Activity返回需要保存实例，其他的destroy不会。

所谓relaunch是指 比如我们手动调用了activity的recreate方法，或者更改了系统语言 屏幕方向等造成的activity重新创建。而系统资源不足回收造成的activity重新创建

是不属于relaunch这一行为的。

原文地址：https://developer.android.com/guide/components/fragments.html