Android Jetpack（3）：Lifecycle

qq_36699930

已于 2022-10-28 18:09:53 修改

阅读量425

点赞数

分类专栏： Jetpack+MVVM 文章标签： Lifecycles Lifecycle android

于 2020-11-14 23:23:15 首次发布

本文链接：https://blog.csdn.net/qq_36699930/article/details/109697624

版权

Jetpack+MVVM 专栏收录该内容

9 篇文章 4 订阅

订阅专栏

Lifecycle介绍

什么是Lifecycle？

LifeCycle是GoogleApp架构中推荐的一个组件。Lifecycles 包含有关Activity与Fragment生命周期状态的信息，并允许其他对象观察此状态。

Lifecycle组件包括LifecycleOwner、LifecycleObserver。

Lifecycle作用

简单的说就是用来监听Activity与Fragment的生命周期变化，在变化时能及时通知其他组件。
Lifecycle可以有效的避免内存泄漏和解决android生命周期的常见难题。

为什么要引进Lifecycle？

前面说了，Lifecycle能够让开发者构建能感知其他组件（主要指Activity 、Fragment）生命周期的类。在android开发的过程中，我们常常需要让一些操作能够感知Activity/Fragment的生命周期，从而实现在活动状态下允许操作，而在销毁状态下需要自动禁止操作，释放资源，防止内存泄露。

例如大名鼎鼎的图片加载框架 Glide 在 Acticiy/Fragment 处于前台的时候加载图片，而在不可见的状态下停止图片的加载，又例如我们希望 RxJava 的 Disposable 能够在Activity/Fragment 销毁是自动 dispose。Lifecycle 的出现，让开发者们能够轻易地实现上述的功能。

在我们的开发中，我们经常需要知道 activity 的生命周期，从而做一些资源释放或控制逻辑，Glide的做法，就是给activity添加一个隐形的 fragment，从而感知 activity 的生命周期变化。

但Lifecycles 组件可以让任何一个类都能轻松感觉到 activity 的生命周期，但却不用编写太多逻辑。

场景

在使用mvp写页面时，p中需要感知Activity或Fragment的生命周期，以进行对应的处理。在这种情况下，Activity或Fragment会在各个生命周期的回调中调用p对应的方法，这是比较麻烦的。
自定义View需要对页面生命周期变化进行对应的处理，如动画的开始和结束，页面销毁时释放资源等。这种情况下，同样需要在Activity或Fragment的生命周期回调中调用View的各个方法。
在使用mvp时，p在收到某个通知时需要判断当前页面的生命周期状态，在这种情况下，需要维护一个记录当前生命状态的变量，也是比较麻烦的。

mvp模式中，p感知Activity或Fragment的生命周期的方式

一项新的技术的提出肯定是为了解决痛点问题，如果使用过MVP模式的话，有个问题：Presenter感知Activity或者Fragment的生命周期？你可能会这样做，Presenter中定义多个和Activity或者Fragment相应的生命周期方法，然后在Activity或者Fragment中调用Presenter中定义的方法。比如下面的这个例子：

Presenter监听某个 Activity 生命周期的变化

interface IPresenter {

    fun onCreate()
    fun onStart()
    fun onResume()
    fun onPause()
    fun onStop()
    fun onDestory()
}

class MainPresenter : IPresenter {

    private val TAG = "MainPresenter"

    override fun onCreate() {
        Log.e(TAG, "onCreate: ");
    }

    override fun onStart() {
        Log.e(TAG, "onStart: ");
    }

    override fun onResume() {
        Log.e(TAG, "onResume: ");
    }

    override fun onPause() {
        Log.e(TAG, "onPause: ");
    }

    override fun onStop() {
        Log.e(TAG, "onStop: ");
    }

    override fun onDestory() {
        Log.e(TAG, "onDestory: ");
    }
}

class MainActivity : AppCompatActivity() {

    private val mMainPresenter by lazy { MainPresenter() }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        mMainPresenter.onCreate()
    }

    override fun onStart() {
        super.onStart()
        mMainPresenter.onStart()
    }

    override fun onResume() {
        super.onResume()
        mMainPresenter.onResume()
    }

    override fun onPause() {
        super.onPause()
        mMainPresenter.onPause()
    }

    override fun onStop() {
        super.onStop()
        mMainPresenter.onStop()
    }

    override fun onDestroy() {
        super.onDestroy()
        mMainPresenter.onDestory()
    }
}

