Fragment 分析上

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的生命周期图

生命周期图

activity的生命周期发生改变的时候都会分发不同的事件

比如onDestory

@Override
protected void onDestroy() {
    super.onDestroy();

    if (mViewModelStore != null && !isChangingConfigurations()) {
        mViewModelStore.clear();
    }

    mFragments.dispatchDestroy();
}

/**
 * Dispatch onPause() to fragments.
 */
@Override
protected void onPause() {
    super.onPause();
    mResumed = false;
    if (mHandler.hasMessages(MSG_RESUME_PENDING)) {
        mHandler.removeMessages(MSG_RESUME_PENDING);
        onResumeFragments();
    }
    mFragments.dispatchPause();
}

不管是dispatchDestroy()还是dispatchPause()都会调用dispatchStateChange

public void dispatchStart() {
    mStateSaved = false;
    mStopped = false;
    dispatchStateChange(Fragment.STARTED);
}

public void dispatchResume() {
    mStateSaved = false;
    mStopped = false;
    dispatchStateChange(Fragment.RESUMED);
}

public void dispatchPause() {
    dispatchStateChange(Fragment.STARTED);
}

public void dispatchStop() {
    mStopped = true;
    dispatchStateChange(Fragment.ACTIVITY_CREATED);
}

所以我们查看下dispatchStateChange的方式实现

private void dispatchStateChange(int nextState) {
    try {
        mExecutingActions = true;
        moveToState(nextState, false);
    } finally {
        mExecutingActions = false;
    }
    execPendingActions();
}

我们继续查看moveToState方法

onAttach和onCreate生命周期

上面我们讲了moveToState方法,

fragment初始值为INITIALIZING,所以switch方法会到这里去

case Fragment.INITIALIZING:
    if (newState > Fragment.INITIALIZING) {
        if (DEBUG) Log.v(TAG, "moveto CREATED: " + f);
        if (f.mSavedFragmentState != null) {
            f.mSavedFragmentState.setClassLoader(mHost.getContext()
                    .getClassLoader());
            f.mSavedViewState = f.mSavedFragmentState.getSparseParcelableArray(
                    FragmentManagerImpl.VIEW_STATE_TAG);
            f.mTarget = getFragment(f.mSavedFragmentState,
                    FragmentManagerImpl.TARGET_STATE_TAG);
            if (f.mTarget != null) {
                f.mTargetRequestCode = f.mSavedFragmentState.getInt(
                        FragmentManagerImpl.TARGET_REQUEST_CODE_STATE_TAG, 0);
            }
            if (f.mSavedUserVisibleHint != null) {
                f.mUserVisibleHint = f.mSavedUserVisibleHint;
                f.mSavedUserVisibleHint = null;
            } else {
                f.mUserVisibleHint = f.mSavedFragmentState.getBoolean(
                        FragmentManagerImpl.USER_VISIBLE_HINT_TAG, true);
            }
            if (!f.mUserVisibleHint) {
                f.mDeferStart = true;
                if (newState > Fragment.ACTIVITY_CREATED) {
                    newState = Fragment.ACTIVITY_CREATED;
                }
            }
        }

        f.mHost = mHost;
        f.mParentFragment = mParent;
        f.mFragmentManager = mParent != null
                ? mParent.mChildFragmentManager : mHost.getFragmentManagerImpl();

        // If we have a target fragment, push it along to at least CREATED
        // so that this one can rely on it as an initialized dependency.
        if (f.mTarget != null) {
            if (mActive.get(f.mTarget.mIndex) != f.mTarget) {
                throw new IllegalStateException("Fragment " + f
                        + " declared target fragment " + f.mTarget
                        + " that does not belong to this FragmentManager!");
            }
            if (f.mTarget.mState < Fragment.CREATED) {
                moveToState(f.mTarget, Fragment.CREATED, 0, 0, true);
            }
        }

        dispatchOnFragmentPreAttached(f, mHost.getContext(), false);
        f.mCalled = false;
        f.onAttach(mHost.getContext());
        if (!f.mCalled) {
            throw new SuperNotCalledException("Fragment " + f
                    + " did not call through to super.onAttach()");
        }
        if (f.mParentFragment == null) {
            mHost.onAttachFragment(f);
        } else {
            f.mParentFragment.onAttachFragment(f);
        }
        dispatchOnFragmentAttached(f, mHost.getContext(), false);

        if (!f.mIsCreated) {
            dispatchOnFragmentPreCreated(f, f.mSavedFragmentState, false);
            f.performCreate(f.mSavedFragmentState);
            dispatchOnFragmentCreated(f, f.mSavedFragmentState, false);
        } else {
            f.restoreChildFragmentState(f.mSavedFragmentState);
            f.mState = Fragment.CREATED;
        }
        f.mRetaining = false;
    }

我只复制了一部分,

f.onAttach(mHost.getContext());

f.performCreate(f.mSavedFragmentState); 这个方法调用的时候

void performCreate(Bundle savedInstanceState) {
    if (mChildFragmentManager != null) {
        mChildFragmentManager.noteStateNotSaved();
    }
    mState = CREATED;
    mCalled = false;
    onCreate(savedInstanceState);
    mIsCreated = true;
    if (!mCalled) {
        throw new SuperNotCalledException("Fragment " + this
                + " did not call through to super.onCreate()");
    }
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}

我们可以看到状态变成了create下次进来的时候switch case就会发生改变

onCreatView和onViewCreated生命周期

同理create情况下会发生

f.performCreateView(f.performGetLayoutInflater(
        f.mSavedFragmentState), container, f.mSavedFragmentState);

 f.onViewCreated(f.mView, f.mSavedFragmentState);

 f.performActivityCreated(f.mSavedFragmentState);

onStart和onResume生命周期

performActivityCreated的时候 状态变成了ACTIVITY_CREATED

switch case继续发生改变

case Fragment.ACTIVITY_CREATED:
    if (newState > Fragment.ACTIVITY_CREATED) {
        if (DEBUG) Log.v(TAG, "moveto STARTED: " + f);
        f.performStart();
        dispatchOnFragmentStarted(f, false);
    }
    // fall through
case Fragment.STARTED:
    if (newState > Fragment.STARTED) {
        if (DEBUG) Log.v(TAG, "moveto RESUMED: " + f);
        f.performResume();
        dispatchOnFragmentResumed(f, false);
        f.mSavedFragmentState = null;
        f.mSavedViewState = null;
    }