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）重入判断，正在添加的观察者不为0或正在处理event，则会重入；
- （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计算
- （1）取当前observer的前一个observer，并将它的state赋值给siblingState；
- （2）获取mParentStates的最近一个state；
- （3）取mState、siblingState、parentState的最小值。
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事件。
网友评论