打印结果：

11-14 22:20:15.872 8336-8336/com.example.jetpack E/MainPresenter: onCreate: 
11-14 22:20:15.872 8336-8336/com.example.jetpack E/MainPresenter: onStart: 
11-14 22:20:15.873 8336-8336/com.example.jetpack E/MainPresenter: onResume: 
11-14 22:20:36.427 8336-8336/com.example.jetpack E/MainPresenter: onPause: 
11-14 22:20:36.877 8336-8336/com.example.jetpack E/MainPresenter: onStop: 
11-14 22:20:36.877 8336-8336/com.example.jetpack E/MainPresenter: onDestory:

通过这么一个简单的例子，我们可以看出，实现流程虽然很简单，但是代码实现繁琐，不够灵活，且代码侵入性太强。该例子只是展示了Present监听Activity生命周期，如果说还有类1，类2，类3……想要监听Activity的生命周期，那么就要在Activity的回调中添加对类1，类2，类3……的回调。这就引起了一个思考，我们是否能够实现Activity在生命周期发生变化时主动通知需求方的功能呢？可以的，答案就是Lifecycle。

Lifecycle的依赖

官方文档

//	implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'//已经废弃
	implementation 'androidx.lifecycle:lifecycle-runtime:2.3.0-alpha05'
	kapt "androidx.lifecycle:lifecycle-common-java8:2.3.0-alpha05"

高版本AS默认创建项目的时候，core\appcompat的androidx依赖库即包含对应lifecycle的依赖，所以可以不添加上面的依赖。

   implementation 'androidx.core:core-ktx:1.3.2'
   implementation 'androidx.appcompat:appcompat:1.2.0'

查看依赖库结构命令：

gradlew moduleName:dependencies     windows
./gradlew moduleName:dependencies    MAC

Lifecycle的使用方式

使用方式1

让要感知Activity生命周期的类实现LifecycleObserver 接口

