Lifecycle使用方法、原理分析

Jetpack系列：
Lifecycle使用方法、原理分析 - 掘金 (juejin.cn)
LiveData使用方法、原理分析 - 掘金 (juejin.cn)
ViewModel使用方法、原理分析（一） - 掘金 (juejin.cn)
ViewModel使用方法、原理分析（二） - 掘金 (juejin.cn)
自定义View中获取ViewModel - 掘金 (juejin.cn)

生命周期是Android四大组件核心特性之一，也是Android视图View开发需要重点关注问题。
Lifecycle生命周期感知型组件可执行操作来响应另一个组件（如 activity 和 fragment）的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护

Lifecycle使用方法

gradle依赖参考官方文档，集成最新版本

//Lifecycle基础功能
implementation "androidx.lifecycle:lifecycle-runtime:2.5.1"
//Lifecycle Kotlin扩展功能
implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.5.1"

在第三方地图集成业务中，都会要求MapView在项目中使用地图的时候需要注意，需要合理的管理地图生命周期，这非常的重要，以下是高德地图官方集成示例，当有多个Activity持有MapView对象时，维护难度增加

public class MainActivity extends Activity {
  MapView mMapView = null;
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_main);
    //获取地图控件引用
    mMapView = (MapView) findViewById(R.id.map);
    //在activity执行onCreate时执行mMapView.onCreate(savedInstanceState)，创建地图
    mMapView.onCreate(savedInstanceState);
  }
  @Override
  protected void onDestroy() {
    super.onDestroy();
    //在activity执行onDestroy时执行mMapView.onDestroy()，销毁地图
    mMapView.onDestroy();
  }
 @Override
 protected void onResume() {
    super.onResume();
    //在activity执行onResume时执行mMapView.onResume ()，重新绘制加载地图
    mMapView.onResume();
    }
 @Override
 protected void onPause() {
    super.onPause();
    //在activity执行onPause时执行mMapView.onPause ()，暂停地图的绘制
    mMapView.onPause();
    }
 @Override
 protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    //在activity执行onSaveInstanceState时执行mMapView.onSaveInstanceState (outState)，保存地图当前的状态
    mMapView.onSaveInstanceState(outState);
  } 
}

使用Lifecycle简化代码结构，可以组件生命周期相关业务处理集成功能组件内部，宿主Activity不必再参与功能组件生命周期处理

class CustomAMap:LifecycleEventObserver {
    private lateinit var aMapView: MapView
    
    override fun initMap(mapView: View) {
        aMapView = mapView as MapView
    }
    
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_CREATE -> {
                aMapView.onCreate(null)
            }
            Lifecycle.Event.ON_RESUME -> {
                aMapView.onResume()
            }
            Lifecycle.Event.ON_PAUSE -> {
                aMapView.onPause()
            }
            Lifecycle.Event.ON_DESTROY -> {
                aMapView.onDestroy()
             
            }else ->{

            }
        }
    }
    
class AMapActivity : AppCompatActivity() {
    private lateinit var mAMap: CustomAMap
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityAmapBinding.inflate(layoutInflater)
        setContentView(binding.root)
        mAMap = CustomAMap()
        lifecycle.addObserver(mAMap)
        mAMap.initMap(binding.map)
    }
}

Lifecycle原理分析

LifecycleOwner

