Android-Fragment源码解析

UML类图

主要类含义介绍

FragmentController

FragmentController为Fragment的宿主提供一个控制器，对Fragment生命周期操作，提供一个控制流程。FragmentController中持有FragmentHostCallback对象，对于Fragment生命周期的操作，主要是通过FragmentHostCallback来实现的。而FragmentHostCallback中的操作，则主要通过FragmentManagerImpl来实现。

FragmentContainer

Fragment容器的回调接口

FragmentHostCallback

Fragment宿主的回调接口，要使一个对象具有持有和管理fragment生命周期的能力，我们只需要实现FragmentHostCallback中的函数。当我们对Fragment进行操作的时候，就会对调用FragmentController的操作，从而间接的调用FragmentHostCallback对象。在FragmentHostCallback中，暴露出了对Fragment操作的一些接口，通过重写这些接口，可以将Fragment操作与Fragment宿主（例如FragmentActivity）捆绑起来。

FragmentActivity

系统为我们提供的，将Activity作为Fragment的宿主的实现类。

FragmentActivity.HostCallbacks

FragmentActivity.HostCallbacks继承FragmentHostCallback，通过重写FragmentHostCallback中的函数，将将Fragment操作与Fragment宿主（例如FragmentActivity）捆绑起来。有些方法需要通过宿主来实现，单单依靠Fragment，无法实现。

FragmentManager

FragmentManager，顾名思义，就是Fragment的真正管理类，主要提供了对Fragment进行操作。实际开发中，对Fragment进行操作的方法，例如beginTransaction()，popBackStack()都是通过该类来获取的。需要注意的是，FragmentManager为一个抽象类，真正的实现类为FragmentManagerImpl

FragmentManager.BackStackEntry

FragmentManager进行pop栈的操作接口，实现类为BackStackRecord，每个Fragment事务FragmentTrasaction都为BackStackRecord

FragmentManagerImpl

Fragmentmanageriml为FragmentManager的实现类，实现了Fragment所有的管理操作，为Fragment操作的入口方法，起到管理Fragment的作用。

FragmentManagerState

FragmentManagerState实现了Parcelable序列化接口，主要用于FragmentManager状态保存。当Activity内存不足被销毁时，保存FragmentManager的当前状态，等到再次启动Activity时，恢复FragmentManager中的Fragment对象。其中，包含了Fragment.FragmentState数组和BackStatckRecord.BackStackState数组，分别保存Fragment的状态信息和Fragment事务（BackStatckRecord）的状态信息。

Fragment.FragmentState

Fragment.FragmentState实现了Parcelable序列化接口，主要用于Fragment状态保存。当Activity内存不足被销毁时，保存Fragment的当前状态，等到再次启动Activity时，恢复Fragment对象。值得一提的是，FragmentState恢复Fragment对象的时候，通过反射调用Fragment参数为空的构造函数，来恢复Fragment对象。这就是为什么Fragment不应该使用有参构造函数的原因。

Fragment

Fragment = View + 固有属性 + State

View，就是添加到界面中的视图；固有属性，就是Attr指得是Fragment的一些固有属性，不会随着Fragment的生命周期发生变化；State，就是Fragemnt当前的状态，Fragment在生命周期变迁中中会发生改变的状态。其实说白了，Fragment就是一个拥有生命周期的自定义View。

FragmentTransaction

Fragment操作的事务，每个FragmentTransaction对象，代表着系列Fragment操作的事务。操作Fragment的添加，删除，隐藏，显示时，都要使用FragmentTransaction。FragmentTransaction其实是个抽象类，真正的实现类为BackStackRecord。

BackStackRecord

BackStackRecord实现了FragmentTransaction，每一个BackStackRecord对象，都代表了一次Fragment操作事务。每次对Fragment进行提交操作，都会生产一个BackStackRecord对象。然后，将对Fragment的每一步操作都封装成Op对象，以链表的形式添加到BackStackRecord中去。BackStackRecord实现了BackStatckRecord.BackStackState接口，表示BackStackRecord可以被FragmentManager保存到操作堆栈中，到执行popBackStack()时，可以恢复原先的BackStackRecord事务。BackStackRecord实现了Runnable接口，当执行FragmentTransaction.commit()方法时，会将BackStackRecord对象当做Runnable，添加到Handler处理队列中，调用BackStackRecord.run()方法来执行上述操作链表中的Op对象集。

Op

Op对象，主要保存了FragmentTransaction操作事务中的单次操作，是相对于Fragment而言的。每个Op对象，保存了操作的Fragment对象，切换动画等对象。Op操作是以链表形式保存起来的。

关键流程分析

以Fragment.replace()为例子，进行Fragment的关键流程分析。执行代码如下：

