Lifecycle - 应用及底层原理

Lifecycle的基本使用

1. Lifecycle 的基本概念

想象一个餐厅的营业周期：

• LifecycleOwner：餐厅老板（管理生命周期）
• LifecycleObserver：餐厅员工（观察生命周期）
• Lifecycle.Event：营业事件（开门、打烊等）
• Lifecycle.State：餐厅状态（准备中、营业中等）

2. 基本实现结构

// 1. 生命周期事件（餐厅的日常事件）
enum class Event {
    ON_CREATE,    // 开始准备
    ON_START,     // 开门营业
    ON_RESUME,    // 正式营业
    ON_PAUSE,     // 暂停营业
    ON_STOP,      // 停止营业
    ON_DESTROY    // 结束营业
}

// 2. 生命周期状态（餐厅的状态）
enum class State {
    INITIALIZED,  // 初始化
    CREATED,      // 准备就绪
    STARTED,      // 开始营业
    RESUMED,      // 营业中
    DESTROYED     // 结束营业
}

3. 生命周期流程图

graph TD
    A[INITIALIZED] --> B[CREATED]
    B --> C[STARTED]
    C --> D[RESUMED]
    D --> E[STARTED]
    E --> F[CREATED]
    F --> G[DESTROYED]
    
    B1[ON_CREATE] --> B
    C1[ON_START] --> C
    D1[ON_RESUME] --> D
    E1[ON_PAUSE] --> E
    F1[ON_STOP] --> F
    G1[ON_DESTROY] --> G

4. 使用示例

// 1. 定义一个生命周期观察者（餐厅员工）
class MyLifecycleObserver : DefaultLifecycleObserver {
    
    override fun onCreate(owner: LifecycleOwner) {
        // 餐厅开始准备
        println("准备开门")
    }
    
    override fun onStart(owner: LifecycleOwner) {
        // 餐厅开门
        println("开始营业")
    }
    
    override fun onResume(owner: LifecycleOwner) {
        // 餐厅正式营业
        println("正式营业")
    }
    
    override fun onPause(owner: LifecycleOwner) {
        // 餐厅暂停营业
        println("暂停营业")
    }
    
    override fun onStop(owner: LifecycleOwner) {
        // 餐厅停止营业
        println("停止营业")
    }
    
    override fun onDestroy(owner: LifecycleOwner) {
        // 餐厅结束营业
        println("结束营业")
    }
}

// 2. 在 Activity 中使用
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 添加生命周期观察者
        lifecycle.addObserver(MyLifecycleObserver())
    }
}

5. 实际应用场景

// 1. 自定义相机管理器
class CameraManager : DefaultLifecycleObserver {
    private var camera: Camera? = null
    
    override fun onResume(owner: LifecycleOwner) {
        // 打开相机
        camera = Camera.open()
    }
    
    override fun onPause(owner: LifecycleOwner) {
        // 释放相机
        camera?.release()
        camera = null
    }
}

// 2. 位置管理器
class LocationManager : DefaultLifecycleObserver {
    private var locationClient: LocationClient? = null
    
    override fun onStart(owner: LifecycleOwner) {
        // 开始定位
        locationClient?.startLocationUpdates()
    }
    
    override fun onStop(owner: LifecycleOwner) {
        // 停止定位
        locationClient?.stopLocationUpdates()
    }
}

6. Lifecycle 的内部实现

// 简化版的 LifecycleRegistry 实现
class LifecycleRegistry(private val provider: LifecycleOwner) : Lifecycle() {
    // 当前状态
    private var state = State.INITIALIZED
    
    // 观察者列表
    private val observers = mutableMapOf<LifecycleObserver, ObserverWithState>()
    
    // 处理生命周期事件
    fun handleLifecycleEvent(event: Event) {
        val newState = getStateAfter(event)
        moveToState(newState)
    }
    
    private fun moveToState(newState: State) {
        if (state == newState) return
        
        state = newState
        observers.forEach { (observer, observerWithState) ->
            observerWithState.dispatchEvent(provider, event)
        }
    }
}

7. 自定义 LifecycleOwner

