本篇文章带读者走一遍源码
Fragment的前几个生命周期，看源码其实有画流程图就不会觉得枯燥。但是写文章我个人倒是觉得写这种读源码文章挺枯燥的。。。哈哈哈 （ps：读者您最好就是开一下IDE，看源码跟着这里面的流程走一下，希望对你自己去看源码会有点帮助）
Fragment生命周期
- 首先先看一下官网的生命周期图。
Activity与Fragment生命周期对照图
从上面的图可以明显看出来
Activity的生命周期与Fragment是相挂钩的。Activity的生命周期是AMS管理,Fragment的生命周期是被所属Activity管理。
Fragment相关类
我们既然要看Fragment的生命周期，而生命周期是交给Activity管理,且跟Activity的生命周期是相关的，那我们的切入点就可以从Activity的生命中周期着手。且本片文章所看的源码是androidx下的FragmentActivity
Activity与Fragment联动.png
-
FragmentActivity拥有成员对象FragmentController mFragments -
FragmentController拥有成员对象FragmentHostCallback mHost -
FragmentHostCallback拥有成员对象FragmentManagerImpl mFragmentManager
每个类对应的责任：
FragmentController是控制类，对外提供控制Fragment的生命周期等方法，内部实现交由FragmentHostCallback中的FragmentManagerImpl去最终实现。FragmentManagerImpl是最终处理Fragment所有逻辑的实现类。FragmentHostCallback这个类中拥有了Activity，Context,FragmentManagerImpl这几个成员变量，在创建FragmentController的时候我们需要指定一个FragmentHostCallback实例用于指定FragmentController的宿主。(这个不理解的话，下面第一个代码块中有说到)
这几个类的关系简化起来就是通过组合的形式，大致就是
FragmentActivity使用一个FragmentController管理类，由它去操控最终的FragmentManagerImpl控制Fragment的生命周期或者其他相关的逻辑。
源码追踪
先切入主题，我们看一下
FragmentActivity类的onCreate()
public class FragmentActivity{
//mFragments的初始化
final FragmentController mFragments = FragmentController.createController(new HostCallbacks());
protected void onCreate(@Nullable Bundle savedInstanceState) {
mFragments.attachHost(null /*parent*/);
.......
mFragments.dispatchCreate();
}
//FragmentHostCallback 传入FragmentActivity作为Fragment的宿主。
//并提供了可以获取到宿主信息的方法。
class HostCallbacks extends FragmentHostCallback<FragmentActivity> {
@Override
public FragmentActivity onGetHost() {
return FragmentActivity.this;
}
@Nullable
@Override
public View onFindViewById(int id) {
return FragmentActivity.this.findViewById(id);
}
}
}
上面代码部分注释了，我们直接看mFragments.dispatchCreate();里面的实现
public class FragmentController {
private final FragmentHostCallback<?> mHost;
public void dispatchCreate() {
mHost.mFragmentManager.dispatchCreate();
}
}
直接从这里面进去FragmentManagerImpl
final class FragmentManagerImpl extends FragmentManager implements LayoutInflater.Factory2 {
public void dispatchCreate() {
mStateSaved = false;
mStopped = false;
dispatchStateChange(Fragment.CREATED);//关键点1
}
private void dispatchStateChange(int nextState) {
...省略
moveToState(nextState, false);//关键点2
...省略
}
void moveToState(int newState, boolean always) {
...省略
mCurState = newState; //这里的mCurState = Fragment.CREATED
if (mActive != null) {
final int numAdded = mAdded.size();
for (int i = 0; i < numAdded; i++) {
Fragment f = mAdded.get(i);
moveFragmentToExpectedState(f);//关键点3
}
...省略
}
}
}
这里重点记住 传入的状态mCurState = Fragment.CREATED
void moveFragmentToExpectedState(Fragment f) {
...省略
int nextState = mCurState; //mCurState = Fragment.CREATED
moveToState(f, nextState, f.getNextTransition(), f.getNextTransitionStyle(), false); //关键点1
}
这里先展示一下Fragment状态的对象值。后面对比用得上。
static final int INITIALIZING = 0; // Not yet created.
static final int CREATED = 1; // Created.
static final int ACTIVITY_CREATED = 2; // Fully created, not started.
static final int STARTED = 3; // Created and started, not resumed.
static final int RESUMED = 4; // Created started and resumed.
接下来就是最终控制逻辑的方法了。这个方法就是控制Fragment生命周期的逻辑实现，因为这个方法过于长，我截取必要部分出来。
//此时
//mState = INITIALIZING
//newState = Fragment.CREATED
void moveToState(Fragment f, int newState, int transit, int transitionStyle,
boolean keepActive) {
.......省略
if (f.mState <= newState){
switch (f.mState) {//这里的case没有break。所以会执行所有的case。
case Fragment.INITIALIZING:
if (newState > Fragment.INITIALIZING) {
...省略
f.onAttach(mHost.getContext()); //关键点1
...省略
if (!f.mIsCreated) {//mIsCreated这个值赋值是在performCreate()，所以第一次为falese则符合这个条件
f.performCreate(f.mSavedFragmentState); //关键点2
}
}
case Fragment.CREATED:
ensureInflatedFragmentView(f);//关键点3
}
}
关键点1：调用了
Fragment中第一个生命周期onAttach(Context context)
关键点2： 调用Fragment的onCreate方法
void performCreate(Bundle savedInstanceState) {
...省略
mState = CREATED;
mCalled = false;
onCreate(savedInstanceState);//调用Fragment的onCreate方法
mIsCreated = true;//上个代码块的条件值 mIsCreated的赋值在这里
...省略
}
关键点3： 调用Fragment的onViewCreated方法
void ensureInflatedFragmentView(Fragment f) {
if (f.mFromLayout && !f.mPerformedCreateView) {
f.performCreateView(f.performGetLayoutInflater(
f.mSavedFragmentState), null, f.mSavedFragmentState);
if (f.mView != null) {
f.mInnerView = f.mView;
f.mView.setSaveFromParentEnabled(false);
if (f.mHidden) f.mView.setVisibility(View.GONE);
f.onViewCreated(f.mView, f.mSavedFragmentState);//调用Fragment的onViewCreated方法
dispatchOnFragmentViewCreated(f, f.mView, f.mSavedFragmentState, false);
} else {
f.mInnerView = null;
}
}
}
由上面的流程下来你可以看到，当
Activity执行onCreate()的时候，至少Fragment有三个生命周期被调用到onAttach() ->onCreate()->onCreateView()。
而后的Activity onStart()可以看一下
protected void onStart() {
super.onStart();
if (!mCreated) {
mCreated = true;
mFragments.dispatchActivityCreated();//关键1
}
mFragments.dispatchStart();//关键2
}
你可以看到上面两个调用分别是
dispatchActivityCreated() dispatchStart()对应Fragment的生命期为onActivityCreate()跟Start()后面的就读者自己去看一下啦 根据上面的一样逻辑思路很容易就看懂的~
总结
其实这篇文章就是看源码写的文章，看源码主要就是抓住重点，确定自己的目标要看懂什么找什么。只要确定这一点然后一边画代码的流水线图，很容易就找到代码的流向。然后根据看懂了之后再总结一下这些类的作用，这样写有什么好处。
最后附上一副自己在看源码的时候画的图~
Fragment生命周期逻辑图片.jpg
网友评论