随着Android开发模式的成熟,组件化已经成为解耦复杂Activity的一个简单实用的方式,因为通过组件化可以大大降低一个Activity的代码复杂度,并且抽离成独立组件,实现代码分离,避免造成内存泄漏和应用崩溃。
那么如何实现组件生命周期同步Activity的生命周期?下面是一个BaseComponent实现和MainActivity生命周期同步的简单实现,相信很多人第一时间都会想到这么做或者类似的实现:
这样做看起来是没有问题,但是随着组件增加,在Activity每个生命周期里面都会放置大量代码,使得Activity维护变得艰难,在这种背景下,Google官方推出了Lifecycle组件以帮助开发者更加简洁地实现组件化。
在我们升级androidx之后,里面已经包含了lifecycle组件,如下图所示。
我们只需要使用到其中的LifecycleObserver和LifecycleOwner即可实现组件化监听Activity的生命周期,代码如下所示。
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
getLifecycle().addObserver(new BaseComponent());
}
}
public class BaseComponent implements LifecycleObserver {
private static final String TAG = "BaseComponent";
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void onCreate() {
Log.i(TAG, "onCreate");
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void onResume() {
Log.i(TAG, "onResume");
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
public void onStop() {
Log.i(TAG, "onStop");
}
}
如果大家只满足了解如何使用Lifecycle的层面,那么本篇文章就到此为止,下面主要是手把手带领大家了解它的底层实现,一探究竟。
在窥探源码之前,其实我们也能猜测到它的实现方式,就是利用非常常用的观察者者模式来实现,只不过它通过反射来实现注解调用。
首先我们了解一下LifeOwner和LifecycleObserver两个接口,LifeOwner的意思就是生命周期的持有者,即被观察者,对应于Activity和Fragment,LifecycleObserver就是生命周期观察者,对应于我们自定义的组件,它们都是接口,实现非常简单:
public interface LifecycleObserver {
}
public interface LifecycleOwner {
@NonNull
Lifecycle getLifecycle();
}
由于我们的Activity/Fragment是被观察者,所以在androidx里面,它们都实现了LifecycleOwner接口,所以它们要实现LifecycleOwner的接口getLifecycle(),返回一个Lifecycle实例,那么Lifecycle是什么呢?如下代码所示,它是一个抽象类,需要实现addObserver、removeObserver、getCurrentState三个抽象方法,其实非常好理解,它就是一个桥接观察者和被观察者的桥梁,负责处理两者关联的逻辑,而Lifecycle的唯一实现类就是LifecycleRegistry,我们下面再说。
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,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
@SuppressWarnings("WeakerAccess")
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
作为一个桥接者,LifecycleRegistry内部维护了一个状态值mState,它是枚举类型State,即Lifecycle里面定义的State,它具有DESTROYED、INITIALIZED、CREATED、STARTED、RESUMED五个状态。
public class LifecycleRegistry extends Lifecycle {
/**
* Current state
*/
private State mState;
}
设计者认为被观察者的生命周期就是从这五个状态循环执行,这五个状态转换过程就响应到观察者的Event的状态变化,即Lifecycle里面定义的ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、ON_STOP、ON_DESTROY、ON_ANY,也是我们比较容易理解的状态。怎么理解State和Event之间的转换关系呢?如下图所示,例如当LifecycleRegistry从CREATED变化到STARTED时,观察者就出发了ON_START事件。
这个图在LifecycleRegistry里面的代码也得到证实:
public class LifecycleRegistry extends Lifecycle {
static State getStateAfter(Event event) {
switch (event) {
case ON_CREATE:
case ON_STOP:
return CREATED;
case ON_START:
case ON_PAUSE:
return STARTED;
case ON_RESUME:
return RESUMED;
case ON_DESTROY:
return DESTROYED;
case ON_ANY:
break;
}
throw new IllegalArgumentException("Unexpected event value " + event);
}
private static Event downEvent(State state) {
switch (state) {
case INITIALIZED:
throw new IllegalArgumentException();
case CREATED:
return ON_DESTROY;
case STARTED:
return ON_STOP;
case RESUMED:
return ON_PAUSE;
case DESTROYED:
throw new IllegalArgumentException();
}
throw new IllegalArgumentException("Unexpected state value " + state);
}
}
那么什么情况下会触发Event变化,响应到观察者呢?就是handleLifecycleEvent方法,被观察者通过调用handleLifecycleEvent,从而触发Event的变化。
public class LifecycleRegistry extends Lifecycle {
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
}
那么是哪里调用handleLifecycleEvent的呢?就是来自于一个ReportFragment的dispatch方法,在ReportFragment的每个生命周期方法都会触发dispatch方法的调用,从而触发LifecycleRegistry的handleLifecycleEvent方法。
public class ReportFragment extends Fragment {
@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(Lifecycle.Event event) {
Activity activity = getActivity();
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肯定被Activity持有,没错,就是ComponentActivity会在创建的时候创建一个ReportFragment:
public class ComponentActivity extends Activity
implements LifecycleOwner, KeyEventDispatcher.Component {
@Override
@SuppressWarnings("RestrictedApi")
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}
}
而我们开发者使用的AppCompatActivity就是通过继承ComponentActivity实现的:
AppCompatActivity -> FragmentActivity -> ComponentActivity -> Activity
我们自定义的组件需要实现LifecycleObserver作为观察者,Activity/Fragment作为被观察者,它需要实现LifecycleOwner接口,并且需要实现一个Lifecycle子类LifecycleRegistry作为桥接观察者和被观察者的桥梁,并且在Activity里面实现了一个无界面的ReportFragment(生命周期与Activity同步)触发LifecycleRegistry里面的Event变化,从而通知到被观察者相应事件。