Jetpack（三）—— Lifecycle

橙子19911016

已于 2022-07-27 09:46:09 修改

阅读量1k

点赞数

于 2021-12-11 16:42:22 首次发布

本文链接：https://blog.csdn.net/xingyu19911016/article/details/121788792

版权

1 感知`Activity`/`Fragment`的生命周期

在编写Android应用程序的时候，经常会遇到需要感知Activity/Fragment生命周期的情况。比如说，某个界面中发起了一条网络请求，但是当请求得到响应的时候，界面或许已经关闭了，这个时候就不应该继续对响应的结果进行处理。因此，需要能够时刻感知到Activity/Fragment的生命周期，以便在适当的时候进行相应的逻辑控制。

在Activity/Fragment中去感知它们的生命周期非常简单，而如果要在一个非Activity/Fragment的类中去感知相关的Activity/Fragment的生命周期，应该怎么办呢？这种需求是广泛存在的，同时也衍生出了一系列的解决方案，比如通过在Activity中嵌入一个隐藏的Fragment来进行感知，或者通过手写监听器的方式来进行感知等等。

下面的代码演示了如何通过手写监听器的方式来对Activity的生命周期进行感知：

class MainActivity : AppCompatActivity() {

    lateinit var observer: MyObserver

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        observer = MyObserver()
    }

    override fun onStart() {
        super.onStart()
        observer.activityStart()
    }

    override fun onStop() {
        super.onStop()
        observer.activityStop()
    }

}

class MyObserver {
    fun activityStart() { }

    fun activityStop() { }
}

可以看到，为了让MyObserver能够感知到Activity的生命周期，需要专门在MainActivity中重写相应的生命周期方法，然后再通知给MyObserver。这种实现方式虽然是可以正常工作的，但是不够优雅，需要在Activity中编写太多额外的逻辑。

2 `Lifecyle`的使用

下面通过具体的例子来学习Lifecycle组件的用法。新建一个MyObserver类，并让它实现LifecycleObserver接口，代码如下所示：

class MyObserver : LifecycleObserver {
}

接下来可以在MyObserver中定义任何方法，但是如果想要感知到Activity的生命周期，还得借助额外的注解功能才行，代码如下所示：

class MyObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun activityStart() {
        Log.e("MyObserver", "activityStart")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun activityStop() {
        Log.e("MyObserver", "activityStop")
    }
    
}

在方法上使用了@OnLifecycleEvent注解，并传入了一种生命周期事件。生命周期事件的类型一共有7种：ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、 ON_STOP和ON_DESTROY分别匹配Activity中相应的生命周期回调；另外还有一种ON_ANY类型，表示可以匹配Activity的任何生命周期回调。因此，上述代码中的activityStart()和activityStop()方法就应该分别在Activity的onStart()和onStop()触发的时候执行。

但是代码写到这里还是无法正常工作的，因为当Activity的生命周期发生变化的时候并没有人去通知MyObserver，而我们又不想像刚才一样在Activity中去一个个手动通知。这个时候就得借助LifecycleOwner了，它可以使用如下的语法结构让MyObserver得到通知：

lifecycleOwner.lifecycle.addObserver(MyObserver())

首先调用LifecycleOwner的getLifecycle()方法，得到一个Lifecycle对象，然后调用它的addObserver()方法来观察LifecycleOwner的生命周期，再把MyObserver的实例传进去就可以了。

因为Activity是继承自ComponentActivity的，Fragment是继承自androidx.fragment.app.Fragment的，它们本身就是一个LifecycleOwner的实例，这部分工作已经由AndroidX库自动完成了。也就是说，在MainActivity当中就可以这样写：

class MainActivity : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        lifecycle.addObserver(MyObserver())
    }
}

只要添加这样一行代码，MyObserver就能自动感知到Activity的生命周期了。另外，需要说明的是，尽管一直在以Activity举例，但其实上述的所有内容在Fragment中也是通用的。

现在重新运行一下程序，activityStart这条日志就会打印出来了。如果再按下Home键或者Back键的话，activityStop这条日志也会打印出来。