class CustomLifecycleOwner : LifecycleOwner {
    private val lifecycleRegistry = LifecycleRegistry(this)
    
    override fun getLifecycle(): Lifecycle = lifecycleRegistry
    
    // 模拟生命周期事件
    fun simulateCreate() {
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
    }
    
    fun simulateDestroy() {
        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    }
}

8. 最佳实践

// 1. 组合使用
class MyViewModel(
    private val locationManager: LocationManager,
    private val cameraManager: CameraManager
) : ViewModel() {
    
    fun bindToLifecycle(lifecycleOwner: LifecycleOwner) {
        lifecycleOwner.lifecycle.apply {
            addObserver(locationManager)
            addObserver(cameraManager)
        }
    }
}

// 2. 在 Fragment 中使用
class MyFragment : Fragment() {
    private val viewModel: MyViewModel by viewModels()
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        viewModel.bindToLifecycle(viewLifecycleOwner)
    }
}

总结：

1. 核心组件：

   • LifecycleOwner：生命周期的拥有者（餐厅老板）
   • LifecycleObserver：生命周期的观察者（餐厅员工）
   • Lifecycle.Event：生命周期事件（营业事件）
   • Lifecycle.State：生命周期状态（餐厅状态）

2. 工作流程：

   • 注册观察者
   • 状态变化
   • 通知观察者
   • 处理事件

3. 使用场景：

   • 相机管理
   • 位置服务
   • 网络监听
   • 传感器管理

4. 最佳实践：

   • 合理使用生命周期感知
   • 及时释放资源
   • 避免内存泄漏
   • 组件解耦

记住：

• Lifecycle 就像餐厅的营业管理系统
• LifecycleOwner 是餐厅老板
• LifecycleObserver 是餐厅员工
• Event 是各种营业事件
• State 是餐厅的营业状态

为什么要用lifecycle呢？

1. 传统方式的问题

想象一个餐厅（Activity）的管理方式：

// ❌ 传统方式：所有逻辑都在 Activity 中
class RestaurantActivity : AppCompatActivity() {
    private var musicPlayer: MusicPlayer? = null
    private var orderSystem: OrderSystem? = null
    private var securitySystem: SecuritySystem? = null
    
    override fun onCreate() {
        super.onCreate()
        // 1. 初始化音乐播放器
        musicPlayer = MusicPlayer()
        // 2. 初始化订单系统
        orderSystem = OrderSystem()
        // 3. 初始化安保系统
        securitySystem = SecuritySystem()
    }
    
    override fun onStart() {
        super.onStart()
        // 1. 开始播放音乐
        musicPlayer?.start()
        // 2. 启动订单系统
        orderSystem?.start()
        // 3. 开启安保系统
        securitySystem?.start()
    }
    
    override fun onStop() {
        super.onStop()
        // 1. 停止音乐
        musicPlayer?.stop()
        // 2. 暂停订单系统
        orderSystem?.stop()
        // 3. 关闭安保系统
        securitySystem?.stop()
    }
}

问题：

1. 代码耦合严重（所有系统都混在一起）
2. 难以维护（改一个功能可能影响其他功能）
3. 代码重复（每个 Activity 都要写类似代码）

2. 使用 Lifecycle 的优势

// ✅ 使用 Lifecycle：每个系统独立管理
class MusicManager : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        // 开始播放音乐
        startMusic()
    }
    
    override fun onStop(owner: LifecycleOwner) {
        // 停止音乐
        stopMusic()
    }
}

class OrderManager : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        // 启动订单系统
        startOrderSystem()
    }
    
    override fun onStop(owner: LifecycleOwner) {
        // 暂停订单系统
        stopOrderSystem()
    }
}

// Activity 变得简单了
class RestaurantActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 只需要注册观察者
        lifecycle.addObserver(MusicManager())
        lifecycle.addObserver(OrderManager())
        lifecycle.addObserver(SecurityManager())
    }
}

3. 生命周期感知的好处

graph TD
    A[传统方式] --> B[代码耦合]
    A --> C[难以维护]
    A --> D[代码重复]
    
    E[Lifecycle方式] --> F[解耦合]
    E --> G[易维护]
    E --> H[代码复用]