public interface LifecycleOwner {
    /**
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

ComponentActivity 实现该接口，并将其注册成Lifecycle的子类LifecycleRegistry

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ......
        LifecycleOwner,
        .....
{
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    
    //父类接口指向子类对象
    //封装隐藏了类的内部实现机制，可以在不影响使用者的前提下修改类的内部结构，同时保护了数据
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

Lifecycle

Lifecycle是抽象类，对外暴露三个接口方法addObserver、removeObserver、getCurrentState
串联LifecycleObserver、LifecycleOwner

public abstract class Lifecycle {
    ......
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);

    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

    @MainThread
    @NonNull
    public abstract State getCurrentState();

    @SuppressWarnings("WeakerAccess")
    public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY;
        
        @Nullable
        public static Event downFrom(@NonNull State state) {
            switch (state) {
                case CREATED:
                    return ON_DESTROY;
                case STARTED:
                    return ON_STOP;
                case RESUMED:
                    return ON_PAUSE;
                default:
                    return null;
            }
        }

        @Nullable
        public static Event downTo(@NonNull State state) {
            switch (state) {
                case DESTROYED:
                    return ON_DESTROY;
                case CREATED:
                    return ON_STOP;
                case STARTED:
                    return ON_PAUSE;
                default:
                    return null;
            }
        }

        @Nullable
        public static Event upFrom(@NonNull State state) {
            switch (state) {
                case INITIALIZED:
                    return ON_CREATE;
                case CREATED:
                    return ON_START;
                case STARTED:
                    return ON_RESUME;
                default:
                    return null;
            }
        }

        @Nullable
        public static Event upTo(@NonNull State state) {
            switch (state) {
                case CREATED:
                    return ON_CREATE;
                case STARTED:
                    return ON_START;
                case RESUMED:
                    return ON_RESUME;
                default:
                    return null;
            }
        }
        
        @NonNull
        public State getTargetState() {
            switch (this) {
                case ON_CREATE:
                case ON_STOP:
                    return State.CREATED;
                case ON_START:
                case ON_PAUSE:
                    return State.STARTED;
                case ON_RESUME:
                    return State.RESUMED;
                case ON_DESTROY:
                    return State.DESTROYED;
                case ON_ANY:
                    break;
            }
            throw new IllegalArgumentException(this + " has no target state");
        }
    }

    @SuppressWarnings("WeakerAccess")
    public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
        
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

LifecycleRegistry

LifecycleRegistry 是Lifecycle具体实现类，ComponentActivity持有该对象，addOberser执行到该对象中，内部持有mObserverMap对象，记录所有LifecycleObserver

public class LifecycleRegistry extends Lifecycle {

    //管理所有的生命周期观察者，用于后续生命事件分发
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
            new FastSafeIterableMap<>();
    
    //当前LifecycleOwner状态
    private State mState;
    
    //弱引用封装，避免内存泄漏
    private final WeakReference<LifecycleOwner> mLifecycleOwner;
    
    /**
    * 添加观察者，将观察者与初始化状态封装成ObserverWithState，将当前LifecycleOwner最新状态
    * 同步分发给最新的观察者
    **/
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        enforceMainThreadIfNeeded("addObserver");
        //初始化状态两种DESTROYED、INITIALIZED
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        if (previous != null) {
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }
        
        //同步最新的Event事件
        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        
        //计算最新的生命周期状态，通过比较mObserver最新的状态、与mParentStates最新状态进行比较
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            final Event event = Event.upFrom(statefulObserver.mState);
            if (event == null) {
                throw new IllegalStateException("no event up from " + statefulObserver.mState);
            }
            statefulObserver.dispatchEvent(lifecycleOwner, event);
            popParentState();
            // mState / subling may have been changed recalculate
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }
    
    
    
    
    /**
    * 封装一个持有Lifecycle状态Observer,并将持有生命周期Event事件分发
    * Lifecycling 理解为不同观察者适配器，将所有的观察者转为LifecycleEventObserver，分发时再
    * 根据具体的子类实现调用不用的方法
    **/
    static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = event.getTargetState();
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }
    
    //在FragmentActivity中该方法
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        enforceMainThreadIfNeeded("handleLifecycleEvent");
        moveToState(event.getTargetState());
    }

    private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        if (mState == INITIALIZED && next == DESTROYED) {
            throw new IllegalStateException("no event down from " + mState);
        }
        mState = next;
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;
        //同步最新的状态
        sync();
        mHandlingEvent = false;
        if (mState == DESTROYED) {
            mObserverMap = new FastSafeIterableMap<>();
        }
    }
    ......
}

LifecycleObserver

生命周期观察者接口，有两个子类实现LifecycleEventObserver、FullLifecycleObserver

public interface LifecycleObserver {

}

public interface LifecycleEventObserver extends LifecycleObserver {
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

interface FullLifecycleObserver extends LifecycleObserver {

    void onCreate(LifecycleOwner owner);

    void onStart(LifecycleOwner owner);

    void onResume(LifecycleOwner owner);

    void onPause(LifecycleOwner owner);

    void onStop(LifecycleOwner owner);

    void onDestroy(LifecycleOwner owner);
}

Lifecycling

LifecycleEventObserver、FullLifecycleObserver两种观察者适配器，同时包括通过注解形式调用方法的具体实现

public class Lifecycling {

    @NonNull
    @SuppressWarnings("deprecation")
    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        ......
        boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
        //通过FullLifecycleObserverAdapter对生命周期回调进行适配
        if (isLifecycleEventObserver && isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                    (LifecycleEventObserver) object);
        }
        if (isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        }

