「Jetpack - Lifecycle梳理」

「Jetpack - Lifecycle梳理」

一、写在前面

谷歌推出Jetpack系列已经有一段时间了，作为AAC(Android Architecture Components)架构组件基础，使开发的过程越来越规范化，遵循谷歌推荐的最佳做法不仅使App更加健壮；体验更优。代码层面更加简洁(Jetpack内部帮我们处理了很多)优雅，消除了冗余的样板代码。

二、Lifecycle是什么？

• Lifecycle是一个抽象类，用于存储有关组件(Activity、Fragment)的生命周期状态的信息，并允许其他对象观察此状态。
• 使用两种主要的枚举跟踪相关组件的生命周期状态

• 从框架和Lifecycle类分派的生命周期事件。这些事件映射到 Activity 和 Fragment 中的回调事件。

• 由 Lifecycle 对象跟踪的组件的当前状态。
• 官网的结构图
  

三、使用依赖

添加相关组件的依赖

dependencies {
  val lifecycle_version = "2.4.0"
  //without ViewModel or LiveData
  implementation("androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version")
  //ViewModel(可选的)
  implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version")
  // LiveData(可选的)
  implementation("androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version")
}

一般的使用Lifecycle都会搭配ViewModel、LiveData一起使用，构建数据驱动UI型应用，可以说Lifecycle作为Jetpack的基石，循序渐进的去掌握有助于理解深刻。

四、生命周期的管理

• 生命周期的管理很重要

• 官方的使用Demo(获取定位信息)

internal class MyLocationListener(
  private val context: Context,
  private val callback: (Location) -> Unit
) {
  fun start() {
    //连接到定位服务器，connect to system location service
  }
  fun stop() {
    //断开与服务器的链接，disconnect from system location service
  }
}

class MyActivity : AppCompatActivity() {
  private lateinit var myLocationListener: MyLocationListener
  override fun onCreate(...) {
    myLocationListener = MyLocationListener(this) { location ->
    //update ui
   }
  }
  
  public override fun onStart() {
    super.onStart()
    myLocationListener.start()
  }
  
  public override fun onStop() {
    super.onStop()
    myLocationListener.stop()
  }
}

Demo的实现很简单，但是具有代表性，比较符合我们以往的**“开发习惯”**，虽然做到了对生命周期的管理，在合适的做到了资源的使用与释放，但是其实是存在问题的。

五、Lifecycle源码实现

1.Lifecycle

简单的概括一下：定义一个具有生命周期的对象。Fragment与FragmentActivity实现了LifecycleOwner接口，而接口中方法getLifecycle可以获得Lifecycle引用，开发者可以通过实现LifecycleOwner接口来自定义自己的生命周期组件，通过类中状态，如Lifecycle.Event.ON_START等完成对应的匹配，要观察生命周期的事件那么需要通过添加生命周期的观察者addObserver(LifecycleObserver)传递的是DefaultLifecycleObserver或者LifecycleEventObserver的实现类。

• 注释中解释的很清楚，Lifecycle相当于一个中转站，有什么作用呢？管理生命周期的组件，无论是系统的Fragment、Activity或者是开发自定义的组件(实现了LifecycleOwner接口)。当状态流转时，“中转站”内的组件的生命周期状态应该保持对应。看看源码中几个重要的方法：

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();
  
  public enum Event {
    ON_CREATE,ON_START,ON_PAUSE,ON_STOP,ON_DESTROY,ON_ANY;
    
    @Nullable
    public static Event downFrom(@NonNull State state) {
      switch (state) {
          case CREATED:
          	return ON_DESTROY;
          case STARTED:
          	return ON_STOP;
          case RESUMED:
          	return ON_PAUSE;
      }
    }
    //......
  }
  public enum State {
    DESTROYED,INITIALIZED,CREATED,STARTED,RESUMED;
    public boolean isAtLeast(@NonNull State state) {
      return compareTo(state) >= 0;
    }
  }
}

• 由之前给出的图，Lifecycle中定义了状态State与之对应的事件Event，将绑定的生命周期组件添加到中转站之中，随着状态主体LifecycleOwner状态的改变而获得对应的状态-addObserver()；同样的有添加就有移除操作removeObserver()。也就是说Owner的状态发生改变需要搭配LifecycleObserver才能被转发下去，典型的观察与订阅，首先不看LifecycleObserver具体实现。Lifecycle作为抽象类，看看其具体实现类。
• LifecycleRegistry实现类

public class LifecycleRegistry extends Lifecycle {
  //通过一个FastSafeIterableMap将观察者连同状态一起保存起来，保存调用addObserver()后存储的对象，这个map
  //系统自定义的结构，线程不安全，但是提供了在遍历时修改的功能。
  private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = 
    new FastSafeIterableMap<>();
  //当前的状态
  private State mState;
  //若引用持用了生命周期的组件
  private final WeakReference<LifecycleOwner> mLifecycleOwner;
  
