Android Lifecycle 源码解析

一、整体架构设计

Android Lifecycle 组件采用分层架构设计：

scss 复制代码

+--------------------------------+
|          LifecycleOwner         |
|  (Activity/Fragment/ViewModel) |
+--------------------------------+
                |
                | getLifecycle()
                v
+--------------------------------+
|         LifecycleRegistry      |
| (状态管理 & 事件分发的核心实现) |
+--------------------------------+
                |
                | handleLifecycleEvent()
                v
+--------------------------------+
|         LifecycleObserver      |
| (开发者实现的业务逻辑观察者)    |
+--------------------------------+

核心设计思想：

观察者模式：解耦生命周期事件产生和消费
状态机模型：确保状态转换有序性
分层设计：支持多种宿主（Activity/Fragment/Service等）

二、Activity中的Lifecycle实现

核心类分析

scala 复制代码

// androidx.activity.ComponentActivity
public class ComponentActivity extends ... implements LifecycleOwner {
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 注入关键组件
        ReportFragment.injectIfNeededIn(this);
    }
    
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

ReportFragment 工作机制

scss 复制代码

// androidx.lifecycle.ReportFragment
public class ReportFragment extends Fragment {
    public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            // Android 10+ 使用新API
            LifecycleCallbacks.registerIn(activity);
        }
        FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            // 添加无UI的Fragment作为生命周期监听器
            manager.beginTransaction()
                    .add(new ReportFragment(), REPORT_FRAGMENT_TAG)
                    .commit();
            manager.executePendingTransactions();
        }
    }
    
    @Override
    public void onStart() {
        super.onStart();
        dispatch(Lifecycle.Event.ON_START);
    }
    
    private void dispatch(Lifecycle.Event event) {
        if (getActivity() instanceof LifecycleOwner) {
            LifecycleRegistry registry = (LifecycleRegistry) 
                ((LifecycleOwner) getActivity()).getLifecycle();
            registry.handleLifecycleEvent(event);
        }
    }
    
    // Android 10+ 替代方案
    static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
        static void registerIn(Activity activity) {
            activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
        }
        
        public void onActivityPostStarted(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_START);
        }
        
        static void dispatch(Activity activity, Lifecycle.Event event) {
            if (activity instanceof LifecycleOwner) {
                LifecycleRegistry registry = (LifecycleRegistry) 
                    ((LifecycleOwner) activity).getLifecycle();
                registry.handleLifecycleEvent(event);
            }
        }
    }
}

Activity生命周期事件流转

scss 复制代码

系统触发Activity.onStart()
    → ReportFragment.onStart()
        → dispatch(ON_START)
            → LifecycleRegistry.handleLifecycleEvent(ON_START)
                → 状态迁移(CREATED → STARTED)
                → 通知所有观察者

三、Fragment中的Lifecycle实现

Fragment生命周期管理源码

csharp 复制代码

// androidx.fragment.app.Fragment
public class Fragment implements ... LifecycleOwner {
    private final LifecycleRegistry mLifecycleRegistry;
    
    public Fragment() {
        mLifecycleRegistry = new LifecycleRegistry(this);
    }
    
    void performCreate(Bundle savedInstanceState) {
        onCreate(savedInstanceState);
        // 直接分发生命周期事件
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }
    
    void performStart() {
        onStart();
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }
    
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

Fragment与Activity生命周期协同

scss 复制代码

Activity onCreate()
    → 创建Fragment实例
    → Fragment.performCreate()
        → Fragment.onCreate()
        → mLifecycleRegistry.handleLifecycleEvent(ON_CREATE)
        
Activity onStart()
    → Fragment.performStart()
        → Fragment.onStart()
        → mLifecycleRegistry.handleLifecycleEvent(ON_START)

四、事件调用流程深度分析

完整事件分发流程

scss 复制代码

// 核心分发入口
public class LifecycleRegistry extends Lifecycle {
    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;
            return;
        }
        
        sync();
    }
    
    private void sync() {
        while (!isSynced()) {
            mNewEventOccurred = false;
            
            // 向前推进状态
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) > 0) {
                backwardPass();
            }
            
            // 向后回退状态
            if (mState.compareTo(mObserverMap.newest().getValue().mState) < 0) {
                forwardPass();
            }
        }
    }
    
    private void forwardPass() {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
                mObserverMap.iteratorWithAdditions();
        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
            ObserverWithState observer = entry.getValue();
            
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred) {
                pushParentState(observer.mState);
                final Event event = Event.upFrom(observer.mState);
                if (event == null) {
                    throw new IllegalStateException("no event up from " + observer.mState);
                }
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }
}

ObserverWithState 事件分发

ini 复制代码

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 = getStateAfter(event);
        mState = min(mState, newState);
        // 关键：调用观察者的回调方法
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

