public class MyObserver implements LifecycleObserver {
private final static String TAG = MyObserver.class.getSimpleName();
@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void ready(){
Log.e(TAG,“ON_START”);
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void connectListener() {
Log.e(TAG,“ON_RESUME”);
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
public void disconnectListener() {
Log.e(TAG,“ON_PAUSE”);
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
public void destroyListener() {
Log.e(TAG,“ON_DESTROY”);
}
}
然后在Activity当中调用:getLifecycle().addObserver(new MyObserver());
运行,启动AC,home返回桌面,再返回,再back关闭AC,打印输出:
![在这里插入图片描述](https://img-blog.csdnimg.cn/20210414001614842.jpg?x-oss-process=image/watermark
《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》
【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享
,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x5YWJjMTIzNDU2,size_16,color_FFFFFF,t_70)
我们发现LifecycleOwner
这个接口可以帮助我们摆脱Activity之外独立监听Activity的生命周期,
点击 getLifecycle() 方法,发现:
没错,就是在SupportActivity类当中的 LifecycleRegistry这个类的对象
LifecycleRegistry 又是神马?
预览一下它的几个方法:
LifecycleRegistry就像状态机一样,来管理和切换Ac的各个生命周期状态的,每个生命周期都有状态常量与之一一对应,那AC又是如何调用LifecycleRegistry的呢?
在 SupportActivity 的onCreate方法当中:
public class SupportActivity extends Activity implements LifecycleOwner, Component {
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}
@CallSuper
protected void onSaveInstanceState(Bundle outState) {
this.mLifecycleRegistry.markState(State.CREATED);
super.onSaveInstanceState(outState);
}
关键是这一行:ReportFragment.injectIfNeededIn(this);,那这个 ReportFragment又是神马?
就是一个Fragment类,而且不是v4包的,是原生包里的,继续看:
它的每个生命周期方法中都会调用 dispatch(Lifecycle.Event event) 方法:
这里调用了 LifecycleRegistry 的 handleLifecycleEvent 方法,而handleLifecycleEvent 方法当中其实就是进行对应生命周期状态的切换了。我们知道Activity 会自动调用 Fragment 的生命周期,这样就完成了生命周期的无感知监听,利用了一个隐式的无UI界面的Fragment对象来巧妙的实现的。
上面是 SupportActivity 的,那普通 Activity 呢?怎么调用 LifecycleRegistry 的?
对于 26.1.0 以后的版本,你会发现,对于普通的 Activity
,如果你想要使用 lifecycle
,你只需要实现LifecycleOwner
接口即可。
从上面的代码也可以看出来,只要Activity
是LifecycleOwner
的实现类,就会调用它的getLifecycle()
方法获得LifecycleRegistry
对象自动处理,而则一切都发生在ReportFragment
这个类里面,所以关键就是普通 Activity
如何跟ReportFragment
绑定的?
其实是在 LifecycleDispatcher 类当中调用的:
class LifecycleDispatcher {
private static AtomicBoolean sInitialized = new AtomicBoolean(false);
static void init(Context context) {
if (sInitialized.getAndSet(true)) {
return;
}
((Application) context.getApplicationContext())
.registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
}
@SuppressWarnings(“WeakerAccess”)
@VisibleForTesting
static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
ReportFragment.injectIfNeededIn(activity);
}
@Override
public void onActivityStopped(Activity activity) {
}
@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
}
}
private LifecycleDispatcher() {
}
}
可以看到,它 在 init 方法中,通过 context.getApplicationContext() .registerActivityLifecycleCallbacks 监听全局 activity
的创建,在 activity
onCreate
回调的时候,还是调用 ReportFragment.injectIfNeededIn(activity) ,从而来添加 fragment
对象,进而分发相应的事件。
那 LifecycleDispatcher.init 方法又是在哪里调用的呢?
public class ProcessLifecycleOwnerInitializer extends ContentProvider {
@Override
public boolean onCreate() {
LifecycleDispatcher.init(getContext());
ProcessLifecycleOwner.init(getContext());
return true;
}
它是在 ProcessLifecycleOwnerInitializer 的 onCreate 方法中调用的。而 ProcessLifecycleOwnerInitializer 是一个 ContentProvider。
而 ContentProvider 的 onCreate 方法优先于 Application 的 onCreate 执行,所以在 Application 之前我们就调用了 ProcessLifecycleOwnerInitializer init 方法,监听了 Activity 的创建,当 Actiivty 创建的时候,会尝试为 Activity 添加 ReportFragment
。后续就通过 ReportFragment
监听 Activity 的生命周期变化。
关于_ContentProvider 的 onCreate 方法优先于 Application 的 onCreate 执行_,可以参考这里。
所以,如果在普通 Actiivty 当中使用前面定义的 MyObserver
来监听,可以直接像下面这样写:
搞个Activity基类也可以,这样使用体验就跟 AppCompatActivity
的子类一样了
建议还是直接继承 AppCompatActivity
这种类似的 support v4 / v7
包 中的Activity类,或者androidx里面的Activity类,方便些。
这里需要注意的是 LifecycleDispatcher
和 ProcessLifecycleOwnerInitializer
在androidx
当中是自带的,但是如果没有使用androidx
需要自己添加一个扩展依赖:
dependencies {
implementation fileTree(dir: ‘libs’, include: [’*.jar’])
implementation “com.android.support:appcompat-v7:28.0.0”
//LifecycleDispatcher和ProcessLifecycleOwnerInitializer在这个库当中
implementation ‘android.arch.lifecycle:extensions:1.1.1’
//implementation ‘android.arch.lifecycle:runtime:1.1.1’//这个不加好像也会默认引入
}
大致过程,借用道友的一张图:
另外,使用 ProcessLifecycleOwner 可以在Application层级监听app的前后台状态切换:
public class App extends Application {
@Override
public void onCreate() {
super.onCreate();
ProcessLifecycleOwner.get().getLifecycle().addObserver(new MyAppObserver());
}
}
其中ProcessLifecycleOwner
类同样实现了 LifecycleOwner
接口:
观察者类同样继承LifecycleObserver
,连使用的注解也是一样的: