【Jetpack】Lifecycle学习笔记

原文：Android官方架构组件Lifecycle:生命周期组件详解&原理分析在过去的谷歌IO大会上，Google官方向我们推 - 掘金

非常好的系列文章，清晰透彻，推荐阅读原文。

lifecycle可以和Activity或Fragment生命周期绑定，方便我们做一些跟生命周期相关的业务逻辑。常见的生命周期处理方法是在Activity onResume（）、onStart（）等中处理相关逻辑，随着业务复杂，也容易出bug，可以使用Lifecycle来感知生命周期的变化，解耦出去这些逻辑，并自动在适当的生命周期内执行。

使用方法

• 引入包

• 定义观察者类

  public interface IBaseViewModel extends LifecycleObserver {
  
      @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
      void onAny(LifecycleOwner owner, Lifecycle.Event event);
  
      @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
      void onCreate();
  
      @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
      void onDestroy();
  
      @OnLifecycleEvent(Lifecycle.Event.ON_START)
      void onStart();
  
      @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
      void onStop();
  
      @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
      void onResume();
  
      @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
      void onPause();
  }
  
  public class BaseViewModel implements IBaseViewModel{
      @Override
      public void onAny(LifecycleOwner owner, Lifecycle.Event event) {
      
      }
      
      @Override
      public void onCreate() {
      
      }
      
      @Override
      public void onDestroy() {
      
      }
      
      @Override
      public void onStart() {
      
      }
      
      @Override
      public void onStop() {
      
      }
      
      @Override
      public void onResume() {
      
      }
      
      @Override
      public void onPause() {
      
      }
  }

• Activity中添加观察者

pubilc class BaseActivity extends AppCompatActivity{
        @Override
        protected void onCreate(){
            //...
            getLifecycle().addObserver(MyObserver())
        }
}

 每次MainActivity中生命周期发生改变，ViewModel中对应周期的就会执行

原理

LifecycleOwner

Fragment、Activity内部实现了LifecycleOwner接口

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ContextAware,
        LifecycleOwner,
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner,
        ActivityResultRegistryOwner,
        ActivityResultCaller {
            private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
            @NonNull
            @Override
            public Lifecycle getLifecycle() {
                return mLifecycleRegistry;
            }
        }

实际上在Fragment、Activity对应的生命周期内，都会发送对应的生命周期事件给内部的 LifecycleRegistry对象处理：

public class FragmentActivity extends ComponentActivity implements
        ActivityCompat.OnRequestPermissionsResultCallback,
        ActivityCompat.RequestPermissionsRequestCodeValidator {
            @Override
            protected void onCreate(@Nullable Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
                mFragments.dispatchCreate();
            }
        }

public class Fragment implements xxx, LifecycleOwner {
    void performCreate(Bundle savedInstanceState) {        
        onCreate(savedInstanceState);  
        //1.先执行生命周期方法        
        //...省略代码        
        //2.生命周期事件分发            
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);    
    }
    
    void performStart() {        
        onStart();        
        //...        
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);    
    }
    
    void performResume() {         
        onResume();        
        //...        
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);    
    }    
    void performPause() {        
        //3.注意，调用顺序变了
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);        
            //...        
        onPause();    
    }    
    void performStop() {           
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);        
        //...        
        onStop();    
    }    
    void performDestroy() {        
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);        
        //...       
        onDestroy();    
    }
}

发送对应的生命周期事件给内部的 LifecycleRegistry对象处理后，LifecycleObserver就会收到对应的生命周期事件。

LifecycleRegistry

LifecycleRegistry 就是 Lifecycle 的子类：

public class LifecycleRegistry extends Lifecycle {}

public abstract class Lifecycle {        
    //注册LifecycleObserver （比如Presenter）        
    public abstract void addObserver(@NonNull LifecycleObserver observer);        
    //移除LifecycleObserver         
    public abstract void removeObserver(@NonNull LifecycleObserver observer);        
    //获取当前状态        
    public abstract State getCurrentState();        
    public enum Event {            
        ON_CREATE,            
        ON_START,            
        ON_RESUME,            
        ON_PAUSE,            
        ON_STOP,            
        ON_DESTROY,            
        ON_ANY        
    }               
    public enum State {            
        DESTROYED,            
        INITIALIZED,            
        CREATED,            
        STARTED,            
        RESUMED;            
        public boolean isAtLeast(@NonNull State state) {                
        return compareTo(state) >= 0;            
        }       
    }
}

LifecycleRegistry 同样也能通过addObserver方法注册LifecycleObserver。当LifecycleRegistry 本身的生命周期改变后，LifecycleRegistry 就会逐个通知每一个注册的LifecycleObserver ，并执行对应生命周期的方法。