Lifecycle用来存储有关组件（如 Activity 或 Fragment）的生命周期状态，并允许其他对象观察此状态。

一、使用

1、基本使用

Lifecycle使用很简单，Fragment和AppCompatActivity已经实现了LifecycleOwner接口，因此只需要以下两步：

• 自定义类，实现DefaultLifecycleObserver接口
• 在Fragment/AppCompatActivity中调用getLifecycle().addObserver()

public class MyObserver implements DefaultLifecycleObserver {
    @Override
    public void onResume(LifecycleOwner owner) {
        connect()
    }

    @Override
    public void onPause(LifecycleOwner owner) {
        disconnect()
    }
}

myLifecycleOwner.getLifecycle().addObserver(new MyObserver());

2、自定义LifecycleOwner

LifecycleOwner是一个接口，表示类具有生命周期（Lifecycle）。它有一个方法getLifecycle()，该方法必须由类实现。

public class MyActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry lifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        lifecycleRegistry = new LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    public void onStart() {
        super.onStart();
        lifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return lifecycleRegistry;
    }
}

二、源码分析

1、AppCompatActivity何时实现的LifecycleOwner

看如下代码，可知：AppCompatActivity继承自FragmentActivity，FragmentActivity继承自ComponentActivity，ComponentActivity实现了LifecycleOwner接口。

// AppCompatActivity继承自FragmentActivity 
public class AppCompatActivity extends FragmentActivity implements AppCompatCallback,
        TaskStackBuilder.SupportParentable, ActionBarDrawerToggle.DelegateProvider {}

// FragmentActivity继承自ComponentActivity
public class FragmentActivity extends ComponentActivity implements
        ActivityCompat.OnRequestPermissionsResultCallback,
        ActivityCompat.RequestPermissionsRequestCodeValidator {}

// ComponentActivity实现了LifecycleOwner接口
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ContextAware,
        LifecycleOwner,
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner,
        ActivityResultRegistryOwner,
        ActivityResultCaller {
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

2、生命周期方法如何触发

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ContextAware,
        LifecycleOwner,
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner,
        ActivityResultRegistryOwner,
        ActivityResultCaller {
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        mSavedStateRegistryController.performRestore(savedInstanceState);
        mContextAwareHelper.dispatchOnContextAvailable(this);
        super.onCreate(savedInstanceState);
        // 通过ReportFragment处理声明周期
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }
}

在ComponentActivity的onCreate方法中，通过ReportFragment.injectIfNeededIn(this)添加了一个透明的fragment，actiivty将自己的生命周期委托给ReportFragment处理。

public class ReportFragment extends android.app.Fragment {
    public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            // On API 29+, we can register for the correct Lifecycle callbacks directly
            LifecycleCallbacks.registerIn(activity);
        }
        // Prior to API 29 and to maintain compatibility with older versions of
        // ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and
        // need to support activities that don't extend from FragmentActivity from support lib),
        // use a framework fragment to get the correct timing of Lifecycle events
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

    @Override
    public void onStart() {
        super.onStart();
        dispatchStart(mProcessListener);
        dispatch(Lifecycle.Event.ON_START);
    }

    private void dispatch(@NonNull Lifecycle.Event event) {
        if (Build.VERSION.SDK_INT < 29) {
            // Only dispatch events from ReportFragment on API levels prior
            // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
            // added in ReportFragment.injectIfNeededIn
            dispatch(getActivity(), event);
        }
    }

    static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }

        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }
}

在ReportFragment对应的生命周期，通过getLifecycle()拿到mLifecycleRegistry，然后处理生命周期事件。

3、LifecycleRegistry.addObserver()

• （1）通过当前状态判断新增的observer的初始状态；
• （2）对observer进行封装为ObserverWithState，关联state；
• （3）将封装好的ObserverWithState缓存到mObserverMap中；如果已经缓存过，直接return；
• （4）是否是重入的判断；
• （5）计算目标状态；
• （6）重新分发该监听者漏掉的事件；
• （7）如果是非重入，则进行同步。

public class LifecycleRegistry extends Lifecycle {
       @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        // 如果需要进行主线程判断，则确认是否是主线程
        enforceMainThreadIfNeeded("addObserver");
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        // 包装监听者和状态
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        // 缓存到map中，由此可知，observer可以添加多个，如果已经存在，返回之前缓存的数据
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        // 如果已经存在的话，直接返回
        if (previous != null) {
            return;
        }
        ...

        // 是否是重入：正在添加的观察者不为0或正在处理event
        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        // 目标状态
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;

        // 重新分发该监听者漏掉的事件
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            final Event event = Event.upFrom(statefulObserver.mState);
            if (event == null) {
                throw new IllegalStateException("no event up from " + statefulObserver.mState);
            }
            statefulObserver.dispatchEvent(lifecycleOwner, event);
            popParentState();
            // mState / subling may have been changed recalculate
            targetState = calculateTargetState(observer);
        }

        // 同步所有观察者状态
        if (!isReentrance) {
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }
}

3.1、targetState计算

public class LifecycleRegistry extends Lifecycle {
    private State calculateTargetState(LifecycleObserver observer) {
        Map.Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);

        State siblingState = previous != null ? previous.getValue().mState : null;
        State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)
                : null;
        return min(min(mState, siblingState), parentState);
    }
}


public class FastSafeIterableMap<K, V> extends SafeIterableMap<K, V> {
    public Map.Entry<K, V> ceil(K k) {
        if (contains(k)) {
            return mHashMap.get(k).mPrevious;
        }
        return null;
    }
}

三、注意

• addObserver将监听者传入后，会在mObserverMap进行缓存，因此可知，可以添加多个监听者
• 过期的生命周期还是可以收到的，例如：在onResume中添加监听者，也能收到onCreate事件。