android架构组件Lifecycle

Lifecycle 组件指的是 android.arch.lifecycle 包下提供的各种类与接口，可以让开发者构建能感知其他组件（主要指Activity 、Fragment）生命周期（lifecycle-aware）的类。

 

在android开发的过程中，我们常常需要让一些操作能够感知Activity/Fragment的生命周期，从而实现在活动状态下允许操作，而在销毁状态下需要自动禁止操作，释放资源，防止内存泄露。例如大名鼎鼎的图片加载框架 Glide 在 Acticiy/Fragment 处于前台的时候加载图片，而在不可见的状态下停止图片的加载，又例如我们希望 RxJava 的 Disposable 能够在Activity/Fragment 销毁是自动 dispose。Lifecycle 的出现，让开发者们能够轻易地实现上述的功能。

 

使用

假设有一个Presenter，需要在Activity的各个生命周期，执行相应的方法，那么，只需要实现LifecycleObserver，这样，在Activity处于相应的生命周期的时候，相应的方法就会被调用：

public class MyPresent implements IPresent, LifecycleObserver {


    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    @Override
    public void onCreate() {
        LogUtil.i(TAG, "onCreate");
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    @Override
    public void onStart() {
        LogUtil.i(TAG, "onStart");
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    @Override
    public void onResume() {
        LogUtil.i(TAG, "onResume");
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    @Override
    public void onPause() {
        LogUtil.i(TAG, "onPause");
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    @Override
    public void onStop() {
        LogUtil.i(TAG, "onStop");
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    @Override
    public void onDestory() {
        LogUtil.i(TAG, "onDestory");
    }
}

上述代码实现的是一个观察者，被观察者是Activity，Activity会将生命周期中的方法回调通知到观察者中对应的方法

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

public class MyActivity extends AppCompatActivity {

    protected MyPresent myPresent;

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState, @Nullable PersistableBundle persistentState) {
        super.onCreate(savedInstanceState, persistentState);

        getLifecycle().addObserver(new MyPresent()); //添加监听对象
    }

}

原理：

• LifecycleOwner：生命周期的事件分发者，在 Activity/Fragment 他们的生命周期发生变化的时发出相应的 Event 给 LifecycleRegistry。
• LifecycleObserver：生命周期的观察者，通过注解将处理函数与希望监听的Event绑定,当相应的Event发生时,LifecycleRegistry会通知相应的函数进行处理。
• LifecycleRegistry：控制中心。它负责控制state的转换、接受分发event事件。

 

Lifecycle使用的三种基本使用方式：

 

第一种使用方式。使用@onLifecycleEvent注解。注解处理器会将该注解解析并动态生成GeneratedAdapter代码，这个GeneratedAdapter会把对应的 Lifecycle.Event 封装为方法调用。最终通过GenericLifecycleObserver的onStateChanged方法调用生成的GeneratedAdapter的callMechods方法进行事件分发

public class MyLifeCycleObserver implements LifeCycleObserver {
    @onLifecycleEvent(LifeCycle.Event.ON_CREATE)
    public onCreate(LifeCycleOwner owner) {
         //doSomething
    }

    @onLifecycleEvent(LifeCycle.Event.ON_DESTROY)
    public onDestroy(LifeCycleOwner owner) {
        //doSomething
    }
}
public class MainActivity extends AppCompatActivity {
    @override
    public void onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        getLifecycle().addObserver(new MyLifeCycleObserver());
    }
}

上述的例子中的 MyLifeCycleObserver 将会在编译时，生成GeneratedAdapter代码如下：

public class MyLifeCycleObserver_LifecycleAdapter implements GeneratedAdapter {


    final MyLifeCycleObserver mReceiver;


    MyLifeCycleObserver_LifecycleAdapter(MyLifeCycleObserver receiver) {
        //mReceiver就是我们开发者传入的MyLifeCycleObserver
        this.mReceiver = receiver;
    }


    //callMechod方法会被GenericLifecycleObserver的onStateChanged方法调用，用以分发生命周期
    @Override
    public void callMethods(LifecycleOwner owner, Lifecycle.Event event, boolean onAny, MethodCallsLogger logger) {
        boolean hasLogger = logger != null;
        if (onAny) {
            return;
        }


        //如果生命周期事件是ON_CREATE，那么调用MyLifeCycleObserver的onCreate方法
        if (event == Lifecycle.Event.ON_CREATE) {
            if (!hasLogger || logger.approveCall("onCreate", 2)) {
                mReceiver.onCreate(owner);
            }
            return;
        }


        //如果生命周期事件是ON_DESTROY，那么调用MyLifeCycleObserver的onDestroy方法
        if (event == Lifecycle.Event.ON_DESTROY) {
            if (!hasLogger || logger.approveCall("onDestroy", 2)) {
                mReceiver.onDestroy(owner);
            }
            return;
        }
    }
}

第二种使用方式。直接继承 GenericLifecycleObserver，并实现onStateChange 方法：

public class MyLifeCycleObserver extends GenericLifeCycleObserver {


    @override
    void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        if(event == LifeCycleEvent.Event.ON_CREATE) {
            //dosomething
        } else if(event == LifeCycleEvent.Event.ON_DESTROY) {
            //doSomething
        }    
    }
}


public class MainActivity extends AppCompatActivity {


    @override
    public void onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        getLifecycle().addObserver(new MyLifeCycleObserver());
    }
}

 第三种使用方式。继承 DefaultLifecycleObserver 接口（DefaultLifecycleObserver 又继承自 FullLifecycleObserver接口），并实现 FullLifecycleObserver 接口的 onCreate、onStart、onResume、onPause、onStop、onDestroy 等对应各自生命周期的方法

class MyLifycycleObserver implements DefaultLifecycleObserver {


    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {
        //doSomething
    }


    ......


    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) {
        //doSomething   
    }
}


public class MainActivity extends AppCompatActivity {


    @override
    public void onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        getLifecycle().addObserver(new MyLifeCycleObserver());
    }
}