先让MainPresenter实现LifecycleObserver接口，同时在每一个方法实现上增加@OnLifecycleEvent(Lifecycle.Event.XXXX）注解，OnLifecycleEvent对应了Activity的生命周期方法：

interface IPresenter : LifecycleObserver {

    fun onCreate(owner: LifecycleOwner)
    fun onStart(owner: LifecycleOwner)
    fun onResume(owner: LifecycleOwner)
    fun onPause(owner: LifecycleOwner)
    fun onStop(owner: LifecycleOwner)
    fun onDestory(owner: LifecycleOwner)
    fun onAny(owner: LifecycleOwner,event: Lifecycle.Event)
}

class MainPresenter : IPresenter, LifecycleObserver {

    private val TAG = "MainPresenter"

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    override fun onCreate(owner: LifecycleOwner) {
        Log.e(TAG, "onCreate: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    override fun onStart(owner: LifecycleOwner) {
        Log.e(TAG, "onStart: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    override fun onResume(owner: LifecycleOwner) {
        Log.e(TAG, "onResume: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    override fun onPause(owner: LifecycleOwner) {
        Log.e(TAG, "onPause: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    override fun onStop(owner: LifecycleOwner) {
        Log.e(TAG, "onStop: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    override fun onDestory(owner: LifecycleOwner) {
        Log.e(TAG, "onDestory: ");
    }

    /**
     * Lifecycle.Event.ON_ANY:任何生命周期都会走这个方法
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    override fun onAny(owner: LifecycleOwner, event: Lifecycle.Event) {
        Log.e(TAG, "onAny: ${event.name}")
    }
}

然后在需要监听的 Activity 中注册：

很简单，一行代码即可，上面说过了AppCompatActivity已经实现了LifeCycleOwner接口。

class MainActivity : AppCompatActivity() {

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

        lifecycle.addObserver(MainPresenter())  //添加监听对象
    }
}

运行结果：

运行过后，在Activity执行 OnResume和OnPause等方法的时候，就会Log出对应的信息。

2021-08-23 07:02:13.208 3036-3036/com.zly.ktdemo E/MainPresenter: onCreate: 
2021-08-23 07:02:13.208 3036-3036/com.zly.ktdemo E/MainPresenter: onAny: ON_CREATE
2021-08-23 07:02:13.215 3036-3036/com.zly.ktdemo E/MainPresenter: onStart: 
2021-08-23 07:02:13.215 3036-3036/com.zly.ktdemo E/MainPresenter: onAny: ON_START
2021-08-23 07:02:13.219 3036-3036/com.zly.ktdemo E/MainPresenter: onResume: 
2021-08-23 07:02:13.220 3036-3036/com.zly.ktdemo E/MainPresenter: onAny: ON_RESUME
2021-08-23 07:03:04.796 3036-3036/com.zly.ktdemo E/MainPresenter: onPause: 
2021-08-23 07:03:04.796 3036-3036/com.zly.ktdemo E/MainPresenter: onAny: ON_PAUSE
2021-08-23 07:03:05.617 3036-3036/com.zly.ktdemo E/MainPresenter: onStop: 
2021-08-23 07:03:05.617 3036-3036/com.zly.ktdemo E/MainPresenter: onAny: ON_STOP
2021-08-23 07:03:05.619 3036-3036/com.zly.ktdemo E/MainPresenter: onDestory: 
2021-08-23 07:03:05.619 3036-3036/com.zly.ktdemo E/MainPresenter: onAny: ON_DESTROY

是不是很简单，我们希望 MainPresent 感知监听 Activity 的生命周期，只需要在Activity中调用一句 getLifecycle().addObserver(new MyPresent()) 就可以了。

使用方式2

继承GenericLifecycleObserver（已过时，计划在lifecycle 3.0已移除）

让要感知Activity的类实现GenericLifecycleObserver接口（已过时）。

@SuppressLint("RestrictedApi")
class MainPresenter : GenericLifecycleObserver {

    private val TAG = "MainPresenter"

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_CREATE -> Log.e(TAG, "onCreate: ")
            Lifecycle.Event.ON_START -> Log.e(TAG, "onStart: ")
            Lifecycle.Event.ON_RESUME -> Log.e(TAG, "onResume: ")
            Lifecycle.Event.ON_PAUSE -> Log.e(TAG, "onPause: ")
            Lifecycle.Event.ON_STOP -> Log.e(TAG, "onStop: ")
            Lifecycle.Event.ON_DESTROY -> Log.e(TAG, "onDestory: ")
        }
    }
}

public class MainActivity extends AppCompatActivity {
class MainActivity : AppCompatActivity() {

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

        lifecycle.addObserver(MainPresenter())
    }
}

使用方式3

继承LifecycleEventObserver

继承GenericLifecycleObserver的方式已过时，我们可以继承LifecycleEventObserver：

class MainPresenter : LifecycleEventObserver {

    private val TAG = "MainPresenter"

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_CREATE -> Log.e(TAG, "onCreate: ")
            Lifecycle.Event.ON_START -> Log.e(TAG, "onStart: ")
            Lifecycle.Event.ON_RESUME -> Log.e(TAG, "onResume: ")
            Lifecycle.Event.ON_PAUSE -> Log.e(TAG, "onPause: ")
            Lifecycle.Event.ON_STOP -> Log.e(TAG, "onStop: ")
            Lifecycle.Event.ON_DESTROY -> Log.e(TAG, "onDestory: ")
        }
    }
}

自定义LifecycleOwner

上面说了，AppCompatActivity与Fragment都已默认实现了LifeCyclerOwner接口，基本上可以应对所有的情况了。

如果您要创建自定义类，则 LifecycleOwner可以使用 LifecycleRegistry 类，但需要将事件转发到该类，如以下代码示例所示：

public class MyActivity extends Activity implements LifecycleOwner {

    private LifecycleRegistry mLifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mLifecycleRegistry = new LifecycleRegistry(this);
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
		
		 //添加观察者
        getLifecycle().addObserver(new MyObserver());
    }

    @Override
    public void onStart() {
        super.onStart();
        mLifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

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

创建观察者

public class MyObserver implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        LogUtils.i("MyObserver","onCreate");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        LogUtils.i("MyObserver","onStart");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        LogUtils.i("MyObserver","onResume");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        LogUtils.i("MyObserver","onPause");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        LogUtils.i("MyObserver","onStop");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestory() {
        LogUtils.i("MyObserver","onDestory");
    }

//    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
//    public void onAny() {
//        LogUtils.i("MyObserver","onAny");
//    }
}

判断当前处在的生命周期

Lifecycle允许其他的对象判断当前的生命周期状态。方法如下：

lifecycle.addObserver(MainPresenter(lifecycle))

class MainPresenter(private val lifecycle: Lifecycle) : IPresenter,LifecycleObserver {

    private val TAG = "MainPresenter"

    fun enable() {
        if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
            // connect if not connected
        }
    }
 }

这个方法不是用来判断是否处于某个状态，而且用来判断是否到达了某个状态。

写个简单的媒体播放感知Activity生命周期案例

不使用Lifecycle实现

class MockMediaPlayer {

    private lateinit var player: MediaPlayer

    fun onCreate() {
        player = MediaPlayer()
        Log.e("MockMediaPlayer", "onCreate")
    }

    fun onResume() {
        thread {
            SystemClock.sleep(3000)//模拟阻塞1s
            player.start()
            Log.e("MockMediaPlayer", "onResume")
        }
    }

    fun onPause() {
        player.stop()
        Log.e("MockMediaPlayer", "onPause")
    }

    fun onDestroy() {
        player.release()
        Log.e("MockMediaPlayer", "onDestroy")
    }
}

class MainActivity : AppCompatActivity() {

    private val mockMediaPlayer=MockMediaPlayer()

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

        mockMediaPlayer.onCreate()

    }

    override fun onResume() {
        super.onResume()

        mockMediaPlayer.onResume()
    }

    override fun onPause() {
        super.onPause()

        mockMediaPlayer.onPause()
    }

    override fun onDestroy() {
        super.onDestroy()

        mockMediaPlayer.onDestroy()
    }
}

使用LifecycleObserver实现

class MockMediaPlayer2(private val owner: LifecycleOwner) : LifecycleObserver {

    private lateinit var player: MediaPlayer

    init {
        //关联生命周期的观察者
        owner.lifecycle.addObserver(this)
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate() {
        player = MediaPlayer()
        Log.e("MockMediaPlayer2", "onCreate")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume() {
        thread {

            SystemClock.sleep(3000)//模拟阻塞1s
            if (owner.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
                player.start()
                Log.e("MockMediaPlayer2", "onResume")
            }
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() {
        player.stop()
        Log.e("MockMediaPlayer2", "onPause")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() {
        player.release()
        Log.e("MockMediaPlayer2", "onDestroy")
    }
}

class MainActivity : AppCompatActivity() {


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

        MockMediaPlayer2(this)
    }

}

使用LifecycleEventObserver实现

class MockMediaPlayer3(private val owner: LifecycleOwner) : LifecycleEventObserver {

    private lateinit var player: MediaPlayer

    init {
        //关联生命周期的观察者
        owner.lifecycle.addObserver(this)
    }

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_CREATE -> {
                Log.e("MockMediaPlayer3", "onCreate")
                player = MediaPlayer()
            }
            Lifecycle.Event.ON_START, Lifecycle.Event.ON_RESUME -> {
                if (owner.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
                    player.start()
                    Log.e("MockMediaPlayer3", "onResume")
                }
            }
            Lifecycle.Event.ON_PAUSE, Lifecycle.Event.ON_STOP -> {
                player.stop()
                Log.e("MockMediaPlayer3", "onPause")
            }
            Lifecycle.Event.ON_DESTROY -> {
                player.release()
                Log.e("MockMediaPlayer3", "onDestroy")
            }
            Lifecycle.Event.ON_ANY -> Log.e("MockMediaPlayer3", "onAny")
        }
    }

}

class MainActivity : AppCompatActivity() {


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

        MockMediaPlayer3(this)
    }

}

Lifecycle原理

原理：

观察者模式+反射+注解。

简单来说就是：通过反射获取需要感知Activity生命周期的类中所有的有@OnLifecycleEvent注解的方法，把该类的相关信息：注解的值（即Lifecycle.Event）和方法对象（Method）保存起来，然后Activity上添加一个透明无界面的Fragment来监听Activity的生命周期，Activity生命周期变化时通过反射调用相对应的方法。

Lifecycle框架使用观察者模式实现观察者监听被观察者的生命周期的变化。

在这里插入图片描述

Lifecycle几个相关的类

Lifecycle：表示一个生命周期过程对象，可以添加生命周期观察者，可以看作被观察者。
LifecycleRegistry：Lifecycle的子类，对Lifecycle中的抽象方法进行了实现。
LifecycleOwner：生命周期的拥有者，一般是Activity和Fragment实现这个接口，只有一个方法getLifecycle()。
LifecycleObserver：生命周期观察者，虽是个空接口，但可以通过Lifecycle的注解定义所有的生命周期方法。用于观察查LifecycleOwner，可以是任何类，常见的有mvp的p，自定义View等。实现该接口的类，通过注解的方式，可以通过被LifecycleOwner类的addObserver(LifecycleObservero)方法注册，被注册后，LifecycleObserver便可以观察到LifecycleOwner的生命周期事件。
Lifecycle.Event：生命周期对应的事件，和Activity/Fragment的相应生命周期回调一一对应，有ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、ON_STOP、ON_DESTROY、ON_ANY七种取值，一般和OnLifecycleEvent注解一起使用，用来在LifecycleObserver中标注方法属于哪个生命周期。
Lifecycle.State：Activity/Fragment生命周期所处状态，有DESTROYED、INITIALIZED、CREATED、STARTED、RESUMED。

我们可以这么理解，实现了LifecycleOwner的类就是被观察者，我们可以看源码（Returns the Lifecycle of the provider，生命周期的提供方，那么就可以认为是被观察），而LifecycleObserver可以是观察者。

Lifecycle源码

public abstract class Lifecycle {

        //注册LifecycleObserver （比如Presenter）
        public abstract void addObserver(@NonNull LifecycleObserver observer);
        //移除LifecycleObserver 
        public abstract void removeObserver(@NonNull LifecycleObserver observer);
        //获取当前状态
        public abstract State getCurrentState();

        public enum Event {
            ON_CREATE,
            ON_START,
            ON_RESUME,
            ON_PAUSE,
            ON_STOP,
            ON_DESTROY,
            ON_ANY
        }
        
       public enum State {
            DESTROYED,
            INITIALIZED,
            CREATED,
            STARTED,
            RESUMED;

            public boolean isAtLeast(@NonNull State state) {
                return compareTo(state) >= 0;
            }
       }
}

LifecycleRegistry

Lifecycle的子类。

public class LifecycleRegistry extends Lifecycle {
	.....
}

Event枚举

Activity/Fragment生命周期改变对应的事件。

public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY
    }

State枚举

Activity/Fragment执行完生命周期方后所处状态。

public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }

LifecycleOwner

AppCompatActivity与中的Fragment都已默认实现了LifeCyclerOwner接口，所以可以直接使用。

LifeCyclerOwner接口很简单，如下:

在这里插入图片描述

LifecycleOwner源码：

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

LifecycleOwner提供getLifecycle返回Lifecycle，该接口由ComponentActivity实现，提供了getLifecycle的实现。

LifecycleObserver

生命周期观察者需要实现LifeCycleObserver接口，这个接口没有任何方法。那他如何对生命周期进行观察呢？

答案是依赖注解–>OnLifecycleEvent

LifecycleObserver源码：

public interface LifecycleObserver {

}

OnLifecycleEvent注解

这个修饰方法的注解定义了一个Lifecycle.Event类型的值。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
    Lifecycle.Event value();
}

把观察者类中所有要观察Activity的生命周期方法的信息保存起来

通过反射获取需要感知Activity生命周期的类中所有的有@OnLifecycleEvent注解的方法，把该类的相关信息：注解的值（即Lifecycle.Event）和方法对象（Method）保存起来，然后Activity生命周期变化是通过反射调用相对应的方法。

Activity中通过 getLifecycle().addObserver(observe)进行关联，先看 getLifecycle()。

 getLifecycle().addObserver(MainPresenter())

观察者实现LifecycleObserver，实现需要的生命周期，在Activity、Fragment中添通过getLifecycle().addObserver加观察者。实际上调用的是ComponentActivity的getLifecycle方法返回mLifecycleRegistry。调用LifecycleRegistry的addObserver加观察者。

getLifecycle()

//ComponentActivity.java
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {
        
 private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
  
  //实际上返回的是 LifecycleRegistry 对象,LifecycleRegistry对象实际上继承了 Lifecycle
   @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

ComponentActivity 实现了LifecycleOwner接口，这意味着ComponentActivity 对象持有生命周期对象（Lifecycle），并可以通过LifecyclegetLifecycle()方法获取内部的Lifecycle对象。
LifecycleOwner实际上持有的是 LifecycleRegistry 对象。
LifecycleRegistry extends Lifecycle是Lifecycle的实现类，getLifecycle()方法所在类ComponentActivity。

public class LifecycleRegistry extends Lifecycle {
}

Lifecycle源码：

public abstract class Lifecycle {

        //注册LifecycleObserver （比如Presenter）
        public abstract void addObserver(@NonNull LifecycleObserver observer);
        //移除LifecycleObserver 
        public abstract void removeObserver(@NonNull LifecycleObserver observer);
        //获取当前状态
        public abstract State getCurrentState();

        public enum Event {
            ON_CREATE,
            ON_START,
            ON_RESUME,
            ON_PAUSE,
            ON_STOP,
            ON_DESTROY,
            ON_ANY
        }
        
       public enum State {
            DESTROYED,
            INITIALIZED,
            CREATED,
            STARTED,
            RESUMED;

            public boolean isAtLeast(@NonNull State state) {
                return compareTo(state) >= 0;
            }
       }
}

LifecycleRegistry.java的addObserver方法：

getLifecycle().addObserver实际上就是执行LifecycleRegistry的addObserver的方法添加观察者。

//LifecycleRegistry.java

//Activity当前状态
 private State mState;
 
 private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();
            
 @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
    	//初始化状态
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        //将观察者和初始化的值封装到ObserverWithState中
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        以观察者为key，statefulObserver为value放到hashMap集合中
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
 }

这里你会发现生成了一个ObserverWithState，然后放入FastSafeIterableMap里，这个类是一个自定义列表，用于保存观察者并可在遍历期间处理删除/添加。

ObserverWithState ：Activity的状态和observer的封装类

 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 = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

Lifecycling.lifecycleEventObserver(observer)：

    @NonNull
    static LifecycleEventObserver lifecycleEventObserver(Object object) {
          ....
          return new ReflectiveGenericLifecycleObserver(object);
    }

ReflectiveGenericLifecycleObserver：

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
    private final Object mWrapped;
    private final CallbackInfo mInfo;

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        //获取观察者的信息
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

    @Override
    public void onStateChanged(LifecycleOwner source, Event event) {
        mInfo.invokeCallbacks(source, event, mWrapped);
    }
}

getInfo()：

   CallbackInfo getInfo(Class klass) {
        CallbackInfo existing = mCallbackMap.get(klass);
        if (existing != null) {
            return existing;
        }
        existing = createInfo(klass, null);
        return existing;
    }

createInfo：通过反射获取观察者相关信息

    private CallbackInfo createInfo(Class klass, @Nullable Method[] declaredMethods) {
        Class superclass = klass.getSuperclass();
        Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();
        if (superclass != null) {
            CallbackInfo superInfo = getInfo(superclass);
            if (superInfo != null) {
                handlerToEvent.putAll(superInfo.mHandlerToEvent);
            }
        }

        Class[] interfaces = klass.getInterfaces();
        for (Class intrfc : interfaces) {
            for (Map.Entry<MethodReference, Lifecycle.Event> entry : getInfo(
                    intrfc).mHandlerToEvent.entrySet()) {
                verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass);
            }
        }
		
		//通过反射获取所有方法
        Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
        boolean hasLifecycleMethods = false;
        for (Method method : methods) {
            OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
            if (annotation == null) {
                continue;
            }
            hasLifecycleMethods = true;
            Class<?>[] params = method.getParameterTypes();
            int callType = CALL_TYPE_NO_ARG;
            if (params.length > 0) {
                callType = CALL_TYPE_PROVIDER;
                if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
                    throw new IllegalArgumentException(
                            "invalid parameter type. Must be one and instanceof LifecycleOwner");
                }
            }
            Lifecycle.Event event = annotation.value();

            if (params.length > 1) {
                callType = CALL_TYPE_PROVIDER_WITH_EVENT;
                if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
                    throw new IllegalArgumentException(
                            "invalid parameter type. second arg must be an event");
                }
                if (event != Lifecycle.Event.ON_ANY) {
                    throw new IllegalArgumentException(
                            "Second arg is supported only for ON_ANY value");
                }
            }
            if (params.length > 2) {
                throw new IllegalArgumentException("cannot have more than 2 params");
            }
            MethodReference methodReference = new MethodReference(callType, method);
            //保存到map集合
            verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
        }
        CallbackInfo info = new CallbackInfo(handlerToEvent);
        mCallbackMap.put(klass, info);
        mHasLifecycleMethods.put(klass, hasLifecycleMethods);
        return info;
    }

verifyAndPutHandler

    private void verifyAndPutHandler(Map<MethodReference, Lifecycle.Event> handlers,
            MethodReference newHandler, Lifecycle.Event newEvent, Class klass) {
        Lifecycle.Event event = handlers.get(newHandler);
        if (event != null && newEvent != event) {
            Method method = newHandler.mMethod;
            throw new IllegalArgumentException(
                    "Method " + method.getName() + " in " + klass.getName()
                            + " already declared with different @OnLifecycleEvent value: previous"
                            + " value " + event + ", new value " + newEvent);
        }
        if (event == null) {
            handlers.put(newHandler, newEvent);
        }
    }

Activity生命周期变化时是怎么通知观察者的

Activity上添加一个透明无界面的Fragment来监听Activity的生命周期，和glide的绑定生命周期比较类似。

//ComponentActivity.java
   @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mSavedStateRegistryController.performRestore(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }

ReportFragment.injectIfNeededIn(this);

public class ReportFragment extends Fragment {
    private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
            + ".LifecycleDispatcher.report_fragment_tag";

    public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            // On API 29+, we can register for the correct Lifecycle callbacks directly
            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();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }
}

再看ReportFragment的生命周期函数，你会发现都调用了dispatch()方法。
而dispatch()方法则会判断Activity是否实现了LifecycleOwner接口，如果实现了该接口就调用LifecycleRegister的handleLifecycleEvent()。这样生命周期的状态就会借由LifecycleRegistry通知给各个LifecycleObserver从而调用其中对应Lifecycle.Event的方法**。这种通过Fragment来感知Activity生命周期的方法其实在Glide的中也是有体现的。

public class ReportFragment extends 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);
        //生命周期变化时都会发出对应的事件
        dispatch(Lifecycle.Event.ON_CREATE);
    }

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

    @Override
    public void onResume() {
        super.onResume();
        dispatchResume(mProcessListener);
        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);
        // just want to be sure that we won't leak reference to an activity
        mProcessListener = null;
    }

    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  处理事件
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

}

handleLifecycleEvent方法

handleLifecycleEvent方法中State next=getStateAfter(event)，事件发生的时候，先得到当前activity执行当前生命周期后应该出现的下状态。

public class LifecycleRegistry extends Lifecycle {
 //  记录Activity当前状态
   private State mState;

   public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
    }

  public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
  		//Activity执行完对应的生命周期方法后所对应的Activity状态
        State next = getStateAfter(event); 
        moveToState(next); //移动状态，Activity是什么状态，对应得observer就要转换为相同的状态
    }
}

看方法的名字我们就可以知道，handleLifecycleEvent方法会通过 getStateAfter 获取当前应处的状态并修改 Lifecycle本身的State 值，紧接着遍历所 LifecycleObserver 并同步且通知其状态发生变化，因此就能触发LifecycleObserver 对应的生命周期事件。

为什么要有状态State?直接根据事件类型调用对应的方法不可以吗？

为了扩展，其他地方或者其他框架使用的时候可以直接获取当前activity所处的状态。所以多了一步转为状态。

getStateAfter

Activity执行完对应的生命周期方法后所对应的Activity状态

   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);
    }

在这里插入图片描述

moveToState(next)

   private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        mState = next; //当前状态赋值给mState
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;
        sync(); //同步状态
        mHandlingEvent = false;
    }

sync()：更新现在的状态

同步LifecycleOwner的状态到Lifecycleobserver，Activity是什么状态，对应得observer就要转换为相同的状态。因为observer要根据状态转为对应得事件类型，根据事件类型反射调用方法。

backwardPass(lifecycleOwner)：逆推，Activity要被销毁，

forwardPass(lifecycleOwner)：正推，Activity要显示出来，看图表上分析。

   private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                    + "garbage collected. It is too late to change lifecycle state.");
        }
        while (!isSynced()) { //还没有完成同步
            mNewEventOccurred = false;
            // no need to check eldest for nullability, because isSynced does it for us.
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            	// 如果ObserverWithState的state小于当前state，那么就调用backwardPass方法，
            	 //如果Activity当前状态要小于观察者者的状态，就表示Activity要销毁
                //那么就调用backwardPass方法。 逆推
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                 //如果Activity当前状态要大于观察者者的状态，就表示Activity要显示出来
                //那么就调用forwardPass方法。 正推
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

forwardPass(lifecycleOwner)方法中的细节

   private void forwardPass(LifecycleOwner lifecycleOwner) {
   		//获取保存的观察者信息
        Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
                mObserverMap.iteratorWithAdditions();
        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
            //找到ObserverWithState 类
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                pushParentState(observer.mState);
                //分发事件
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                popParentState();
            }
        }
    }

upEvent：把状态转换为相对应的事件，因为要根据事件调用对应得方法

   private static Event upEvent(State state) {
        switch (state) {
            case INITIALIZED:
            case DESTROYED:
                return ON_CREATE;
            case CREATED:
                return ON_START;
            case STARTED:
                return ON_RESUME;
            case RESUMED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }

接下来就是调用onStateChanged()，来通知实现了 LifecycleObserver的类，生命周期发生了变化

   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 = getStateAfter(event);
            mState = min(mState, newState);
            //通知实现了 LifecycleObserver的类，生命周期发生了变化
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

LifecycleEventObserver

LifecycleEventObserver 是LifecycleObserver 的子类，生命周期变化时会调用onStateChanged方法。

public interface LifecycleEventObserver extends LifecycleObserver {
 
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

查看实现类ReflectiveGenericLifecycleObserver.onStateChanged()

ReflectiveGenericLifecycleObserver的构造方法中就把LifecycleObserver中的方法和注解保存了下来，再通过onStateChanged()进行生命周期的方法的调用。

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
    private final Object mWrapped;
    private final CallbackInfo mInfo;

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

    @Override
    public void onStateChanged(LifecycleOwner source, Event event) {
    	//通过反射调用对应方法
        mInfo.invokeCallbacks(source, event, mWrapped);
    }
}

invokeCallbacks()

   void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
            invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
            invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
                    target);
        }
   private static void invokeMethodsForEvent(List<MethodReference> handlers,
                LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
            if (handlers != null) {
                for (int i = handlers.size() - 1; i >= 0; i--) {
                    handlers.get(i).invokeCallback(source, event, mWrapped);
                }
            }
        }

       void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
            //noinspection TryWithIdenticalCatches
            try {
                switch (mCallType) {
                    case CALL_TYPE_NO_ARG:
                        mMethod.invoke(target); //反射调用方法
                        break;
                    case CALL_TYPE_PROVIDER:
                        mMethod.invoke(target, source);
                        break;
                    case CALL_TYPE_PROVIDER_WITH_EVENT:
                        mMethod.invoke(target, source, event);
                        break;
                }
            } catch (InvocationTargetException e) {
                throw new RuntimeException("Failed to call observer method", e.getCause());
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }

流程：
在这里插入图片描述

qq_36699930

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Android Jetpack（3）：Lifecycle

什么是Lifecycle？LifeCycle是GoogleApp架构中推荐的一个组件。Lifecycles 包含有关Activity与Fragment生命周期状态的信息，并允许其他对象观察此状态。Lifecycle组件包括LifecycleOwner、LifecycleObserver。作用简单的说就是用来监听Activity与Fragment的生命周期变化，在变化时能及时通知其他组件。为什么要引进Lifecycle？前面说了，Lifecycle能够让开发者构建能感知其他组件（主要指Acti
复制链接

扫一扫