AAC: LifeCycle

[yunshuipiao]

AAC: LifeCycle

[TOC]

这篇文章对 Android Architecture Component 中的 LifeCycle 进行源码分析，看其怎么对 Activity 的生命周期进行处理。

LifeCycle 基本认识

这里先从 ComponentActivity 开始看起，作为比较基础的类，google 在推出 AAC 框架时就慢慢对基础类做了修改：

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        SavedStateRegistryOwner {
        }

可以看到实现了 LifeCycleOwner 接口。

// 只有一个方法， 返回 保存有 Android 生命周期事件的 Lifecycle。
public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

// LifeCycle
public abstract class Lifecycle {
  	// 对 生命周期对象进行观察
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);
    public abstract void removeObserver(@NonNull LifecycleObserver observer);
  
  	// 获得当前生命周期事件对应的状态
    @MainThread
    @NonNull
    public abstract State getCurrentState();
  
  // LifecycleOwner 对应的生命周期事件
  public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY
    }
  // 上述事件分别对应的状态
  public 
    enum State {
    		// 销毁状态，之后 LifeCycle 不再分发事件。在 Activity onDestory() 结束之后
        DESTROYED,
    		// 初始状态：在 Actiivty 创建成功，onCreate() 方法调用之前
        INITIALIZED,
    		// 创建状态，在 onCreate() 之后，onStop() 调用之前
        CREATED,
    		// 开始状态：在 onStart() 之后，在 onPause() 之前
        STARTED,
    		// 活跃状态，在 onResume() 之后。
        RESUMED;
    		
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
  }
  

// 接口，标记一个类能感知生命周期，使用注解 OnLifecycleEvent 调用相关方法。
@SuppressWarnings("WeakerAccess")
public interface LifecycleObserver {

}

在上面的基本类中，对其 LifeCycler 有一个基本的了解。下面开始来一个最简单的 demo。

val TAG = "MainActivity"
class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        bindData()
        initView()
    }

    private fun bindData() {
        Log.d(TAG, "MainActivity on create， ${lifecycle.currentState}")
        lifecycle.addObserver(LifeCycleObject())
    }


    private fun initView() {
        lifecycle
    }

    override fun onResume() {
        super.onResume()
        Log.d(TAG, "MainActivity on resume， ${lifecycle.currentState}")
    }
}

class LifeCycleObject: LifecycleObserver {
    // 添加回调生命周期事件的注解
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume() {
        Log.d(TAG, "LifeCycleObject on resume")
    }
}

运行程序，输入日志如下：

D/MainActivity: MainActivity on create， INITIALIZED
D/MainActivity: MainActivity on resume， STARTED
D/MainActivity: LifeCycleObject on resume

通过以上程序演示的 LifeCycle 的作用，可以让自定义对象感知生命周期方法。

并调用 OnLifecycleEvent 注解的相关方法。

注意：Debug 查看堆栈是阅读源码手段中最常用最简单最好用最亲民的方法，没有之一，每个人都应该熟练掌握。

下面就从源码角度来分析其是怎么做的。

如何感知生命周期

lifecycle.addObserver(LifeCycleObject())

由于 Activity 中实现了接口，所以这里可以拿到 lifeCycle 对象。

@Override
public Lifecycle getLifecycle() {
    return super.getLifecycle();
}
// 继承 LifeCycle类 的具体实现类
@Override
public Lifecycle getLifecycle() {
     return mLifecycleRegistry;
}
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

// 以 LifeCycleOwner 为参数，初始状态为 INITIALIZED。
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
    }

下面是如何对一个对象进行观察：

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
  	// 初始状态
    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;
    }

    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    State targetState = calculateTargetState(observer);
    mAddingObserverCounter++;
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
        pushParentState(statefulObserver.mState);
        statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
        popParentState();
        // mState / subling may have been changed recalculate
        targetState = calculateTargetState(observer);
    }

    if (!isReentrance) {
        // we do sync only on the top level.
        sync();
    }
    mAddingObserverCounter--;
}

代码到这里就结束了，下面来看一下当注解的生命周期回调式，堆栈的情况。

在堆栈的调用关系上，可以看到 Zygote 和 ActivityThread 的身影。

在 lifecycle 相关的包下面，看到 ReportFragment 的方法，onResume 和 dipatch。

