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的引用。传进去以后就代表FragmentController
35 //这个类的成员mHost 也持有了activity的引用
36 class HostCallbacks extends FragmentHostCallback<Activity> {
37 public HostCallbacks() {
38 super(Activity.this /*activity*/);
39 }
40
41 @Override
42 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 //下面的代码来源自抽象类FragmentHostCallback
2 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 implements
15 FragmentManager.BackStackEntry, Runnable {
16 static final String TAG = FragmentManagerImpl.TAG;
17
18 final FragmentManagerImpl mManager;
19 }
20
21 //下面的这个class就是在BackStackRecord这个类的源码里面的，这里Op
22 //实际上就是一个双向链表结构
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的主线程去执行了FragmentManagerImpl
100 //execPendingActions方法
101 Runnable mExecCommit = new Runnable() {
102 @Override
103 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.
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) {
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 != null
101 ? 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 " + f
108 + " 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 view
120 // layout, we need to instantiate the view immediately
121 // 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> CREATOR
43 = 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 //来自于fragmentcontroller
13 public void dispatchStop() {
14 mHost.mFragmentManager.dispatchStop();
15 }
16
17 //来自于fragemntmanager
18 public void dispatchStop() {
20 // all platform versions, to keep our behavior more consistent between
21 // 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这一行为的
