Lifecycle应用

上一篇 文章分析了lifecycle的源码，源码真的很枯燥，不过有了上一篇的基础，我们再来分析lifecycle的应用就简单多了。lifecycle应用中最重要的两个类是：LifecycleOwner 和  LifecycleObserver ，前者是提供lifecycle生命周期的，后者是观察者，我们马上会分析源码，先看应用：

自定义一个handler，解决内存泄漏问题：

public class LifecycleHandler extends Handler implements LifecycleEventObserver {
    private LifecycleOwner mLifecycleOwner;

    public LifecycleHandler(LifecycleOwner lifecycleOwner) {
        this.mLifecycleOwner = lifecycleOwner;
        lifecycleOwner.getLifecycle().addObserver(this);
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        switch (event) {
            case ON_DESTROY:
                removeCallbacksAndMessages(null);
                mLifecycleOwner.getLifecycle().removeObserver(this);
                break;
        }
    }
}

使用如下：

private Handler mHanlder=new LifecycleHandler(this){//this是activity或者fragment
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what){
                //......
            }
        }
 };

就这样，我们就可以放心使用handler了，不用担心内存泄漏了。

源码分析：

1.LifecycleOwner 源码解析：

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

源码就这么简单，一个接口，获取lifecycle。那么他的实现类是谁呢？ComponentActivity和fragment ：

 */
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner {

    
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

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

简化后的代码就这么多，是不是很熟悉，LifecycleRegistry 就是上一篇我们分析的源码，我们添加的所有观察者都会放到LifecycleRegistry 的链表中，当LifecycleOwner(也就是activity)的生命周期发生改变时，会调用所有观察者的onStateChanged 方法。

2.LifecycleObserver 观察者源码分析：

public interface LifecycleObserver {

}

空接口，什么也没有做，那么来看看他的子类：LifecycleEventObserver 

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

定义了一个抽象方法，状态改变的回调方法，上面分析过了。

那么lifecycle的所有源码我们都已经分析完了，其实原理很简单，就是通过一个抽象层lifecycle，将具有生命周期的对象，把生命周期暴露出来，其他所有想和他的生命周期关联的对象，都可以通过lifecycle解耦来实现，最大的用处应该就是封装第三方库和解决内存泄漏问题。

再来写两个应用案例：

1.service中使用

    public void startService(){
        LifecycleService service = new LifecycleService();
        service.getLifecycle().addObserver(new LifecycleServiceObservier(service));
        startService(new Intent(this, LifecycleService.class));
    }


public class LifecycleServiceObservier implements LifecycleEventObserver {
    private LifecycleOwner mLifecycleOwner;

    public LifecycleServiceObservier(LifecycleOwner lifecycleOwner) {
        this.mLifecycleOwner = lifecycleOwner;
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        switch (event) {
            case ON_CREATE:
                //服务创建
                break;
            case ON_START:
                //start或bind方法
                break;
            case ON_DESTROY:
                mLifecycleOwner.getLifecycle().removeObserver(this);
                break;
        }

    }
}

2.监听app进入前后台：

application的oncreate中增加：

ProcessLifecycleOwner.get().getLifecycle().addObserver(new BackgroundFroutChangeObsever());

public class BackgroundFroutChangeObsever implements LifecycleEventObserver {
    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        switch (event){
            case ON_RESUME:
                Log.e("TAG", "onStateChanged: 应用处于前台");
                break;
            case ON_STOP:
                Log.e("TAG", "onStateChanged: 应用处于后台");
                break;
        }
    }
}

就可以方便监听应用是否处于前后台了，不过实际中发现在某些手机上不是很准。