Android 架构组件Lifecycle的使用

Lifecycle 是 Google 推出的架构组件，用于处理 Activity 和 Fragment 的生命周期。
中文官网文档 https://developer.android.google.cn/topic/libraries/architecture/lifecycle

监听生命周期

按照 Google 文档，常规做法是：写一个辅助类，类中分别写对应Activity生命周期的方法，然后再类中处理与生命周期有关的逻辑。
即 Activity onResume() 时调用辅助类的 onResume() ，以此类推。
如Google文档的示例，这样做没问题，但当工程逻辑复杂、代码量很大时， Activity 的 onResume()等方法就会很臃肿。

class MyLocationListener {
    public MyLocationListener(Context context, Callback callback) {
        // ...
    }

    void start() {
        // connect to system location service
    }

    void stop() {
        // disconnect from system location service
    }
}

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    @Override
    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, (location) -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        myLocationListener.start();
        // manage other components that need to respond
        // to the activity lifecycle
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

使用Lifecycle

添加依赖

Lifecycle 是 androidx 包下，需要在 app 的 build.grdle 中添加依赖，

dependencies {
    def lifecycle_version = "2.2.0"
    implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"
}

直接使用

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.d("luoah", "[MainActivity.java] -- onCreate -- ");
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        getLifecycle().addObserver(new LifecycleObserver() {
            @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
            public void on_New_Create() {
            
            }

            @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
            public void on_New_Resume() {
            
            }

            @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
            public void on_New_Stop() {
            
            }

            @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
            public void on_New_Destroy() {
            
            }
        });
    }
}

简单粗暴，拿到 Lifecycle，并添加 Observer 来实现对 Activity 生命周期的监听。

定义一个 LifecycleObserver 使用

和直接使用类似，就是自已创建一个 LifecycleObserver 。

使用注解对应组件的生命周期，如 @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
on_Create 等方法可以自己命名。

private class MyLifecycleObserver implements LifecycleObserver{

        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
        public void on_Create(){
        
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        public void on_Start(){
        
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        public void on_Resume(){
        
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        public void on_Pause(){
        
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
        public void on_Stop(){
        
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
        public void on_Destroy(){
        
        }
    }

在被监测的组件中调用

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.d("luoah", "[MainActivity.java] -- onCreate -- ");
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        getLifecycle().addObserver(new MyLifecycleObserver());
    }
}

使用 LifecycleRegistry 实现

首先，被监测的组件实现 LifecycleOwner 接口，重写 getLifecycle() 方法；
然后， 实现 LifecycleRegistry 、LifecycleObserver 。
代码示例：

public class FirstActivity extends AppCompatActivity implements LifecycleOwner {
	private LifecycleRegistry mRegistry;
    private LifecycleObserver mObserver;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_first);

        mObserver = new LifecycleObserver() {

            @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
            public void on_Create(){
            
            }

            @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
            public void on_Resume(){
            
            }

            @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
            public void on_Destroy(){
            
            }
        };

        mRegistry = new LifecycleRegistry(FirstActivity.this);
        mRegistry.addObserver(mObserver);
    }
    
	@Override
    public Lifecycle getLifecycle() {
        return mRegistry;
    }
	
	@Override
    protected void onDestroy() {
        super.onDestroy();
        mRegistry.removeObserver(mObserver);//移除观察者
    }
}

这样，就可以实现对声明周期的监听了。