        if (isLifecycleEventObserver) {
            return (LifecycleEventObserver) object;
        }
        //反射注解相关参数
        final Class<?> klass = object.getClass();
        int type = getObserverConstructorType(klass);
        if (type == GENERATED_CALLBACK) {
            List<Constructor<? extends GeneratedAdapter>> constructors =
                    sClassToAdapters.get(klass);
            if (constructors.size() == 1) {
                GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                        constructors.get(0), object);
                return new SingleGeneratedAdapterObserver(generatedAdapter);
            }
            GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
            for (int i = 0; i < constructors.size(); i++) {
                adapters[i] = createGeneratedAdapter(constructors.get(i), object);
            }
            return new CompositeGeneratedAdaptersObserver(adapters);
        }
        return new ReflectiveGenericLifecycleObserver(object);
    }
    ......
}

生命周期监听注解使用方式，官方已废弃该种方式，无法获取LifecycleOwner

class CustomAMap : IMap, LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START) 
    private fun onCreate(){ }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    private fun onStart(){

    }
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private fun onResume(){

    }
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private fun onPause(){

    }
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    private fun onStop(){

    }
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    private fun onDestroy(){

    }
}

Lifecycle实践案例

在 Android 应用中，通常请求网络数据源以便在屏幕上显示数据更新。通过收集这些数据流，来避免产生不必要的操作和资源浪费 (包括 CPU 和内存)，以及防止在 View 进入后台时泄露数据

lifecycleScope

//引用协程依赖
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.1'
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.1'
//Lifecycle Kotlin扩展功能
implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.5.1"

class AMapActivity : AppCompatActivity() {
    companion object {
        private const val TAG = "AMapActivity"
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityAmapBinding.inflate(layoutInflater)
        setContentView(binding.root)
        binding.map.onCreate(savedInstanceState)
        aMap = CustomAMap()
        lifecycle.addObserver(aMap)
        
        //使用lifecycleScope作用域启动协程，关于协程相关后续文章中补充
        lifecycleScope.launch {
            withContext(Dispatchers.IO){

            }
            //在生命周期大于START状态时执行该方法
            lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED){
            
            }
        }
        lifecycleScope.launch(Dispatchers.IO){

        }
        lifecycleScope.launchWhenCreated {
            
        }
        
}

参考Google开发者推文使用更为安全的方式收集 Android UI 数据流 - 简书 (jianshu.com)

ProcessLifecycleOwner

需要添加gradle依赖，可以实现对整个App生命周期监测，监听App前后台切换

implementation "androidx.lifecycle:lifecycle-process:2.4.1"

class App:Application() {

    companion object{
        private final val TAG = "App"

        val isForeground
            get() = ProcessLifecycleOwner.get().lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)
    }

    private val processLifecycleObserver by lazy {
        object : DefaultLifecycleObserver{
            override fun onStart(owner: LifecycleOwner) {
                super.onStart(owner)
                Log.d(TAG, "进入前台")
            }
            override fun onStop(owner: LifecycleOwner) {
                super.onStart(owner)
                Log.d(TAG, "进入后台")
            }
        }
    }

    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(processLifecycleObserver)
    }
}

LifecycleService

拥有生命周期概念的组件，除了Activity和Fragment，还有一个非常重要的组件是Service，Android提供了一个名为LifecycleService的类，让该类继承自Service，并实现LifecycleOwner接口
同时当Service拥有了Lifecycle生命周期后就可以使用LifecycleScope启动协程处理耗时任务

class CustomService:LifecycleService() {
    companion object{
        private const val TAG = "CustomService"
    }

    override fun onCreate() {
        super.onCreate()
        Log.d(TAG,"onCreate")
        lifecycle.addObserver(CustomLifecycleServiceObserver())
        lifecycleScope.launch {
            //todo
        }
    }

    override fun onBind(intent: Intent): IBinder? {
        Log.d(TAG,"onBind")
        return super.onBind(intent)
    }
}

class CustomLifecycleServiceObserver: LifecycleEventObserver{
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when(event){
            Lifecycle.Event.ON_START->{
                Log.d("CustomLifecycleServiceObserver","ON_START")
            }
            Lifecycle.Event.ON_STOP->{
                Log.d("CustomLifecycleServiceObserver","ON_STOP")
            }
            else->{}
        }
    }
}