这些就是Lifecycles组件最常见的用法了。不过目前MyObserver虽然能够感知到Activity的生命周期发生了变化，却没有办法主动获知当前的生命周期状态。要解决这个问题也不难，只需要在MyObserver的构造函数中将Lifecycle对象传进来即可，如下所示：

class MyObserver(val lifecycle: Lifecycle) : LifecycleObserver {
   .....
}

3 `Lifecycle`源码解析

在Android框架中定义的大多数应用组件都有生命周期，生命周期由操作系统或进程中运行的框架代码管理。它们是Android工作原理的核心，应用必须遵循它们，否则，可能会引发内存泄漏甚至应用崩溃。

生命周期感知型组件感知另一个组件（如Activity和Fragment）的生命周期状态的变化。 这些组件有助于编写出更有条理且更精简的代码，此类代码也更容易维护。

androidx.lifecycle软件包提供了可用于构建生命周期感知型组件的类和接口——这些组件可以根据Activity或Fragment的当前生命周期状态自动调整其行为。其中，有四个比较重要的类，分别是Lifecycle、LifecycleRegistry、LifecycleOwner、LifecycleObserver：

Lifecycle是一个持有组件（Activity/Fragment）生命周期状态信息的抽象类，并且作为一个被观察者，允许其它对象观察生命周期状态；
LifecycleRegistry是Lifecycle的实现类，主要是用来注册/移除观察者以及向观察者同步组件的生命状态；
LifecycleOwner是Lifecycle的持有者，是一个单一方法接口。在android中，ComponentActivity和Fragment都实现了该接口；
LifecycleObserver是Lifecycle的观察者，是一个空接口；

registry [ˈredʒɪstri] 注册；登记处；挂号处

3.1 生命周期感知型组件 — `Lifecycle`

Lifecycle的源码如下所示：

public abstract class Lifecycle {

  @MainThread
  public abstract void addObserver(@NonNull LifecycleObserver observer);

  @MainThread
  public abstract void removeObserver(@NonNull LifecycleObserver observer);

  @MainThread
  @NonNull
  public abstract State getCurrentState();

  @SuppressWarnings("WeakerAccess")
  public enum Event {
    ON_CREATE, // Constant for onCreate event of the {@link LifecycleOwner}.
    ON_START, // Constant for onStart event of the {@link LifecycleOwner}.    
    ON_RESUME, // Constant for onResume event of the {@link LifecycleOwner}.   
    ON_PAUSE, // Constant for onPause event of the {@link LifecycleOwner}. 
    ON_STOP, // Constant for onStop event of the {@link LifecycleOwner}.  
    ON_DESTROY, // Constant for onDestroy event of the {@link LifecycleOwner}. 
    ON_ANY; // An {@link Event Event} constant that can be used to match all events.  
  }

  /**
    * Lifecycle states. 
    */
  @SuppressWarnings("WeakerAccess")
  public enum State {
    DESTROYED, // Destroyed state for a LifecycleOwner.
    INITIALIZED, // Initialized state for a LifecycleOwner. 
    CREATED, // Created state for a LifecycleOwner. 
    STARTED, // Started state for a LifecycleOwner.
    RESUMED; // Resumed state for a LifecycleOwner. 

    /**
      * Compares if this State is greater or equal to the given {@code state}.
      */
    public boolean isAtLeast(@NonNull State state) {
      return compareTo(state) >= 0;
    }
  }
}

initialized [ɪˈnɪʃəlaɪzd] 初始化

Lifecycle是一个抽象类，其内部有添加和移除观察者的方法，还有两个枚举来关联组件的生命周期状态，分别是Event和State:

State表示生命周期所处的状态；
Event表示生命周期状态变化时所对应的事件；

State和Event的关系如下图所示：

Lifecycle生命周期

Event中的事件和Activity/Fragment的生命周期几乎是对应的，除了ON_ANY，它可用于匹配所有事件。State中有INITIALIZED、DESTROYED、CREATED、STARTED、RESUMED这5种状态类型。

从源码中可以看出，Lifecycle没有直接持有Activity/Fragment的强引用，可以有效的避免内存泄漏的问题。

