android Jetpack应用实战（一）－Lifecycle

Jetpack已经出来好几年了，之前因为项目的原因会偶尔使用Jetpack　里面的组件，发现真的很优秀的设计，自己也一直没时间（就是懒）没有系统性的学习，所以准备系统性学习下，记录自己的学习心得．

１，加gradle 配置

官网有介绍，导入下面的包，不然用不了,本文只要用到Lifecycles 相关的，因为后面文章也需要，就一起介绍了

https://developer.android.com/jetpack/androidx/releases/lifecycle?hl=zh-cn#groovy

dependencies {
        def lifecycle_version = "2.5.1"
        def arch_version = "2.1.0"

        // ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
        // LiveData
        implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
        // Lifecycles only (without ViewModel or LiveData)
        implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

        // Saved state module for ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"

        // Annotation processor
        annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

        // optional - helpers for implementing LifecycleOwner in a Service
        implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

        // optional - ReactiveStreams support for LiveData
        implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version"

        // optional - Test helpers for LiveData
        testImplementation "androidx.arch.core:core-testing:$arch_version"

        // optional - Test helpers for Lifecycle runtime
        testImplementation "androidx.lifecycle:lifecycle-runtime-testing:$lifecycle_version"
    }

２，LifeCycle

为什么要使用LifeCycle?

我们经常在Activity Service 等生命周期内处理一下初始化，关闭一些功能的操作，造成这些组件代码越来越雍宗，耦合度太高，为此，LifeCycle 这个组件就可以发挥作用了

原理：观察者模式

Activity

通过阅读源码我们发现，Activity 已经帮我们实现了被观察者的代码

public class FragmentActivity extends ComponentActivity implements
        ActivityCompat.OnRequestPermissionsResultCallback,
        ActivityCompat.RequestPermissionsRequestCodeValidator {
  
    /**
     * A {@link Lifecycle} that is exactly nested outside of when the FragmentController
     * has its state changed, providing the proper nesting of Lifecycle callbacks
     * <p>
     * TODO(b/127528777) Drive Fragment Lifecycle with LifecycleObserver
     */
    final LifecycleRegistry mFragmentLifecycleRegistry = new LifecycleRegistry(this);

      @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        //....
        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
     
    }

      @Override
    protected void onDestroy() {
        //....
        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
    }

     @Override
    protected void onPause() {
        //....
        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
    }

    protected void onResumeFragments() {
        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
        
    }

     @Override
    protected void onStart() {
         // .......
        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }
    
  @Override
    protected void onStop() {
        // .......
        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
    }

}

你所要做的事情，就是添加自己的观察者就可以了

实现自己的观察者

public class MyTaskListener implements LifecycleEventObserver {

    private String TAG = "MyTaskListener";

    public MyTaskListener() {
    }

    @Override
    public void onStateChanged(@NonNull @NotNull LifecycleOwner source, @NonNull @NotNull Lifecycle.Event event) {

        Log.d(TAG,event.name()+","+event.toString());

    }
}

Activity　中添加观察者

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {


        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        MyTaskListener myTaskListener = new MyTaskListener();

        getLifecycle().addObserver(myTaskListener);

    }
}

打印log，我们只要在观察者里面做特定的逻辑即可，Activity 只需要处理UI 即可，Fragment 同理

com.sim.testlifecycle D/MyTaskListener: ON_CREATE,ON_CREATE

com.sim.testlifecycle D/MyTaskListener: ON_START,ON_START

com.sim.testlifecycle D/MyTaskListener: ON_RESUME,ON_RESUME

//下面是熄屏的周期

com.sim.testlifecycle D/MyTaskListener: ON_PAUSE,ON_PAUSE

com.sim.testlifecycle D/MyTaskListener: ON_STOP,ON_STOP

Service

同Activity 一样，不在重复介绍

应用程序的生命周期

作用：判断应用程序处于前台或者后台的状态监听

监听者同Activity 一致

public class MyApplicationObser implements LifecycleEventObserver {
    private String TAG = "MyApplicationObser";

    @Override
    public void onStateChanged(@NonNull @NotNull LifecycleOwner source, @NonNull @NotNull Lifecycle.Event event) {
        Log.d(TAG,event.name()+","+event.toString());
    }
}

注册的方式有一些改变

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        ProcessLifecycleOwner.get().getLifecycle().addObserver(new MyApplicationObser());
    }
}

应用到前台的时候

2023-03-22 09:10:23.572 15961-15961/com.sim.testlifecycle D/MyApplicationObser: ON_START,ON_START

2023-03-22 09:10:23.585 15961-15961/com.sim.testlifecycle D/MyApplicationObser: ON_RESUME,ON_RESUME

应用到后台的时候

2023-03-22 09:10:24.387 15961-15961/com.sim.testlifecycle D/MyApplicationObser: ON_PAUSE,ON_PAUSE

2023-03-22 09:10:24.388 15961-15961/com.sim.testlifecycle D/MyApplicationObser: ON_STOP,ON_STOP

Ps:ON_CREATE 之后调用一次，就是应用创建的时候