前言
Lifecycle是一个可执行操作来响应另一个组件（Activity和Fragment）的生命周期状态的变化。
Lifecycle 是一个类，用于存储有关组件（如 Activity 或 Fragment）的生命周期状态的信息，并允许其他对象观察此状态。
事件
Lifecycle类分派的生命周期事件，这些事件映射到Activity和Fragment的回调事件。
状态
由 Lifecycle 对象跟踪的组件的当前状态
实现原理
一.Activity中的实现过程
LifecycleOwner定义：主要返回一个Lifecycle对象
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
@NonNull
Lifecycle getLifecycle();
}
ComponentActivity中实现LifecycleOwner，并返回给Lifecycle的实现类LifecycleRegistry。
public class ComponentActivity androidx.core.app.ComponentActivity implements
LifecycleOwner,
ViewModelStoreOwner,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner {
......
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mSavedStateRegistryController.performRestore(savedInstanceState);
//具体的生命周期事件变化，对应到ReportFragment中实现
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}
......
}
相关的生命周期变换交由ReportFragment，那么接下来查看具体的实现过程：
public class ReportFragment extends Fragment {
......
//在Activity中添加一个空的Fragment
public static void injectIfNeededIn(Activity activity) {
// ProcessLifecycleOwner should always correctly work and some activities may not extend
// FragmentActivity from support lib, so we use framework fragments for activities
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);
//分发ON_CREATE事件
dispatch(Lifecycle.Event.ON_CREATE);
}
@Override
public void onStart() {
super.onStart();
dispatchStart(mProcessListener);
dispatch(Lifecycle.Event.ON_START);
}
....
private void dispatch(Lifecycle.Event event) {
Activity activity = getActivity();
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
}
//调用Lifecycle的事件处理
if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
......
}
从上面的源码中可以看出，生命周期的处理都交由LifecycleRegistry进行处理，接下来看LifecycleRegistry是如何实现的。
public class LifecycleRegistry extends Lifecycle {
......
//只对LifecycleOwner进行弱引用，如果有其他的导致了Lifecycle泄漏，也不会泄漏整个Fragment/Activity.然而，Lifecycle强引用了所有的监听者，如果Lifecycle内存泄漏，也会导致相应的Listener内存泄漏
private final WeakReference<LifecycleOwner> mLifecycleOwner;
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
}
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
//添加观察者
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
......
}
//对LifecycleObserver 进行包装处理
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
//LifecycleObserver的实现方法给我们提供了三种 LifecycleEventObserver，FullLifecycleObserver，直接实现LifecycleObserver，添加事件注解
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
@NonNull
static LifecycleEventObserver lifecycleEventObserver(Object object) {
boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
if (isLifecycleEventObserver && isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
(LifecycleEventObserver) object);
}
if (isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
}
if (isLifecycleEventObserver) {
return (LifecycleEventObserver) object;
}
final Class<?> klass = object.getClass();
int type = getObserverConstructorType(klass);
.....
}
//设置当前状态并且通知相应的观察者
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
//最后交由forwardPass()或者backwardPass进行事件变化通知处理
moveToState(next);
}
......
}
小结：Lifecycle在Activity中的实现过程为：
- Activity实现LifecycleOwner，默认实例化Lifecycle的子类LifecycleRegistry来管理相关的事件
- 在Activity中默认创建ReportFragment来感知相应的生命周期变化
- LifecycleRegistry通知相关的LifecycleObserver事件变化
整个实现过程就上面三大步骤，相关的源码也在上面有分析，其中ON_STOP事件有特殊的处理
以下内容参考处理ON_STOP事件
如果 Lifecycle 属于 AppCompatActivity 或 Fragment，那么调用 AppCompatActivity 或 Fragment 的 onSaveInstanceState() 时，Lifecycle 的状态会更改为 CREATED 并且会分派 ON_STOP 事件。
通过 onSaveInstanceState() 保存 Fragment 或 AppCompatActivity 的状态后，其界面被视为不可变，直到调用 ON_START。如果在保存状态后尝试修改界面，很可能会导致应用的导航状态不一致，因此应用在保存状态后运行 FragmentTransaction 时，FragmentManager 会抛出异常。如需了解详情，请参阅 commit()。
LiveData 本身可防止出现这种极端情况，方法是在其观察者的关联 Lifecycle 还没有至少处于 STARTED 状态时避免调用其观察者。在后台，它会在决定调用其观察者之前调用 isAtLeast()。
遗憾的是，AppCompatActivity 的 onStop() 方法会在 onSaveInstanceState() 之后调用，这样就会留下一个缺口，即不允许界面状态发生变化，但 Lifecycle 尚未移至 CREATED 状态。
为防止出现这个问题，beta2 及更低版本中的 Lifecycle 类会将状态标记为 CREATED 而不分派事件，这样一来，即使未分派事件（直到系统调用 onStop()），检查当前状态的任何代码也会获得实际值。
遗憾的是，此解决方案有两个主要问题：
-
在 API 23 及更低级别，Android 系统实际上会保存 Activity 的状态，即使它的一部分被另一个 Activity 覆盖。换句话说，Android 系统会调用 onSaveInstanceState()，但不一定会调用 onStop()。这样可能会产生很长的时间间隔，在此时间间隔内，观察者仍认为生命周期处于活动状态，虽然无法修改其界面状态。
-
要向 LiveData 类公开类似行为的任何类都必须实现由 Lifecycle 版本 beta 2 及更低版本提供的解决方案。
注意： 为了简化此流程并让其与较低版本实现更好的兼容性，自 1.0.0-rc1 版本起，当调用 onSaveInstanceState() 时，会将 Lifecycle 对象标记为 CREATED 并分派 ON_STOP，而不等待调用 onStop() 方法。这不太可能影响您的代码，但您需要注意这一点，因为它与 API 26 及更低级别的 Activity 类中的调用顺序不符。
二.fragment中的实现过程
fragment的实现原理和Activity类似，详情可进入源码进行查。
如何使用
在了解完原理后，接下来需要了解在开发中具体如何使用；
开发中我们我自定了一个控件，需要在Fragment或者Activity的onDetroy()中释放相关的资源，结合Lifecycle我们来看一下如何实现呢？
方法一
implements LifecycleObserver,使用注解的方式对事件进行监听
class VideoController implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
public void release() {
// your code
}
//注册监听
public void addOwner(LifecycleOwner owner){
owner.getLifecycle().addObserver(this);
}
}
方法二
implements LifecycleEventObserver,在onStateChanged方法中对事件进行监听
class VideoController implements LifecycleEventObserver {
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
//
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
//you code
}
// or lide this
if(event == ON_DESTROY){
//you code
}
}
//注册监听
public void addOwner(LifecycleOwner owner){
owner.getLifecycle().addObserver(this);
}
}
最后添加观察者
使用中注意事项
Event.ON_CREATE、ON_START、ON_RESUME在对应的生命周期只执行完成后才执行。ON_PAUSE、ON_STOP、ON_DESTROY则是在对应的生命周期之前执行。这些生命周期的执行顺序需要了解，从而减少错误的概率。
总结
使用lifecycle的目的为了解耦，同时解决开发过程中因为没有在onDetroy()之前释放资源造成内存泄漏或者OOM的问题。
扫一扫
537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