4. 实际应用场景

// 1. 位置服务
class LocationManager : DefaultLifecycleObserver {
    override fun onResume(owner: LifecycleOwner) {
        // 自动开始定位
        startLocationUpdates()
    }
    
    override fun onPause(owner: LifecycleOwner) {
        // 自动停止定位
        stopLocationUpdates()
    }
}

// 2. 相机管理
class CameraManager : DefaultLifecycleObserver {
    override fun onResume(owner: LifecycleOwner) {
        // 自动打开相机
        openCamera()
    }
    
    override fun onPause(owner: LifecycleOwner) {
        // 自动关闭相机
        closeCamera()
    }
}

// 3. 可以在任何 Activity/Fragment 中复用
class CameraActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(CameraManager())
    }
}

5. 组件化开发

// 1. 独立的功能模块
class AnalyticsComponent : DefaultLifecycleObserver {
    override fun onResume(owner: LifecycleOwner) {
        // 开始统计
        startTracking()
    }
    
    override fun onPause(owner: LifecycleOwner) {
        // 停止统计
        stopTracking()
    }
}

// 2. 可以方便地添加到任何页面
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(AnalyticsComponent())
    }
}

6. 优势总结

1. 解耦合：

   • 每个功能独立管理
   • 不同功能互不影响
   • 便于维护和测试

2. 代码复用：

   • 功能模块可以复用
   • 不需要重复编写代码
   • 降低出错概率

3. 生命周期安全：

   • 自动处理生命周期
   • 避免内存泄漏
   • 减少崩溃风险

4. 组件化开发：

   • 便于团队协作
   • 模块独立开发
   • 易于集成和测试

总结：

使用 Lifecycle 的原因：

1. 代码组织更好：

   • 功能模块化
   • 责任分明
   • 易于维护

2. 复用性更强：

   • 组件可复用
   • 减少重复代码
   • 提高开发效率

3. 更安全：

   • 自动管理生命周期
   • 避免常见问题
   • 减少人为错误

4. 更灵活：

   • 随时添加/移除功能
   • 便于扩展
   • 适应性强

记住：

• 传统方式像是一个人管理整个餐厅
• Lifecycle 方式像是给每个部门都配了经理
• 每个经理负责自己的工作
• 餐厅老板（Activity）不需要事事亲力亲为

lifecycle 在 Activity 中的使用

1. ComponentActivity 的实现

// ComponentActivity 的简化实现
open class ComponentActivity : Activity(), LifecycleOwner {
    // 1. 内部持有 LifecycleRegistry
    private val mLifecycleRegistry = LifecycleRegistry(this)
    
    // 2. 实现 LifecycleOwner 接口
    override fun getLifecycle(): Lifecycle {
        return mLifecycleRegistry
    }
    
    // 3. 在各个生命周期方法中分发事件
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
    }
    
    override fun onStart() {
        super.onStart()
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
    }
    
    // ... 其他生命周期方法类似
}

2. 继承关系

graph TD
    A[Activity] --> B[ComponentActivity]
    B --> C[FragmentActivity]
    C --> D[AppCompatActivity]
    D --> E[RestaurantActivity]
    
    F[LifecycleOwner] -.-> B

3. 实际工作流程

// 1. AppCompatActivity 继承自 ComponentActivity
class AppCompatActivity : ComponentActivity {
    // 继承了 lifecycle 属性
}

// 2. 我们的 Activity
class RestaurantActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // lifecycle 是从 ComponentActivity 继承的属性
        // 实际上是调用了 getLifecycle() 方法
        lifecycle.addObserver(MusicManager())
    }
}

所以：

1. lifecycle 属性来自 ComponentActivity
2. 实际是通过实现 LifecycleOwner 接口获得
3. 内部使用 LifecycleRegistry 管理生命周期

就像餐厅的管理系统：

• ComponentActivity 是系统的基础设施
• LifecycleRegistry 是实际的管理系统
• lifecycle 属性就是访问这个管理系统的入口