可以猜测就是这里进行的事件分发。

public class ReportFragment extends Fragment {
    private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
            + ".LifecycleDispatcher.report_fragment_tag";
		
  	// 使用 无页面 Fragment 进行生命周期管理和分发
    public static void injectIfNeededIn(Activity activity) {
        // ProcessLifecycleOwner should always correctly work and some activities may not extend
        // FragmentActivity from support lib, so we use framework fragments for activities
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }
  ...
    // onResume 状态
    @Override
    public void onResume() {
        super.onResume();
        dispatchResume(mProcessListener);
        dispatch(Lifecycle.Event.ON_RESUME);
    }

   ...
		
     // 分发事件
    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }

        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }
}

其中注入方法在两个地方调用。

// ComponentActivity.java
@Override
@SuppressWarnings("RestrictedApi")
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);
}

// LifecycleDispatcher.java
class LifecycleDispatcher {

    private static AtomicBoolean sInitialized = new AtomicBoolean(false);

    static void init(Context context) {
        if (sInitialized.getAndSet(true)) {
            return;
        }
        ((Application) context.getApplicationContext())
                .registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
    }

    @SuppressWarnings("WeakerAccess")
    @VisibleForTesting
    static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {

        @Override
        public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
            ReportFragment.injectIfNeededIn(activity);
        }

        @Override
        public void onActivityStopped(Activity activity) {
        }

        @Override
        public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
        }
    }

    private LifecycleDispatcher() {
    }
}

下面来看一下后一个调用在哪发生。

// 初始化 LifeCycle 模块的内部类。
public class ProcessLifecycleOwnerInitializer extends ContentProvider {
    @Override
    public boolean onCreate() {
      	// 注入 Fragment 感知生命周期
        LifecycleDispatcher.init(getContext());
      	// 为 app 进程提供处理 LifeCycle 的能力。
        ProcessLifecycleOwner.init(getContext());
        return true;
    }
}

上述方法使用的 Provider 初始化模块的方法，第三方模块可以利用进行初始化操作

如何调用注解生命周期的方法

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
    Lifecycle.Event value();
}

在上述的堆栈调用中，在 Fragment 的 onResume 中进行处理。

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    State next = getStateAfter(event);
    moveToState(next);
}

private void moveToState(State next) {
  	// 当前状态与下一状态相等
    if (mState == next) {
        return;
    }
    mState = next;
    if (mHandlingEvent || mAddingObserverCounter != 0) {
        mNewEventOccurred = true;
        // we will figure out what to do on upper level.
        return;
    }
    mHandlingEvent = true;
    sync();
    mHandlingEvent = false;
}

// 对比当前状态和上一个状态，决定是前移还是后移
    private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "
                    + "new events from it.");
            return;
        }
        while (!isSynced()) {
            mNewEventOccurred = false;
            // no need to check eldest for nullability, because isSynced does it for us.
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

最终代码来到了分发的地方：

static class ObserverWithState {
    State mState;
    GenericLifecycleObserver mLifecycleObserver;

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

    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = getStateAfter(event);
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

// ReflectiveGenericLifecycleObserver
@Override
public void onStateChanged(LifecycleOwner source, Event event) {
    mInfo.invokeCallbacks(source, event, mWrapped);
}
// ClassesInfoCache.java
private static void invokeMethodsForEvent(List<MethodReference> handlers,
                LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
            if (handlers != null) {
                for (int i = handlers.size() - 1; i >= 0; i--) {
                    handlers.get(i).invokeCallback(source, event, mWrapped);
                }
            }
        }

通过反射解析注解得到对应注解的相关信息，最后通过方法的相关信息调用 invoke 实现对注解方法的调用。

我们在 Observer 用注解修饰的方法，会被通过反射的方式获取，并保存下来，然后在生命周期发生改变的时候再找到对应 Event 的方法，通过反射来调用方法。

总结

Lifecycle 是一个专门用来处理生命周期的库，它能够帮助我们将 Acitivity、Framgent 的生命周期处理与业务逻辑处理进行完全解耦，让我们能够更加专注于业务；通过解耦让 Activity、Fragment 的代码更加可读可维护。

可以这么说 Lifecycle 的出现彻底解决了 Android 开发遇到的生命周期处理难题，并且还给开发者带来了新的架构姿势，让我们可以设计出更加合理的架构。