Android 中 JetPack(四)Lifecycle生命周期管理

笔墨Android
658 阅读3分钟

本文知识点:

  1. 为什么使用lifecycle
  2. lifecycle的简单使用
  3. 自定义生命周期感知组件

1. 为什么使用lifecycle

在没有jetpack前,我们处理生命周期是这样的:

  1. 直接在Activity中处理;
  2. 自己创建一个类,然后重写生命周期方法并在相应的生命周期方法中调用.

相比较第一种方式,第二种可维护性相对高一些,但是耦合性还是比较高.因为你在Activity必须持有相应的引用.可能有人会说使用dagger2.这样就能解决耦合的问题,其实没有什么不对的,但是dagger2相对的学习成本比较高.所以相对来说对开发的要求比较高.

以上种种是关于Activity的生命周期处理,但是我们为什么要使用lifecycle呢?

  1. 学习成本低;
  2. 耦合性比较低;
  3. 代码入侵性低.

developer.android.com/images/topi…

上图是lifecycle的事件流转.关于其中的事件流转都是和生命周期对应的.

以上这些都是我选择lifecycle的原因.不知道你们是怎么考虑的.如果有什么不同的意见,还请赐教...

2. lifecycle的简单使用

使用方法是这样的:

  1. 创建相应的LifecycleObserver实现类;
  2. 添加相应的观察者.

就这两步,你就能观测相应的Activity了. 你不信? 代码走起...

1. 创建相应的LifecycleObserver实现类;

kotlin代码示例:

class KotlinObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun resume() {
        Log.e("TAG", "connectListener: ON_RESUME" )
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun pause() {
        Log.e("TAG", "disconnectListener: ON_PAUSE" )
    }
}

java代码示例:

public class JavaObserver implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void resume() {
        Log.e("TAG", "connectListener: ON_RESUME");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void pause() {
        Log.e("TAG", "connectListener: ON_PAUSE");
    }
}

上面两个方法,其实两个方法的名字不重要,重要的是上面的那两个注解.关于注解,这里贴一下系统都提供了那些注解.

  • ON_CREATE
  • ON_START
  • ON_RESUME
  • ON_PAUSE
  • ON_STOP
  • ON_DESTROY
  • ON_ANY

上面的生命周期和Activity的生命周期都是对应的,最后一个其实就是在任何生命周期都会调用的.

2. 添加相应的观察者.

kotlin代码示例:

lifecycle.addObserver(KotlinObserver())

java代码示例:

 getLifecycle().addObserver(new JavaObserver());

这样你就能在打印的日志中看见相应的内容.

3. 自定义生命周期感知组件

其实这里关于自定义生命周期组件这里,如果这里你动了,那个基本上源码的整个流程你也会懂了.

先明确一个问题: AppCompatActivity -> FragmentActivity -> ComponentActivity -> androidx.core.app.ComponentActivity -> Activity

然后你看androidx.core.app.ComponentActivity的类中实现了LifecycleOwner.这个接口中就有一个方法Lifecycle getLifecycle();,然后在看他的实现.

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

就是返回了一个mLifecycleRegistry.然后你看它的创建.

  private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

然后你去FragmentActivity中寻找相应的设置方法,你会找到它调了一个setCurrentState ,其实这个就是在相应生命周期方法中调用的一个方法.

接下来我们仿照Activity写一个自定义的生命周期观察.

先明确一个问题,Activity没有实现LifecycleOwner这个接口,所以我们就拿他开发,这样我们如果能通过上面的JavaObserver和KotlinObserver进行观察,就说明我们自定义观察类成功了.

首先我们创建一个继承Activity的类.

kotlin代码示例:


class LifecycleKotlinActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

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

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
        lifecycle.addObserver(KotlinObserver())
    }

    override fun onResume() {
        super.onResume()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
        lifecycleRegistry.currentState = Lifecycle.State.RESUMED

    }

    override fun onStart() {
        super.onStart()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
    }

    override fun onPause() {
        super.onPause()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)

    }

    override fun onStop() {
        super.onStop()
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
    }

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

这样你会在KotlinObserver或者JavaObserver收到相应的回调.

其实这样就相当于自定义的逻辑了,至于相应的逻辑怎么处理.就只有在做的看官自己去实现了...

其实关于Lifecycle的东西不多.关于源码我没怎么看,等到后期有时间了.我在补上.

avatar
文章
阅读
粉丝