注意这里的addObserver(Observer)、removeObserver(observer)、getCurrentState()都是抽象方法。有了Lifecycle对象之后，就可以调用lifecycle.currentState来获知当前组件的生命周期状态。

3.2 `Lifecycle`的持有者 — `LifecycleOwner`

getLifecycle()是接口LifecycleOwner中的方法，通过调用这个方法可以获得Lifecycle的实例。CompontentActivity/Fragment都实现了LifecycleOwner接口，并重写了getLifecycle()方法，以下是相关源码：

public interface LifecycleOwner {
  @NonNull
  Lifecycle getLifecycle();
}

public class Fragment implements LifecycleOwner, ... { }

public class AppCompatActivity extends FragmentActivity implements ... { }
public class FragmentActivity extends ComponentActivity implements ... { }
public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner, ... {

  private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this); // 1

  @Override
  protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ReportFragment.injectIfNeededIn(this); // 2
  }

  @CallSuper
  @Override
  protected void onSaveInstanceState(@NonNull Bundle outState) {
    Lifecycle lifecycle = getLifecycle();
    if (lifecycle instanceof LifecycleRegistry) {
      ((LifecycleRegistry) lifecycle).setCurrentState(Lifecycle.State.CREATED); // 3
    }
    super.onSaveInstanceState(outState);
  }

  @NonNull
  @Override
  public Lifecycle getLifecycle() {
    return mLifecycleRegistry; // 4
  }
}

按正常的逻辑来说应该在ComponentActivity的各个生命周期中改变Lifecycle的State，但是，源码并是这样实现的，而是将这个任务交给了ReportFragment。在注释2处将ComponentActivity注入到了ReportFragment中。以下是ReportFragment的源码：

public class ReportFragment extends android.app.Fragment {

  public static void injectIfNeededIn(Activity activity) {
    if (Build.VERSION.SDK_INT >= 29) { // 1
      LifecycleCallbacks.registerIn(activity);
    }
    android.app.FragmentManager manager = activity.getFragmentManager();
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
      manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
      manager.executePendingTransactions();
    }
  }

  static ReportFragment get(Activity activity) {
    return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
      REPORT_FRAGMENT_TAG);
  }

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

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

  @Override
  public void onResume() {
    super.onResume();
    dispatch(Lifecycle.Event.ON_RESUME);
  }

  @Override
  public void onPause() {
    super.onPause();
    dispatch(Lifecycle.Event.ON_PAUSE);
  }

  @Override
  public void onStop() {
    super.onStop();
    dispatch(Lifecycle.Event.ON_STOP);
  }

  @Override
  public void onDestroy() {
    super.onDestroy();
    dispatch(Lifecycle.Event.ON_DESTROY);
  }

  private void dispatch(@NonNull Lifecycle.Event event) {
    if (Build.VERSION.SDK_INT < 29) {
      dispatch(getActivity(), event);
    }
  }
  
  static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    if (activity instanceof LifecycleRegistryOwner) { 
      ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event); // 2
      return;
    }

    if (activity instanceof LifecycleOwner) { 
      Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
      if (lifecycle instanceof LifecycleRegistry) {
        ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event); 
      }
    }
  } 
  
  static class LifecycleCallbacks implements ActivityLifecycleCallbacks {
    public void onActivityPostCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState) {
      ReportFragment.dispatch(activity, Event.ON_CREATE);
    }

    public void onActivityPostStarted(@NonNull Activity activity) {
      ReportFragment.dispatch(activity, Event.ON_START);
    }
    public void onActivityPostResumed(@NonNull Activity activity) {
      ReportFragment.dispatch(activity, Event.ON_RESUME);
    }

    public void onActivityPrePaused(@NonNull Activity activity) {
      ReportFragment.dispatch(activity, Event.ON_PAUSE);
    }
    public void onActivityPreStopped(@NonNull Activity activity) {
      ReportFragment.dispatch(activity, Event.ON_STOP);
    }
    public void onActivityPreDestroyed(@NonNull Activity activity) {
      ReportFragment.dispatch(activity, Event.ON_DESTROY);
    }
  }
}

