Android Jetpack -- Lifecycle

看到这些博客的时候,相信小伙伴们已经看了不少的有关于Android Jetpack的知识了,关于Jetpack的原理,有些文章讲的很好,这里就不重复了,此系列的博客,旨在通过一些很简单的小demo,和大家一起熟悉最基本的用法~

Android Jetpack -- Lifecycle

Android Jetpack -- ViewModel & LiveData

Android Jetpack -- paging & room

Android Jetpack -- navigation

项目git地址:https://github.com/zhangtiansimple/jetpack_demo

--------------------------------------------------------------------------------------------------------------------

先来看一个小栗子

有一个Presenter

class Presenter {

    fun create() {
        //TODO
    }

    fun destroy() {
        //TODO
    }
}

然后在Activity里

class MainActivity(val presenter: Presenter) : AppCompatActivity() {

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

        presenter.create()
    }

    override fun onDestroy() {
        super.onDestroy()

        presenter.destroy()
    }
}

这样写本身是没有问题的,但是随着业务逻辑的不断增多,越来越多的初始化及回收操作需要在onCreate和onDestory中完成,会导致这两个方法变得非常臃肿。

Lifecycle便应时而生,Lifecycle持有组件(Activity、Fragment等)的生命周期的状态信息,并且允许其他对象观察此状态。

而且实现也很简洁

首先定义IPresenter接口

interface IPresenter : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate(owner: LifecycleOwner)

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy(owner: LifecycleOwner)

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    fun onLifecycleChanged(
        owner: LifecycleOwner,
        event: Lifecycle.Event
    )
}

然后把想要观察到的声明周期事件封装到BasePresenter里

open class BasePresenter : IPresenter {

    val TAG = "BasePresenter"

    override fun onCreate(owner: LifecycleOwner) {
        Log.d(TAG, "onCreate")
    }

    override fun onDestroy(owner: LifecycleOwner) {
        Log.d(TAG, "onDestroy")
    }

    override fun onLifecycleChanged(owner: LifecycleOwner, event: Lifecycle.Event) {
    }
}

如此,每当MainActivity发生了对应的生命周期改变,MainPresenter就会执行对应事件注解的方法

class MainPresenter : BasePresenter() {

    override fun onCreate(owner: LifecycleOwner) {
        Log.e(TAG, "MainPresenter onCreate");
        super.onCreate(owner)
    }

    override fun onDestroy(owner: LifecycleOwner) {
        Log.e(TAG, "MainPresenter onDestroy");
        super.onDestroy(owner)
    }
}
class MainActivity : AppCompatActivity() {

    private val TAG = "MainActivity"
    private var mPresenter: IPresenter? = null

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

        Log.e(TAG, "MainActivity onCreate")
        mPresenter = MainPresenter()
        getLifecycle().addObserver(mPresenter as MainPresenter);
    }

    override fun onDestroy() {
        Log.e(TAG, "MainActivity onDestroy")
        super.onDestroy()
    }
}

这里只实现了onCreate和onDestroy,需要求他的生命周期状态时,只需要实现对应的方法。

 

接下来看看原理,掌握Liifecycle,首先要理解五个类

LifeCycleObserver接口(Lifecycle观察者):实现该接口的类,可以用过lifecyclerowner类的addObserver()方法进行注册,之后,lifecycleObserver便可以观察到lifeCycleOwner中的生命周期事件。

LifeCycleOwner接口(LifeCycle的持有者):实现该接口的类持有lifecycle对象,该类的声明周期周期发生变化时,会被注册的观察者也就是LifeCycleObsverser观察到。

LifeCycle(生命周期)

State(当前声明周期所处的状态)

Event(当前声明周期改变对应的事件)

Activity与Fragment实现机制类似,这里来看看Activity的实现

public class ComponentActivity extends Activity
        implements LifecycleOwner, KeyEventDispatcher.Component {
    

    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

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

public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

getLifecycle()方法实际返回的是LifeCycleRegistry对象,我们在来看LifeCycleRegistry类

public class LifecycleRegistry extends Lifecycle {
}

LifeCycleRegistry是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;
            }
       }
}

lifeCycle里的抽象方法在LifeCycleRegistry里进行了实现,LifeCycleRegistry中有一个方法

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }

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

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值