1,什么是 LifeCycle
LifeCycle是google提供的一种帮助开发者感知生命周期的组件.组件通过获取管理内部生命周期,从而降低模块间的耦合度,并且在对应的生命周期内进行请求业务的绑定和解绑,降低内存泄漏的可能性.
2,LifeCycle组成
JetPact提供了2个重要的类:LifecycleOwner(被观察者)和LifecycleObserver(观察者).通过观察者模式实现对生命周期的监听.
public class ComponentActivity extends Activity implements
LifecycleOwner,
KeyEventDispatcher.Component {}
public class Fragment implements ComponentCallbacks,
OnCreateContextMenuListener, LifecycleOwner,
ViewModelStoreOwner, SavedStateRegistryOwner {}
观察源码发现activity和fragment的父类都实现了LifecycleOwner接口,所以在activity和fragment中,我们实现LifecycleObserver接口并与其绑定即可.
getLifecycle().addObserver(mLifecycleObserver);
3,一个例子
举个实战例子,获取手机号验证码60秒倒计功能,首先创建CounterLinsenner类实现LifecycleObserver,并在需要生命周期监听的方法上使用@OnLifecycleEvent(Lifecycle.ON_XXX)注解标签进行标识.代码如下:
public class CounterLinsenner implements LifecycleObserver {
private Timer timer;
private int mCount=60;
public interface SecondCounter{
void secondChange(int second);
}
private SecondCounter mSecondCounter;
public CounterLinsenner(SecondCounter mSecondCounter) {
this.mSecondCounter = mSecondCounter;
}
//开始计时
public void startCount(){
if (timer==null) {
timer=new Timer();
}else if (timer!=null){
timer.cancel();
}
timer.schedule(new TimerTask() {
@Override
public void run() {
if (mSecondCounter!=null) {
mCount--;
mSecondCounter.secondChange(mCount);
}
}
},0,1000);
}
/**
* 当activity执行onCreate()方法时该方法被调用
* */
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
private void onActivityCreate(){
Log.i("Lifecycle","ON_CREATE");
}
/**
* 当activity执行onStart()方法时该方法被调用
* */
@OnLifecycleEvent(Lifecycle.Event.ON_START)
private void onActivityStart(){
Log.i("Lifecycle","ON_START");
}
/**
* 当activity执行onResume()方法时该方法被调用
* */
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
private void onActivityResume(){
Log.i("Lifecycle","ON_RESUME");
}
/**
* 当activity执行onPause()方法时该方法被调用
* */
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
private void onActivityPause(){
Log.i("Lifecycle","ON_PAUSE");
}
/**
* 当activity执行onStop()方法时该方法被调用
* */
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
private void onActivityStop(){
Log.i("Lifecycle","ON_STOP");
}
/**
* 当activity执行onDestroy()方法时该方法被调用
* */
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
private void onActivityDestroy(){
//取消计时
timer.cancel();
Log.i("Lifecycle","ON_DESTROY");
}
}
在activity中引用CounterLinsenner,只需要通过getLifecycle().addObserver()方法,将观察者与被观察者绑定起来,让观察者自己内部管理生命周期,代码如下:
public class MainActivity extends AppCompatActivity {
private CounterLinsenner counterLinsenner;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findViewById(R.id.btn_click).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
startActivity(new Intent(MainActivity.this,SecondActivity.class));
}
});
findViewById(R.id.btn_start).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
counterLinsenner.startCount();
}
});
counterLinsenner=new CounterLinsenner(new CounterLinsenner.SecondCounter() {
@Override
public void secondChange(int second) {
Log.i("Lifecycle secondChange",second+"");
}
});
//最重要的步骤,绑定观察者
getLifecycle().addObserver(counterLinsenner);
}
@Override
public void onBackPressed() {
super.onBackPressed();
Log.i("Lifecycle", "点击了返回键");
}
}
activity中有2个按钮,分别是跳转到另一个activity和开始计时,操作流程是先开始计时,然后跳转到另一个activity,接着返回到原类的activity,最后返回键退出应用.
日志打印:
image.png
就这样通过LifecycleOwner(被观察者)和LifecycleObserver(观察者)绑定,让LifecycleObserver自己管理监听生命周期
4,LifecycleService
google也提供了LifecycleService类以便于监听service的生命周期,该类继承service,并实现了LifecycleOwner接口
使用前引用
implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
1),创建LifecycleObserver实现类MyServiceObserver
public class MyServiceObserver implements LifecycleObserver {
private final String TAG="MyServiceObserver";
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
private void onServiceStart(){
Log.i(TAG,"开始Service");
}
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
private void onServiceDestory(){
Log.i(TAG,"结束Service");
}
}
2),创建LifecycleService的子类MyService
public class MyService extends LifecycleService {
private MyServiceObserver myServiceObserver;
public MyService() {
myServiceObserver=new MyServiceObserver();
//绑定
getLifecycle().addObserver(myServiceObserver);
}
}
3),在清单配置声明后,通过正常的流程开启关闭服务就可以在MyServiceObserver里监听服务的创建和销毁
//开启服务
startService(new Intent(SecondActivity.this, MyService.class));
//关闭服务
stopService(new Intent(SecondActivity.this, MyService.class));
5,ProcessLifecycleOwner
google提供了ProcessLifecycleOwner来监控application的生命周期,以便区分应用处于前后台的状态或前后台的切换监听.
使用前引用
implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
1),定义观察类ApplicationObserver
public class ApplicationObserver implements LifecycleObserver {
private static final String TAG="ApplicationObserver";
//onCreate只会被调用一次
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void onCrate(){
Log.i(TAG,"ON_CREATE") ;
}
//应用进入前台调用
@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void start(){
Log.i(TAG,"ON_START") ;
}
//应用进入前台调用
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
public void resume(){
Log.i(TAG,"ON_RESUME") ;
}
//应用退到后台调用
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
public void puase(){
Log.i(TAG,"ON_PAUSE") ;
}
//应用退到后台调用
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
public void stop(){
Log.i(TAG,"ON_STOP") ;
}
//永远不被调用
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
public void destory(){
Log.i(TAG,"ON_DESTROY") ;
}
}
2),在application绑定即可
public class MyApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
ProcessLifecycleOwner.get().getLifecycle().addObserver(new ApplicationObserver());
}
}