@Deprecated
public interface LifecycleRegistryOwner extends LifecycleOwner {
  @NonNull
  @Override
  LifecycleRegistry getLifecycle();
}

如果SDK >= 29会注册一个ActivityLifecycleCallbacks，ActivityLifecycleCallbacks是Application的一个内部接口。以Activity.onResume()为例，如果注册了ActivityLifecycleCallbacks，系统首先会调用ActivityLifecycleCallbacks.onActivityResumed方法，再执行Activity.onResume()方法。

在ReportFragment中，不论是SDK >= 29还是SDK < 29，最终都是通过调用LifecycleRegistry.handleLifecycleEvent(event)方法将Lifecycle.Event分发给每个观察者。

3.3 `Lifecycle`的实现类 — `LifecycleRegistry`

LifecycleRegistry是抽象类Lifecycle的实现类，实现了Lifecycle中的addObserver(observer)/removeObserver(observer)等抽象方法。 以下是addObserver(obsever)方法的源码：

public class LifecycleRegistry extends Lifecycle {
  
  // 保存Observer以及其对应的State
  private FastSafeIterableMap<LifecycleObserver, LifecycleRegistry.ObserverWithState> mObserverMap;
  
  // 生命周期状态
  private State mState;
  
  public void addObserver(@NonNull LifecycleObserver observer) {
    this.enforceMainThreadIfNeeded("addObserver");
    
    // 1. 首先确定新添加的Observer的初始状态，只要组件的状态不是DESTROYED，那么它的初始状态都是INITIALIZED
    State initialState = this.mState == State.DESTROYED ? State.DESTROYED : State.INITIALIZED;
    
    // 2. 将Observer和initialState包装成一个ObserverWithState类，这个类表示一个带状态的Observer
    LifecycleRegistry.ObserverWithState statefulObserver = new LifecycleRegistry.ObserverWithState(observer, initialState);
    
    // 3. 将observer和statefulObserver添加到集合中
    LifecycleRegistry.ObserverWithState previous = (LifecycleRegistry.ObserverWithState)this.mObserverMap.putIfAbsent(observer, statefulObserver);
    
    if (previous == null) {
      LifecycleOwner lifecycleOwner = (LifecycleOwner)this.mLifecycleOwner.get();
      if (lifecycleOwner != null) {
        boolean isReentrance = this.mAddingObserverCounter != 0 || this.mHandlingEvent;
        // 4. 首先计算出Observer应该到达的状态
        State targetState = this.calculateTargetState(observer);
        ++this.mAddingObserverCounter;

        // 5. 通过compareTo方法比较Observer和组件的状态，如果小于0，说明两者的状态还没有对齐。利用while循环将观察者和组件的状态进行对齐
        while(statefulObserver.mState.compareTo(targetState) < 0 && this.mObserverMap.contains(observer)) {
          this.pushParentState(statefulObserver.mState);
          Event event = Event.upFrom(statefulObserver.mState);
          if (event == null) {
            throw new IllegalStateException("no event up from " + statefulObserver.mState);
          }

          // 6. 执行一次事件分发
          statefulObserver.dispatchEvent(lifecycleOwner, event);
          this.popParentState();
          // 7. 计算Observer下一个应该到达的状态，在下次循环中还需要与之对比
          targetState = this.calculateTargetState(observer);
        }

        if (!isReentrance) {
          this.sync();
        }

        --this.mAddingObserverCounter;
      }
    }
  }
  
  
  static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
      this.mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
      this.mState = initialState;
    }

    void dispatchEvent(LifecycleOwner owner, Event event) {
      State newState = event.getTargetState();
      this.mState = LifecycleRegistry.min(this.mState, newState);
      this.mLifecycleObserver.onStateChanged(owner, event);
      this.mState = newState;
    }
  }

}

根据while循环的逻辑，可以知道，即使我们在onResume方法中调用addObserver(observer)方法来添加观察者，观察者依旧可以接收到ON_CREATE和ON_START事件（数据倒灌）。比如说，在onResume()方法中注册观察者：

