Android Architecture Components ——lifecycle 使用

lifecycle主要监听Acticity/Fragment的生命周期，这样可以解决像MVP，MVVM这种设计架构下，我们可以在Presenter，ViewModel中直接进行生命周期的操作，减少解耦和相互调用。

Lifecycle 已经是稳定版，它包含在 support library 26.1.0 及之后的依赖包中，在目前的开发者Acticity、Fragment直接可以对lifecycle进行引用，不需要再进行导入包的操作！

在Activity中使用lifecycle

• 构建观察者 IObserver实现LifecycleObserver

import android.arch.lifecycle.Lifecycle;
import android.arch.lifecycle.LifecycleObserver;
import android.arch.lifecycle.OnLifecycleEvent;
import android.util.Log;

public class IObserver implements LifecycleObserver {
    private String TAG = "huangxiaoguo";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreated() {
        Log.d(TAG, "onCreated: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        Log.d(TAG, "onStart: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        Log.d(TAG, "onResume: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        Log.d(TAG, "onPause: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        Log.d(TAG, "onStop: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Log.d(TAG, "onDestroy: ");
    }

    /**
     * 此方法可以有参数，但类型必须如两者之一(LifecycleOwner owner,Lifecycle.Event event)
     * 此方法在所以得生命周期都执行一遍
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void onAny() {
        Log.d(TAG, "onAny: ");
    }
}

使用OnLifecycleEvent注解对应的生命周期，具体对应枚举Event

继承成FragmentActivity的Activity

• 在Activity中进行监听操作

public class LifecycleOneActivity extends AppCompatActivity {
    private String TAG = "huangxiaoguo";

    private IObserver mObserver;

    @Override
    protected void onStart() {
        super.onStart();
        Log.e(TAG, "onStart: ");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.e(TAG, "onResume: ");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.e(TAG, "onRestart: ");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.e(TAG, "onPause: ");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.e(TAG, "onStop: ");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.e(TAG, "onDestroy: ");
        getLifecycle().removeObserver(mObserver);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_lifecycle_onew);
        mObserver = new IObserver();
        getLifecycle().addObserver(mObserver);
    }


}

主要是在onCreate中的添加监听操作和onDestroy中的删除监听操作

• 具体效果

从图中可以看出lifecycle对生命周期的监听大致流程

不是集成FragmentActivity的Activity，只是普通的Acticity

• 在Activity中进行监听操作

import android.app.Activity;
import android.arch.lifecycle.Lifecycle;
import android.arch.lifecycle.LifecycleOwner;
import android.arch.lifecycle.LifecycleRegistry;
import android.os.Bundle;
import android.support.annotation.NonNull;

import cn.tsou.google2019io.Lifecycle.interfaceview.IObserver;
import cn.tsou.google2019io.R;

public class LifecycleTwoActivity extends Activity implements LifecycleOwner {

    private LifecycleRegistry mLifecycleRegistry;
    private IObserver mObserver;

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

    @Override
    protected void onResume() {
        super.onResume();
        mLifecycleRegistry.markState(Lifecycle.State.RESUMED);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mLifecycleRegistry.markState(Lifecycle.State.DESTROYED);
        getLifecycle().removeObserver(mObserver);
    }


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_lifecycle_two);
        mLifecycleRegistry = new LifecycleRegistry(this);
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
        mObserver = new IObserver();
        getLifecycle().addObserver(mObserver);
        
    }

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

注意：onStart，onResume，onDestroy方法中对Lifecycle设置对应的State

• 效果展示

在Fragment中使用lifecycle

在fragment中的使用方法和Acticity相同

import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

import cn.tsou.google2019io.Lifecycle.interfaceview.IObserver3;
import cn.tsou.google2019io.R;

/**
 * Created by Administrator on 2017/7/6 0006.
 */

public class Lifecycle3Fragment extends Fragment {

    private IObserver3 mObserver;

    @Override
    public void onDestroy() {
        super.onDestroy();
        getLifecycle().removeObserver(mObserver);
    }

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View mView = inflater.inflate(R.layout.fragment_lifecycle, container, false);
        mObserver = new IObserver3();
        getLifecycle().addObserver(mObserver);
        return mView;
    }
}

小结：使用 lifecycle，可以将各种生命周期执行的动作内聚在自身，减少与调用者之间的耦合，同时也便于维护