  private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
    mLifecycleOwner = new WeakReference<>(provider);
    mState = INITIALIZED;
    mEnforceMainThread = enforceMainThread;
  }
  //设置当前状态
  @MainThread
  public void setCurrentState(@NonNull State state) {
    moveToState(state);
  }
  //处理生命周期事件
  public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    moveToState(event.getTargetState());
  }
  
  private void moveToState(State next) {
    if (mState == next) {
      return;
    }
    mState = next;
    if (mHandlingEvent || mAddingObserverCounter != 0) {
      mNewEventOccurred = true;
      return;
    }
    mHandlingEvent = true;
    sync();
    mHandlingEvent = false;
  }
  
  private boolean isSynced() {
    if (mObserverMap.size() == 0) {
            return true;
    }
    State eldestObserverState = mObserverMap.eldest().getValue().mState;
    State newestObserverState = mObserverMap.newest().getValue().mState;
    return eldestObserverState == newestObserverState && mState == newestObserverState;
  }
  
  private void sync() {
    //省略判空
    while (!isSynced()) {
      mNewEventOccurred = false;
      if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
        backwardPass(lifecycleOwner);
      }
       Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
         if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
      }
    }
    mNewEventOccurred = false;
  }
  
  private void forwardPass(LifecycleOwner lifecycleOwner) {
    //....
    observer.dispatchEvent(lifecycleOwner, event);
    //....
  }
  
  private void backwardPass(LifecycleOwner lifecycleOwner) {
    //...
    observer.dispatchEvent(lifecycleOwner, event);
    //...
  }
  
  static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;
    ObserverWithState(LifecycleObserver observer, State initialState) {
      mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
      mState = initialState;
    }
    void dispatchEvent(LifecycleOwner owner, Event event) {
      State newState = event.getTargetState();
      mState = min(mState, newState);
      mLifecycleObserver.onStateChanged(owner, event);
      mState = newState;
    }
  }
}

//Returns the Lifecycle.Event that will be reported by a Lifecycle leaving the specified //Lifecycle.State to a higher state, or null if there is no valid event that can move up //from the given state.
public static Event upFrom(@NonNull State state) {
  switch (state) {
     case INITIALIZED:
         return ON_CREATE;
     case CREATED:
         return ON_START;
     case STARTED:
         return ON_RESUME;
     default:
         return null;
  }
}

• dispatchEvent

无论是backwardPass还是forwardPass，最终都会执行到dispatchEvent方法，getTargetState通过计算对应的状态，通知到所有的观察者。而继承自LifecycleObserver的LifecycleEventObserver接口方法onStateChanged就完成了状态的更新操作。

2.LifecycleOwner

LifecycleOwner是一个接口，仅仅包含了一个方法。返回“生命周期”Lifecycle。

@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
  @NonNull
  Lifecycle getLifecycle();
  //The lifecycle of the provider.
}

既然是接口，那么看看实现类，以AppCompatActivity为例，而其完整的继承链路为：

直接查看ComponentActivity的实现细节，看看究竟是如何管理生命周期的。

public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner... {
  
  private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
  
  @NonNull
  @Override
  public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
  }
  
  @Override
  protected void onCreate(@Nullable Bundle savedInstanceState) {
     // Restore the Saved State first so that it is available to
     // OnContextAvailableListener instances
     mSavedStateRegistryController.performRestore(savedInstanceState);
     mContextAwareHelper.dispatchOnContextAvailable(this);
     super.onCreate(savedInstanceState);
     //ReportFragment注入
     ReportFragment.injectIfNeededIn(this);
     if (mContentLayoutId != 0) {
       setContentView(mContentLayoutId);
     }
   }
}

在ComponentActivity中仅仅只有一个生命周期方法onCreate()作了处理，而其他的生命周期方法并未有具体实现。那又是怎么管理生命周期的呢？跟预期显然是不符合的，但是注意到这个ReportFragment这个的注入。似曾相识，如果熟悉Glide图片加载库对生命周期的管理-无布局的Fragment注入。这里其实也做了同样的事情。看看是不是使用相似的方法来管理生命周期。

• ReportFragment

public class ReportFragment extends Fragment {
  public static void injectIfNeededIn(Activity activity) {
    if (Build.VERSION.SDK_INT >= 29) {
      activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks()));
    }
    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 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);
       }
     }
  }
	
  @Override
  public void onStart() {
    super.onStart();
    dispatchStart(mProcessListener);
    dispatch(Lifecycle.Event.ON_START);
  }
  //.....
}

总结一下：

• 自定义生命周期感知类

官方比较推荐的做法是实现DefaultLifecycleObserver接口

class MyObserver : DefaultLifecycleObserver {
    override fun onResume(owner: LifecycleOwner) {
        //do something
    }

    override fun onPause(owner: LifecycleOwner) {
        //do something
    }
}

myLifecycleOwner.getLifecycle().addObserver(MyObserver())

当然也可以配合LifecycleRegistry与LifecycleOwner实现更加细致的功能需求

class MyActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

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

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

    public override fun onStart() {
        super.onStart()
        lifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

六、文档

Jetpack-Lifecycle

Lifecycle

Modern Android Development