事件到观察者的映射过程

scss 复制代码

LifecycleRegistry.handleLifecycleEvent(ON_START)
    → moveToState(STARTED)
        → sync()
            → forwardPass()
                → 遍历所有观察者
                → 对于每个需要更新的观察者：
                    → ObserverWithState.dispatchEvent(owner, ON_START)
                        → LifecycleEventObserver.onStateChanged(owner, ON_START)
                            → 最终调用开发者定义的 @OnLifecycleEvent 方法

五、状态管理机制深度剖析

状态转换源码实现

csharp 复制代码

// androidx.lifecycle.Lifecycle
static State getStateAfter(Event event) {
    switch (event) {
        case ON_CREATE:
        case ON_STOP:
            return CREATED;
        case ON_START:
        case ON_PAUSE:
            return STARTED;
        case ON_RESUME:
            return RESUMED;
        case ON_DESTROY:
            return DESTROYED;
        case ON_ANY:
        default:
            throw new IllegalArgumentException("Unexpected event value " + event);
    }
}

static Event downEvent(State state) {
    switch (state) {
        case INITIALIZED:
            throw new IllegalArgumentException();
        case CREATED:
            return ON_DESTROY;
        case STARTED:
            return ON_STOP;
        case RESUMED:
            return ON_PAUSE;
        case DESTROYED:
            throw new IllegalArgumentException();
    }
    throw new IllegalArgumentException("Unexpected state value " + state);
}

状态同步算法

LifecycleRegistry 使用两阶段状态同步算法：

状态迁移阶段：
- 确定目标状态
- 标记需要更新的观察者
事件分发阶段：
- 按添加顺序遍历观察者
- 对每个观察者执行最小步数状态迁移
- 保证不会跳过中间状态

scss 复制代码

// 状态同步核心算法
private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) return;
    
    while (!isSynced()) {
        mNewEventOccurred = false;
        
        // 需要向后回退状态
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        
        // 需要向前推进状态
        if (!mNewEventOccurred && 
            mObserverMap.newest() != null &&
            mState.compareTo(mObserverMap.newest().getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    
    mNewEventOccurred = false;
}

六、高级特性与设计思想

1. 生命周期事件与状态关系

事件(Event)	触发方法	状态(State)变化
ON_CREATE	onCreate()	INITIALIZED → CREATED
ON_START	onStart()	CREATED → STARTED
ON_RESUME	onResume()	STARTED → RESUMED
ON_PAUSE	onPause()	RESUMED → STARTED
ON_STOP	onStop()	STARTED → CREATED
ON_DESTROY	onDestroy()	CREATED → DESTROYED
ON_ANY	所有事件	无直接变化

2. 观察者优先级机制

LifecycleRegistry 支持三种观察者优先级：

arduino 复制代码

public enum ObserverPriority {
    // 最高优先级，最先接收事件
    HIGH,
    
    // 默认优先级
    NORMAL,
    
    // 最低优先级，最后接收事件
    LOW
}

优先级实现原理：

less 复制代码

public void addObserver(@NonNull LifecycleObserver observer) {
    addObserver(observer, ObserverPriority.NORMAL);
}

public void addObserver(@NonNull LifecycleObserver observer, 
                        @NonNull ObserverPriority priority) {
    // 根据优先级插入到不同位置
    switch (priority) {
        case HIGH:
            mObserverMap.putAtFront(observer, statefulObserver);
            break;
        case LOW:
            mObserverMap.putAtEnd(observer, statefulObserver);
            break;
        default:
            mObserverMap.put(observer, statefulObserver);
    }
    
    // 立即同步状态
    while (...) {
        // 状态迁移逻辑
    }
}

3. 生命周期边界情况处理

情况1：配置变更时的状态保留

less 复制代码

// ComponentActivity 中处理配置变更
public void onConfigurationChanged(@NonNull Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
    
    // 重建时保留ViewModel
    if (mViewModelStore != null) {
        mViewModelStore.clear();
    }
    
    // 重新分发CREATE事件
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}

情况2：添加观察者时的状态同步

less 复制代码

public void addObserver(@NonNull LifecycleObserver observer) {
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    
    // 立即同步到当前状态
    while (statefulObserver.mState.compareTo(mState) < 0) {
        pushParentState(statefulObserver.mState);
        statefulObserver.dispatchEvent(upEvent(statefulObserver.mState));
        popParentState();
    }
}

总结

Android Lifecycle 组件的设计精髓：

事件驱动架构：通过无界面Fragment捕获系统事件
状态机模型：确保状态转换的有序性和一致性
观察者模式：解耦生命周期产生者和消费者
分层设计：支持Activity、Fragment等多种宿主
资源安全：内置内存泄漏防护机制