while第一次循环：分发ON_CREATE事件，观察者的状态INITIALIZED -> CREATED；
while第二次循环：分发ON_START事件，观察者的状态CREATED -> STARTED;
while第三次循环：分发ON_RESUME事件，观察者的状态STARTED -> RESUMED；

不过，建议是最好在onCreate方法中进行注册。

组件生命周期的Observer可以有多个，但是需要维护好它们的状态，每次添加新的Observer的初始状态都是INITIALIZED，之后需要把它同步到当前的生命周期状态。在稳定的状态下，也就是说没有生命周期状态的变化，没有添加新的Observer，mObserverMap中的所有观察者都应该处于同一个生命周期状态。

在ReportFragment中调用了LifecycleRegistry.handleLifecycleEvent(event)来分发Lifecycle.Event事件，以下是相关源码：

public class LifecycleRegistry extends Lifecycle {
  
  public void handleLifecycleEvent(@NonNull Event event) {
    this.enforceMainThreadIfNeeded("handleLifecycleEvent");
    // 1. 根据要分发的事件，获取组件目前处于什么状态
    this.moveToState(event.getTargetState());
  }

  private void moveToState(State next) {
    if (this.mState != next) {
      this.mState = next;
      if (!this.mHandlingEvent && this.mAddingObserverCounter == 0) {
        this.mHandlingEvent = true;
        // 2. 将组建的状态同步给观察者
        this.sync();
        this.mHandlingEvent = false;
      } else {
        this.mNewEventOccurred = true;
      }
    }
  }

  private void sync() {
    LifecycleOwner lifecycleOwner = (LifecycleOwner)this.mLifecycleOwner.get();
    if (lifecycleOwner == null) {
      throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is alreadygarbage collected. It is too late to change lifecycle state.");
    } else {
      while(!this.isSynced()) {
        this.mNewEventOccurred = false;
        // 3. 如果组件的状态小于mObserverMap集合中最早添加的那个Observer状态，说明组件发生了状态回退。比如说，之前的状态是RESUMED，执行了onPause()方法后，状态回到了STARTED，此时调用backwardPass方法，给集合中的每个Observer分发一个ON_PAUSE事件，并同步它的状态
        if (this.mState.compareTo(((LifecycleRegistry.ObserverWithState)this.mObserverMap.eldest().getValue()).mState) < 0) {
          this.backwardPass(lifecycleOwner);
        } 

        Entry<LifecycleObserver, LifecycleRegistry.ObserverWithState> newest = this.mObserverMap.newest();
         // 4. 如果组件的状态大于mObserverMap集合中最早添加的那个Observer状态，说明组件发生了状态前进，比如说，之前是STARTED，执行了onResume()方法后，状态前进到了RESUMED，此时调用forwardPass方法，给集合中的每个Observer分发一个ON_RESUMED事件，并同步它的状态
        if (!this.mNewEventOccurred && newest != null && this.mState.compareTo(((LifecycleRegistry.ObserverWithState)newest.getValue()).mState) > 0) {
          this.forwardPass(lifecycleOwner);
        }
      }

      this.mNewEventOccurred = false;
    }
  }
}


public abstract class Lifecycle {
  public static enum Event {
    @NonNull
    public Lifecycle.State getTargetState() {
      switch(this) {
        case ON_CREATE:
        case ON_STOP:
          return Lifecycle.State.CREATED;
        case ON_START:
        case ON_PAUSE:
          return Lifecycle.State.STARTED;
        case ON_RESUME:
          return Lifecycle.State.RESUMED;
        case ON_DESTROY:
          return Lifecycle.State.DESTROYED;
        case ON_ANY:
        default:
          throw new IllegalArgumentException(this + " has no target state");
      }
    }
  }
}

3.4 `LifecycleObserver`：`Lifecycle`的观察者

LifecycleObserver是一个空方法接口，只需要进行一下接口实现声明就可以了，不需要重写任何方法。 以下是LifecycleObserver的源码：

public interface LifecycleObserver { }

