MVVM框架第一篇 LifeCycle

一.LifeCycle介绍

解耦在软件开发中占据很重要的位置，正常组件在使用过程中需要依赖系统组件的生命周期。在onCreate或onResume方法初始化，在onPause中停止，在onDestroy中进行资源回收。这可能引发内存泄漏。LifeCycle为此而生，可以加强对自定义组件的管理，不依赖页面生命周期的回调方法。

二.简单使用

我们很多的需求都需要在onResume进行初始化，onPause进行停止。如NFC或获取地理位置等

public class MainActivity extends AppCompatActivity {

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

    @Override
    protected void onResume() {
        super.onResume();
        Log.d("=====","onResume");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d("=====","onPause");
    }
}

Jetpack为我们提供两个类，LifecycleOwner(被观察者)和LifecycleObserver(观察者)。
Activity已经实现了LifecycleOwner接口，我们只需要实现LifecycleObserver即可。

public class MyMainListener implements LifecycleObserver {

    private OnMainChangeListener listener;

    public MyMainListener(OnMainChangeListener listener) {
        this.listener = listener;
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private void myResume() {
        listener.onChange("onResume");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private void myPause() {
        listener.onChange("onPause");
    }

    public interface OnMainChangeListener {
        void onChange(String message);
    }
}

在方法上使用 @OnLifecycleEvent(Lifecycle.Event.ON_XXX)标签进行标识。当生命周期发生周期变化时，方法会自动调用。

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MyMainListener listener = new MyMainListener(new MyMainListener.OnMainChangeListener() {
            @Override
            public void onChange(String message) {
                Log.d("=====", message);
            }
        });
        getLifecycle().addObserver(listener);
    }
}

---

在service方面，Android提供LifecycleService，该类继承Service，实现LifecycleOwner接口，使用方法与Activity类似。
添加依赖

implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'

public class MyServiceObserver implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private void myCreate() {
        Log.d("=====", "create");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    private void destroy() {
        Log.d("=====", "destroy");
    }
}

public class MyService extends LifecycleService {

    public MyService() {
        MyServiceObserver myServiceObserver = new MyServiceObserver();
        getLifecycle().addObserver(myServiceObserver);//添加观察者
    }
}

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        findViewById(R.id.start).setOnClickListener(new View.OnClickListener()
        {
            @Override
            public void onClick(View v)
            {
                Intent intent = new Intent(MainActivity.this, MyService.class);
                startService(intent);
            }
        });

        findViewById(R.id.stop).setOnClickListener(new View.OnClickListener()
        {
            @Override
            public void onClick(View v)
            {
                Intent intent = new Intent(MainActivity.this, MyService.class);
                stopService(intent);
            }
        });
    }
}

三.ProcessLifecycleOwner

具有生命周期的系统组件还有Application。Android同样提供了ProcessLifecycleOwner来监听应用的生命周期。

implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'

public class ApplicationObserver implements LifecycleObserver {

    /**
     * ON_CREATE 在应用程序的整个生命周期中只会被调用一次
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        Log.d("=====", "Lifecycle.Event.ON_CREATE");
    }

    /**
     * 应用程序出现到前台时调用
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        Log.d("=====", "Lifecycle.Event.ON_START");
    }

    /**
     * 应用程序出现到前台时调用
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        Log.d("=====", "Lifecycle.Event.ON_RESUME");
    }

    /**
     * 应用程序退出到后台时调用
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        Log.d("=====", "Lifecycle.Event.ON_PAUSE");
    }

    /**
     * 应用程序退出到后台时调用
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        Log.d("=====", "Lifecycle.Event.ON_STOP");
    }

    /**
     * 永远不会被调用到，系统不会分发调用ON_DESTROY事件
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        Log.d("=====", "Lifecycle.Event.ON_DESTROY");
    }
}

public class BaseApp extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        ProcessLifecycleOwner.get().getLifecycle().addObserver(new ApplicationObserver());
    }
}

有了ProcessLifecycleOwner，我们可以监听应用的生命周期，但有几个注意的点。

• ProcessLifecycleOwner是对整个应用程序的监听，与Activity的数量无关。
• ON_CREATE只会调用一次，ON_DESTROY虽然有方法但不会调用。