Fragment fragment  =  DrawerFragment .instance();
FragmentManager fragmentManager  = getSupportFragmentManager();
FragmentTransaction transaction  = fragmentManager .beginTransaction();
transaction .add( R .id .test_content, fragment);
transaction .commit();

关键方法流程图

核心方法介绍

当执行BackStackRecord.commit()的时候，会将BackStackRecord作为Runnable对象，保存到FragmentManagerImpl中。最终，会在Handler中，执行BackStackRecord.run()方法。所以，真正的Fragment操作，都是在run()方法中进行的。

public  void run() {
    . ..
      Op op  = mHead;
      while (op  !=  null) {
          int enterAnim  = state  !=  null  ?  0  : op .enterAnim;
          int exitAnim  = state  !=  null  ?  0  : op .exitAnim;
          switch (op .cmd) {
              case  OP_ADD : {
                  Fragment f  = op .fragment;
                f .mNextAnim  = enterAnim;
                mManager .addFragment(f,  false);
            }  break;
              case  OP_REPLACE : {
                  . ..
            }  break;
              case  OP_REMOVE : {
                  Fragment f  = op .fragment;
                f .mNextAnim  = exitAnim;
                mManager .removeFragment(f, transition, transitionStyle);
            }  break;
              case  OP_HIDE : {
                . ..
            }  break;
            . ..
              //更多case
        }

        op  = op .next;
    }
      //将active状态的fragment全部执行状态变迁检查
    mManager .moveToState(mManager .mCurState, transition, transitionStyle,  true);

      if (mAddToBackStack) {
        mManager .addBackStackState( this);
    }
}

run()方法内部根据不同的cmd走了很不不同的分支，每个分支内部都会对，fragment状态做改变，最后调用moveToState将fragment的生命周期状态mState进行变迁，下面是moveToState()方法。

void moveToState( Fragment f,  int newState,  int transit,  int transitionStyle,  boolean keepActive) {
      // Fragments that are not currently added will sit in the onCreate() state.
    . ..
      if (f .mState  < newState) {
          // For fragments that are created from a layout, when restoring from
          // state we don't want to allow them to be created until they are
          // being reloaded from the layout.
        . ..
          switch (f .mState) {
              case  Fragment .INITIALIZING :
                . ..
              case  Fragment .CREATED :
                  if (newState  >  Fragment .CREATED) {
                   . ..
                }
              case  Fragment .ACTIVITY_CREATED :
              case  Fragment .STOPPED :
                  if (newState  >  Fragment .STOPPED) {
                      if ( DEBUG)  Log .v( TAG,  "moveto STARTED: "  + f);
                    f .performStart();
                }
              case  Fragment .STARTED :
                  if (newState  >  Fragment .STARTED) {
                      if ( DEBUG)  Log .v( TAG,  "moveto RESUMED: "  + f);
                    f .performResume();
                    f .mSavedFragmentState  =  null;
                    f .mSavedViewState  =  null;
                }
        }
    }  else  if (f .mState  > newState) {
          switch (f .mState) {
              case  Fragment .RESUMED :
                  if (newState  <  Fragment .RESUMED) {
                      if ( DEBUG)  Log .v( TAG,  "movefrom RESUMED: "  + f);
                    f .performPause();
                }
              case  Fragment .STARTED :
                  if (newState  <  Fragment .STARTED) {
                      if ( DEBUG)  Log .v( TAG,  "movefrom STARTED: "  + f);
                    f .performStop();
                }
              case  Fragment .STOPPED :
                  if (newState  <  Fragment .STOPPED) {
                      if ( DEBUG)  Log .v( TAG,  "movefrom STOPPED: "  + f);
                    f .performReallyStop();
                }
              case  Fragment .ACTIVITY_CREATED :
                  if (newState  <  Fragment .ACTIVITY_CREATED) {
                   . ..
                }
              case  Fragment .CREATED :
                  if (newState  <  Fragment .CREATED) {
                    . ..
                }
        }
    }

    . ..
}

Fragment状态变迁发生在用户主动发起transaction，或者fragment被add到activity之后跟随activity的生命周期变化一起发生改变。每次状态变迁最终都会走到函数moveToState，字面意思是将fragment迁移到新的状态。fragment的state取值，为前面提到的七中状态，其中最低值是INITIALIZING状态，代表fragment刚创建，还未被add， 最高状态值是RESUMED,代表fragment处于前台。 所以moveToState内部分两条线，状态跃升，和状态降低，里面各有一个switch判断，注意到switch里每个case都没有break，这意味着，状态可以持续变迁，比如从INITIALIZING，一直跃升到RESUMED，将每个case都走一遍，每次case语句内，都会改变state的值。

Fragment状态变迁图

参考

http://www.jianshu.com/p/180d2cc0feb5