在实现LifecycleOwner接口的类中（如Activity/Fragment），通过getLifecycle().addObserver(LifecycleObserver o)对实现LifecycleObserver接口的类进行注册（通过注解的方式），被注册后，LifecycleObserver就可以观察LifecycleOwner的生命周期。

4 生命周期感知型组件的最佳做法

使界面控制器（Activity和Fragment）尽可能保持精简。它们不应试图获取自己的数据，而应使用ViewModel执行此操作，并观察 LiveData对象以将更改体现到视图中；
设法编写数据驱动型界面，对于此类界面，界面控制器的责任是随着数据更改而更新视图，或者将用户操作通知给ViewModel；
将数据逻辑放在ViewModel类中。ViewModel应充当界面控制器与应用其余部分之间的连接器。不过要注意，ViewModel不负责获取数据（例如，从网络获取）。但是，ViewModel应调用相应的组件来获取数据，然后将结果提供给界面控制器；
使用数据绑定在视图与界面控制器之间维持干净的接口。这样一来，可以使视图更具声明性，并尽量减少需要在Activity和Fragment中编写的更新代码；
如果界面很复杂，可以考虑创建presenter类来处理界面的修改；
避免在ViewModel中引用 View 或 Activity 上下文。如果 ViewModel 存在的时间比Activity更长（在配置更改的情况下），Activity将泄漏并且不会获得垃圾回收器的妥善处置；
使用Kotlin协程管理长时间运行的任务和其他可以异步运行的操作；

5 生命周期感知型组件的用例

生命周期感知型组件可以在各种情况下更轻松地管理生命周期。下面列举几个例子：

在粗粒度和细粒度位置更新之间切换。使用生命周期感知型组件可在位置应用可见时启用细粒度位置更新，并在应用位于后台时切换到粗粒度更新。借助生命周期感知型组件LiveData，应用可以在用户使用位置发生变化时自动更新界面；
停止和开始视频缓冲。使用生命周期感知型组件可尽快开始视频缓冲，但会推迟播放，直到应用完全启动。此外，应用销毁后，还可以使用生命周期感知型组件终止缓冲；
开始和停止网络连接。借助生命周期感知型组件，可在应用位于前台时启用网络数据的实时更新（流式传输），并在应用进入后台时自动暂停。
暂停和恢复动画可绘制资源。借助生命周期感知型组件，可在应用位于后台时暂停动画可绘制资源，并在应用位于前台后恢复可绘制资源。

6 处理`ON_STOP`事件

如果Lifecycle属于 AppCompatActivity 或 Fragment，那么调用 AppCompatActivity 或 Fragment 的 onSaveInstanceState() 时，Lifecycle的状态会更改为CREATED并且会分派ON_STOP事件。

通过 onSaveInstanceState() 保存 Fragment 或 AppCompatActivity 的状态后，其界面被视为不可变，直到调用ON_START。如果在保存状态后尝试修改界面，很可能会导致应用的导航状态不一致，因此应用在保存状态后运行 FragmentTransaction 时，FragmentManager 会抛出异常。

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 类中的调用顺序不符。

参考

https://developer.android.google.cn/topic/libraries/architecture/lifecycle
https://liuwangshu.cn/application/jetpack/2-lifecycle-use.html
https://liuwangshu.cn/application/jetpack/2-lifecycle-use.html
https://developer.android.google.cn/topic/libraries/architecture/lifecycle
Jetpack 之 LifeCycle 组件原理解析
 硬核讲解 Jetpack 之 LifeCycle 源码篇

橙子19911016

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Jetpack（三）—— Lifecycle

Lifecycles在编写Android应用程序的时候，可能会经常遇到需要感知Activity生命周期的情况。比如说，某个界面中发起了一条网络请求，但是当请求得到响应的时候，界面或许已经关闭了，这个时候就不应该继续对响应的结果进行处理。因此，需要能够时刻感知到Activity的生命周期，以便在适当的时候进行相应的逻辑控制。在一个Activity中去感知它的生命周期非常简单，而如果要在一个非Activity的类中去感知Activity的生命周期，应该怎么办呢？这种需求是广泛存在的，同时也衍生出了一系列的
复制链接

扫一扫