Activity：生命周期与状态

Activity
 └── PhoneWindow                  (Window 的唯一实现)
      └── DecorView               (顶层 ViewGroup，继承自 FrameLayout)
           ├── StatusBar 区域      (系统状态栏占位)
           ├── Title/ActionBar     (标题栏区域，取决于主题)
           └── ContentFrameLayout  (android.R.id.content)
                └── 你的布局 XML    (setContentView 传入的布局)

// Activity.java 中的 setContentView 方法
public void setContentView(@LayoutRes int layoutResID) {
    // Activity 不自己处理布局，而是直接委托给 Window 对象
    // 这里的 getWindow() 返回的就是 PhoneWindow 实例
    getWindow().setContentView(layoutResID);
    // 初始化 ActionBar（如果当前主题包含 ActionBar 的话）
    initWindowDecorActionBar();
}

// PhoneWindow.java 中的 setContentView 方法（简化）
@Override
public void setContentView(int layoutResID) {
    // mContentParent 就是 id 为 android.R.id.content 的 FrameLayout
    // 首次调用时它为 null，需要先安装 DecorView
    if (mContentParent == null) {
        // installDecor() 会创建 DecorView 和 mContentParent
        // 这是整个窗口视图层级的初始化入口
        // 它会根据当前主题/窗口特性来决定 DecorView 的内部结构
        installDecor();
    } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        // 如果不是首次调用且没有内容转场动画
        // 先清空之前的所有子 View
        mContentParent.removeAllViews();
    }
    if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        // 如果启用了内容转场，走转场动画的设置流程
        final Scene newScene = Scene.getSceneForLayout(
            mContentParent, layoutResID, getContext()
        );
        transitionTo(newScene);
    } else {
        // 核心操作：将开发者传入的布局 XML inflate 到 mContentParent 中
        // 这一步才真正把你写的布局变成 View 对象并添加到视图树中
        mLayoutInflater.inflate(layoutResID, mContentParent);
    }
    // 通知 DecorView 内容已经改变，触发 WindowInsets 的重新应用
    mContentParent.requestApplyInsets();
    // 回调通知 Activity 内容已变更
    final Callback cb = getCallback();
    if (cb != null && !isDestroyed()) {
        // Activity 实现了 Window.Callback 接口
        // 这个回调让 Activity 有机会在内容变更后做额外处理
        cb.onContentChanged();
    }
}

// Activity.java 的 attach 方法（简化关键部分）
final void attach(Context context, ActivityThread aThread,
        Instrumentation instr, IBinder token, int ident,
        Application application, Intent intent, ActivityInfo info,
        CharSequence title, Activity parent, String id,
        NonConfigurationInstances lastNonConfigurationInstances,
        Configuration config, String referrer, IVoiceInteractor voiceInteractor,
        Window window, ActivityConfigCallback activityConfigCallback,
        IBinder assistToken, IBinder shareableActivityToken) {
 
    // 第一步：绑定 Context —— 确立"Context 实现"身份
    // 调用 attachBaseContext，将 ContextImpl 赋值给 mBase
    // 从此 Activity 拥有了访问系统资源和服务的完整能力
    attachBaseContext(context);
 
    // 第二步：创建 PhoneWindow —— 确立"Window 容器"身份
    // Activity 的窗口从这里诞生
    mWindow = new PhoneWindow(this, window, activityConfigCallback);
 
    // 第三步：设置 Window.Callback —— 确立"交互控制器"身份
    // Activity 自身作为 Window.Callback 传入
    // 窗口中的按键事件、触摸事件、菜单事件等都会回调到 Activity
    mWindow.setWindowControllerCallback(mWindowControllerCallback);
    mWindow.setCallback(this);
    mWindow.setOnWindowDismissedCallback(this);
 
    // 为 PhoneWindow 设置 WindowManager
    // WindowManager 是与系统 WMS（WindowManagerService）通信的 IPC 桥梁
    // 后续 DecorView 的添加、移除、更新都通过它来完成
    mWindow.setWindowManager(
            (WindowManager) context.getSystemService(Context.WINDOW_SERVICE),
            mToken,  // IBinder token，Activity 在 AMS 中的身份标识
            mComponent.flattenToString(),
            (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
    // 保存 WindowManager 引用，方便后续使用
    mWindowManager = mWindow.getWindowManager();
}

// ActivityThread.handleResumeActivity() 简化逻辑
public void handleResumeActivity(ActivityClientRecord r,
        boolean finalStateRequest, boolean isForward, String reason) {
 
    // 1. 先触发 Activity.onResume() 回调
    // 此时 View 树已构建但尚未提交给系统绘制
    if (!performResumeActivity(r, finalStateRequest, reason)) {
        return;
    }
 
    final Activity a = r.activity;
 
    // 2. onResume() 之后，将 DecorView 添加到 WindowManager
    if (r.window == null && !a.mFinished && willBeVisible) {
        r.window = r.activity.getWindow();
        View decor = r.window.getDecorView();
        // 先设置为不可见，等布局完成后再显示
        decor.setVisibility(View.INVISIBLE);
        ViewManager wm = a.getWindowManager();
        WindowManager.LayoutParams l = r.window.getAttributes();
        a.mDecor = decor;
 
        // 关键调用：addView 会创建 ViewRootImpl
        // ViewRootImpl 是应用进程中 View 系统与 WMS 之间的核心纽带
        // 它负责触发 measure、layout、draw 三大流程
        // 最终将像素数据通过 Surface 提交给 SurfaceFlinger 合成显示
        wm.addView(decor, l);
    }
 
    // 3. 让 DecorView 变为可见
    if (r.activity.mVisibleFromClient) {
        r.activity.makeVisible();
        // makeVisible() 内部：mDecor.setVisibility(View.VISIBLE)
    }
}

// Activity.java 中的触摸事件分发 —— 事件分发的应用层入口
// 每一个触摸事件都会先经过这里
public boolean dispatchTouchEvent(MotionEvent ev) {
    // ACTION_DOWN 表示一次新的触摸序列开始
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {
        // onUserInteraction() 是一个空方法，供子类重写
        // 常用于：重置屏幕超时计时器、统计用户活跃度
        // 记录用户最后交互时间等场景
        onUserInteraction();
    }
    // 将事件委托给 PhoneWindow 的 superDispatchTouchEvent
    // PhoneWindow 内部会调用 DecorView.dispatchTouchEvent()
    // 然后沿着 ViewGroup → View 的标准路径向下传递
    if (getWindow().superDispatchTouchEvent(ev)) {
        // 如果 View 层级中有任何一个 View 消费了这个事件
        // 返回 true，分发结束
        return true;
    }
    // 如果整个 View 树都没有消费这个事件
    // 最终由 Activity 自己的 onTouchEvent() 兜底处理
    // 这是 Activity 作为"最后防线"的体现
    return onTouchEvent(ev);
}

Activity.getSystemService()
  → ContextThemeWrapper.getSystemService()
    → ContextWrapper.getSystemService()
      → mBase.getSystemService()         // mBase 是 ContextImpl 实例
        → ContextImpl.getSystemService() // 真正的实现逻辑

// ActivityThread.performLaunchActivity() 简化逻辑
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    // 1. 创建 ContextImpl —— 这是真正的 Context 实现
    // createActivityContext 会关联 packageInfo、activityInfo、token 等信息
    ContextImpl appContext = ContextImpl.createActivityContext(
        this, r.packageInfo, r.activityInfo, r.token, displayId, r.overrideConfig
    );
 
    // 2. 通过反射创建 Activity 实例
    // 此时 Activity 还是一个"空壳"，没有任何 Context 能力
    Activity activity = mInstrumentation.newActivity(
        cl, component.getClassName(), r.intent
    );
 
    // 3. 调用 activity.attach() —— 关键的绑定步骤
    // 在这里，Activity 同时获得了三重身份：
    //   - Context 能力（通过 attachBaseContext 绑定 ContextImpl）
    //   - Window 容器（创建 PhoneWindow）
    //   - 交互控制器（设置 Window.Callback）
    activity.attach(
        appContext,       // ContextImpl 实例，将赋值给 mBase
        this,             // ActivityThread 引用
        mInstrumentation, // Instrumentation 用于监控和测试
        r.token,          // IBinder token，Activity 在 AMS 中的身份标识
        r.ident,          // 标识符
        app,              // Application 实例
        r.intent,         // 启动 Intent
        r.activityInfo,   // AndroidManifest 中声明的 Activity 信息
        title,            // 窗口标题
        r.parent,         // 父 Activity（用于嵌入模式，现已少用）
        r.embeddedID,
        r.lastNonConfigurationInstances, // 配置变更时保留的数据
        config,           // Configuration 配置信息
        r.referrer,
        r.voiceInteractor,
        window,           // Window 参数
        r.configCallback,
        r.assistToken,
        r.shareableActivityToken
    );
 
    // 4. 最后才调用 onCreate()
    // 到这里 Activity 已经拥有了完整的 Context 能力
    // 可以安全地调用 setContentView、getResources、getSystemService 等
    if (r.isPersistable()) {
        mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
    } else {
        mInstrumentation.callActivityOnCreate(activity, r.state);
    }
 
    return activity;
}

// ❌ 危险示例：单例持有 Activity Context
object ToastManager {
    // 这个 context 字段会持有 Activity 的引用
    // 当 Activity 被销毁（如旋转屏幕）时，旧 Activity 无法被 GC 回收
    private lateinit var context: Context
 
    fun init(context: Context) {
        // 直接保存了传入的 Context（可能是 Activity）
        this.context = context
    }
 
    fun showToast(message: String) {
        Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
    }
}
 
// ✅ 正确做法：使用 Application Context
object ToastManager {
    private lateinit var context: Context
 
    fun init(context: Context) {
        // applicationContext 的生命周期与进程一致
        // 不会因 Activity 销毁而导致泄漏
        this.context = context.applicationContext
    }
 
    fun showToast(message: String) {
        Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
    }
}

// Activity 的 onCreate 回调 —— 整个生命周期的起点
override fun onCreate(savedInstanceState: Bundle?) {
    // 必须首先调用 super.onCreate()
    // 父类会在这里恢复 Fragment 状态、初始化 Loader 等
    super.onCreate(savedInstanceState)
 
    // setContentView 内部做了三件事：
    // 1. 通过 PhoneWindow.setContentView() 创建 DecorView（如果还没有）
    // 2. 将你的布局 XML inflate 成 View 树
    // 3. 将 View 树添加到 DecorView 的 content 区域（id 为 android.R.id.content 的 FrameLayout）
    setContentView(R.layout.activity_main)
 
    // 此时 View 树已经创建完毕，但尚未进行 measure/layout/draw
    // 所以你可以安全地 findViewById 或使用 ViewBinding
    val binding = ActivityMainBinding.bind(
        findViewById(android.R.id.content) // 获取 content 根布局
    )
 
    // 判断是否为重建场景
    if (savedInstanceState != null) {
        // 从 Bundle 中恢复之前保存的状态
        val scrollPosition = savedInstanceState.getInt("scroll_pos", 0)
        binding.recyclerView.scrollToPosition(scrollPosition)
    }
 
    // 初始化 ViewModel —— ViewModel 的生命周期跨越配置变更
    // 所以即使 Activity 重建，ViewModel 中的数据依然存在
    val viewModel: MainViewModel by viewModels()
 
    // 设置 RecyclerView Adapter、注册点击监听等一次性操作
    binding.recyclerView.adapter = MyAdapter(viewModel.items)
}

override fun onStart() {
    // 调用 super 确保 Lifecycle 状态正确转移到 STARTED
    // 此时所有注册了 ON_START 事件的 LifecycleObserver 会收到通知
    super.onStart()
 
    // 注册广播接收器 —— 只在 Activity 可见时接收广播
    // 与 onStop() 中的 unregister 配对
    registerReceiver(networkReceiver, IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION))
 
    // 开始监听数据变化
    // LiveData 在 STARTED 状态下才会分发数据给 Observer
    // 所以这里是确认 LiveData 观察生效的时机
    viewModel.userData.observe(this) { user ->
        binding.userName.text = user.name
    }
 
    // 检查权限状态 —— 用户可能在设置中修改了权限
    checkLocationPermission()
}

override fun onResume() {
    // super.onResume() 之后，Lifecycle 状态变为 RESUMED
    // 所有 LifecycleObserver 收到 ON_RESUME 事件
    super.onResume()
 
    // 恢复动画、视频播放等需要焦点的操作
    // 这些操作在 onPause() 中被暂停
    videoPlayer.resume()
 
    // 开始请求传感器数据 —— 传感器回调频率高，只在前台时监听
    sensorManager.registerListener(
        accelerometerListener,
        accelerometer,
        SensorManager.SENSOR_DELAY_UI  // UI 级别的采样率
    )
 
    // 刷新 UI 状态 —— 用户可能从其他 Activity 返回
    // 比如从设置页面修改了主题，回来后需要刷新
    refreshThemeIfNeeded()
 
    // 启动周期性 UI 更新（如倒计时、实时时钟）
    startUiUpdateTimer()
}

override fun onPause() {
    // super.onPause() 将 Lifecycle 状态从 RESUMED 降为 STARTED
    super.onPause()
 
    // 暂停动画和视频 —— 失去焦点后不应继续播放
    videoPlayer.pause()
 
    // 停止传感器监听 —— 减少不必要的电量消耗
    sensorManager.unregisterListener(accelerometerListener)
 
    // 停止周期性 UI 更新
    stopUiUpdateTimer()
 
    // ⚠️ 不要在这里做耗时操作！
    // 错误示范：database.saveAllDataSync() ← 这会阻塞 UI 线程
    // 正确做法：使用协程或 WorkManager 异步保存
    lifecycleScope.launch(Dispatchers.IO) {
        // 异步保存用户的临时编辑状态
        repository.saveDraft(currentDraft)
    }
}

override fun onStop() {
    // super.onStop() 将 Lifecycle 状态降为 CREATED
    super.onStop()
 
    // 注销广播接收器 —— 与 onStart() 中的注册配对
    unregisterReceiver(networkReceiver)
 
    // 持久化数据 —— onStop() 是保存数据的最佳时机
    // 从 Android 7.0 (API 24) 开始，系统保证 onStop() 一定会被调用
    // （之前只保证 onPause() 一定被调用）
    lifecycleScope.launch(Dispatchers.IO) {
        // 将用户编辑的内容保存到数据库
        repository.saveUserProgress(currentProgress)
    }
 
    // 释放重量级资源
    // 比如关闭相机预览 —— 相机是独占资源，不释放会阻止其他应用使用
    cameraProvider.unbindAll()
 
    // 取消不再需要的网络请求
    pendingRequests.forEach { it.cancel() }
}

override fun onDestroy() {
    // super.onDestroy() 将 Lifecycle 状态设为 DESTROYED
    // 所有 LifecycleObserver 收到 ON_DESTROY 事件
    // LiveData 的 Observer 会被自动移除（Lifecycle-aware 的优势）
    super.onDestroy()
 
    if (isFinishing) {
        // 用户主动退出 —— 执行彻底的清理
        // 清除缓存、关闭数据库连接、释放所有资源
        cache.evictAll()
        database.close()
 
        // 取消所有后台任务
        // 注意：lifecycleScope 会在 onDestroy 后自动取消
        // 但如果你使用了自定义的 CoroutineScope，需要手动取消
        customScope.cancel()
    } else {
        // 配置变更导致的重建 —— 只释放与 View 相关的资源
        // ViewModel 会存活，不需要清理 ViewModel 中的数据
        // 但需要释放持有 Activity 引用的对象，防止内存泄漏
        binding = null  // 清除 ViewBinding 引用
    }
 
    // 无论哪种情况，都应该释放的资源：
    // 注销不再需要的回调、关闭流、释放 Native 资源
    mediaPlayer?.release()
    mediaPlayer = null
}

# 先把 App 切到后台（按 Home 键），然后执行：
adb shell am kill com.example.myapp
# 注意：是 "am kill" 而不是 "am force-stop"
# am kill 会模拟 LMK 的行为，保留 saved state
# am force-stop 则会清除所有状态，相当于用户强制停止

<!-- 声明 Activity 自行处理屏幕方向和屏幕尺寸变化 -->
<!-- 注意：orientation 和 screenSize 通常需要一起声明 -->
<activity
    android:name=".VideoPlayerActivity"
    android:configChanges="orientation|screenSize|screenLayout|smallestScreenSize" />

// 当声明了 configChanges 后，配置变更时系统调用此方法
// 而不是走 onDestroy -> onCreate 的重建流程
override fun onConfigurationChanged(newConfig: Configuration) {
    // 必须调用 super，否则会抛出 SuperNotCalledException
    super.onConfigurationChanged(newConfig)
 
    // 通过 newConfig 判断当前的配置状态
    when (newConfig.orientation) {
        // 横屏：可以切换到横屏专用的 UI 布局
        Configuration.ORIENTATION_LANDSCAPE -> {
            // 例如视频播放器进入全屏模式
            enterFullScreen()
        }
        // 竖屏：恢复默认的竖屏布局
        Configuration.ORIENTATION_PORTRAIT -> {
            // 退出全屏模式
            exitFullScreen()
        }
    }
}

// Bundle 只能存储以下类型的数据：
// 1. 基本类型：Int, Long, Float, Double, Boolean, String
// 2. 基本类型数组：IntArray, LongArray, StringArray 等
// 3. Parcelable 对象：实现了 Parcelable 接口的对象
// 4. Serializable 对象：实现了 Serializable 接口的对象（性能较差）
// 5. 嵌套 Bundle
 
// ❌ 不能存储的：
// - 普通对象（没有实现 Parcelable/Serializable）
// - Bitmap（太大，应该存文件路径）
// - Context 引用（会导致内存泄漏）
// - 大量数据（Bundle 总大小限制约 1MB，超过会抛 TransactionTooLargeException）

class OrderFormActivity : AppCompatActivity() {
 
    // 这些成员变量在 Activity 重建后会丢失（因为是新对象）
    // 需要手动保存到 Bundle 中
    private var selectedCityId: Int = -1          // 用户选择的城市 ID
    private var currentStep: Int = 0              // 当前表单步骤
    private var isDiscountApplied: Boolean = false // 是否已应用优惠券
 
    override fun onSaveInstanceState(outState: Bundle) {
        // 必须先调用 super，让系统保存 View 树的状态
        // 如果忘记调用 super，EditText 的文本、ScrollView 的位置等都会丢失
        super.onSaveInstanceState(outState)
 
        // 手动保存自定义的 UI 状态
        // 使用常量 Key 避免拼写错误
        outState.putInt(KEY_SELECTED_CITY, selectedCityId)
        outState.putInt(KEY_CURRENT_STEP, currentStep)
        outState.putBoolean(KEY_DISCOUNT_APPLIED, isDiscountApplied)
 
        // ⚠️ 不要在这里保存大对象！
        // 例如不要保存从网络获取的订单列表数据
        // 那些数据应该放在 ViewModel + Repository 中管理
    }
 
    companion object {
        // 使用常量定义 Bundle 的 Key，防止拼写错误导致的 Bug
        private const val KEY_SELECTED_CITY = "key_selected_city"
        private const val KEY_CURRENT_STEP = "key_current_step"
        private const val KEY_DISCOUNT_APPLIED = "key_discount_applied"
    }
}

override fun onCreate(savedInstanceState: Bundle?) {
    // 调用 super 时传入 savedInstanceState
    // 系统会在 super.onCreate() 中恢复 Fragment 的状态、View 树的状态等
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_order_form)
 
    // 判断是否是从保存状态恢复
    if (savedInstanceState != null) {
        // 恢复场景：从 Bundle 中取回之前保存的状态
        selectedCityId = savedInstanceState.getInt(KEY_SELECTED_CITY, -1)
        currentStep = savedInstanceState.getInt(KEY_CURRENT_STEP, 0)
        isDiscountApplied = savedInstanceState.getBoolean(KEY_DISCOUNT_APPLIED, false)
 
        // 根据恢复的状态更新 UI
        // 例如跳转到之前的表单步骤
        navigateToStep(currentStep)
    } else {
        // 首次创建场景：执行默认初始化
        // 例如从 Intent 中读取初始参数
        selectedCityId = intent.getIntExtra("city_id", -1)
        currentStep = 0
        isDiscountApplied = false
    }
}

override fun onRestoreInstanceState(savedInstanceState: Bundle) {
    // 调用 super 让系统恢复 View 树的状态
    // 包括 EditText 文本、CheckBox 选中状态、ScrollView 滚动位置等
    super.onRestoreInstanceState(savedInstanceState)
 
    // 这里不需要判空，因为只有确实有保存状态时才会调用
    selectedCityId = savedInstanceState.getInt(KEY_SELECTED_CITY, -1)
    currentStep = savedInstanceState.getInt(KEY_CURRENT_STEP, 0)
    isDiscountApplied = savedInstanceState.getBoolean(KEY_DISCOUNT_APPLIED, false)
 
    // 恢复 UI 状态
    updateStepIndicator(currentStep)
}

class SearchActivity : AppCompatActivity() {
 
    // UI 状态：这些变量在 Activity 重建后会丢失
    private var searchQuery: String = ""        // 当前搜索关键词
    private var filterType: Int = FILTER_ALL    // 当前筛选类型
    private var isFilterPanelOpen: Boolean = false // 筛选面板是否展开
 
    // ViewModel：不受配置变更影响，但进程死亡后会丢失
    // 如果需要进程死亡后也能恢复，使用 SavedStateHandle
    private val viewModel: SearchViewModel by viewModels()
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_search)
 
        if (savedInstanceState != null) {
            // ---- 恢复场景 ----
            // 从 Bundle 恢复轻量级 UI 状态
            searchQuery = savedInstanceState.getString(KEY_QUERY, "")
            filterType = savedInstanceState.getInt(KEY_FILTER, FILTER_ALL)
            isFilterPanelOpen = savedInstanceState.getBoolean(KEY_PANEL_OPEN, false)
 
            // 恢复 UI 表现
            // 注意：EditText 的文本会被系统自动恢复（因为它有 android:id）
            // 但我们可能需要根据 searchQuery 做额外逻辑
            if (isFilterPanelOpen) {
                showFilterPanel()
            }
        }
 
        // 无论是首次创建还是恢复，都需要观察 ViewModel 的数据
        // ViewModel 在配置变更时不会丢失，所以搜索结果还在
        // 但进程死亡后 ViewModel 也会丢失，此时 ViewModel 内部
        // 可以通过 SavedStateHandle 恢复关键参数并重新请求数据
        viewModel.searchResults.observe(this) { results ->
            // 更新搜索结果列表
            updateResultList(results)
        }
    }
 
    override fun onSaveInstanceState(outState: Bundle) {
        // 先让系统保存 View 树状态
        super.onSaveInstanceState(outState)
 
        // 保存自定义 UI 状态
        outState.putString(KEY_QUERY, searchQuery)
        outState.putInt(KEY_FILTER, filterType)
        outState.putBoolean(KEY_PANEL_OPEN, isFilterPanelOpen)
 
        // ❌ 不要这样做：
        // outState.putParcelableArrayList(KEY_RESULTS, searchResults)
        // 搜索结果可能很大，应该由 ViewModel/Repository 管理
        // ViewModel 可以通过 SavedStateHandle 保存搜索参数
        // 恢复时重新请求数据即可
    }
 
    companion object {
        private const val KEY_QUERY = "key_search_query"
        private const val KEY_FILTER = "key_filter_type"
        private const val KEY_PANEL_OPEN = "key_filter_panel_open"
        private const val FILTER_ALL = 0
    }
 
    // ... 省略 showFilterPanel(), updateResultList() 等方法
}

// 使用 SavedStateHandle 的 ViewModel
// SavedStateHandle 由 ViewModelProvider 自动注入
class SearchViewModel(
    // savedStateHandle 自动参与 Activity 的状态保存/恢复
    private val savedStateHandle: SavedStateHandle
) : ViewModel() {
 
    // 使用 SavedStateHandle 存储搜索关键词
    // getLiveData() 返回一个与 SavedStateHandle 双向绑定的 LiveData
    // 当 LiveData 的值变化时，SavedStateHandle 自动更新
    // 当进程恢复时，SavedStateHandle 自动恢复值到 LiveData
    val searchQuery: MutableLiveData<String> =
        savedStateHandle.getLiveData("query", "")
 
    // 也可以使用 StateFlow（Kotlin Coroutines 风格）
    // getStateFlow() 返回一个与 SavedStateHandle 绑定的 StateFlow
    val currentPage: StateFlow<Int> =
        savedStateHandle.getStateFlow("page", 0)
 
    // 搜索结果不需要保存到 SavedStateHandle
    // 因为它可以根据 searchQuery 和 currentPage 重新请求
    private val _searchResults = MutableLiveData<List<SearchResult>>()
    val searchResults: LiveData<List<SearchResult>> = _searchResults
 
    // 执行搜索
    fun search(query: String) {
        // 更新 SavedStateHandle 中的值
        // 这个值会在进程死亡时自动保存
        savedStateHandle["query"] = query
        savedStateHandle["page"] = 0
 
        // 发起网络请求获取搜索结果
        viewModelScope.launch {
            val results = repository.search(query, page = 0)
            _searchResults.value = results
        }
    }
 
    // 进程恢复后，Activity 可以调用此方法重新加载数据
    // 因为 searchQuery 和 currentPage 已经从 SavedStateHandle 恢复
    fun restoreSearch() {
        val query = savedStateHandle.get<String>("query") ?: return
        val page = savedStateHandle.get<Int>("page") ?: 0
        viewModelScope.launch {
            val results = repository.search(query, page)
            _searchResults.value = results
        }
    }
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
 
    // ✅ 正确做法：只在首次创建时添加 Fragment
    if (savedInstanceState == null) {
        // 首次创建，手动添加 Fragment
        supportFragmentManager.beginTransaction()
            .add(R.id.container, HomeFragment(), "home")
            .commit()
    }
    // 如果 savedInstanceState != null，Fragment 已经被系统自动恢复
    // 不需要再手动添加
}

// ❌ 危险的做法：依赖静态变量存储关键状态
object UserSession {
    // 进程死亡后，这个变量会变回 null
    // 但 Activity 可能从 savedInstanceState 恢复
    // 此时 Activity 以为用户已登录，但 currentUser 是 null
    var currentUser: User? = null
}
 
// ✅ 安全的做法：从持久化存储中恢复
object UserSession {
    // 每次访问都从 DataStore/SharedPreferences 中读取
    // 或者在 Application.onCreate() 中从持久化存储初始化
    suspend fun getCurrentUser(context: Context): User? {
        // 从 DataStore 读取用户信息
        return context.userDataStore.data.first().toUser()
    }
}

// ❌ 危险：列表数据可能非常大
override fun onSaveInstanceState(outState: Bundle) {
    super.onSaveInstanceState(outState)
    // 如果 articleList 有几百条数据，每条包含标题、摘要、图片 URL
    // 序列化后可能超过 1MB，导致 TransactionTooLargeException
    outState.putParcelableArrayList("articles", ArrayList(articleList))
}
 
// ✅ 正确：只保存恢复所需的最小信息
override fun onSaveInstanceState(outState: Bundle) {
    super.onSaveInstanceState(outState)
    // 只保存当前页码和筛选条件
    // 恢复时根据这些参数重新请求数据
    outState.putInt("page", currentPage)
    outState.putString("category", selectedCategory)
}

// 一个健壮的 Activity 状态管理模板
class RobustActivity : AppCompatActivity() {
 
    // 1. 使用 ViewModel 管理业务数据（扛配置变更）
    private val viewModel: MyViewModel by viewModels()
 
    // 2. 轻量 UI 状态用成员变量 + onSaveInstanceState 保存
    private var uiState: Int = 0
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_robust)
 
        // 3. 区分首次创建和恢复
        if (savedInstanceState == null) {
            // 首次创建：初始化 Fragment、读取 Intent 参数
            initFragments()
            parseIntentParams()
        } else {
            // 恢复：从 Bundle 恢复轻量状态
            uiState = savedInstanceState.getInt("ui_state", 0)
            // Fragment 由系统自动恢复，不要重复添加
        }
 
        // 4. 观察 ViewModel 数据（无论首次还是恢复都需要）
        observeViewModel()
    }
 
    override fun onSaveInstanceState(outState: Bundle) {
        // 5. 永远先调用 super
        super.onSaveInstanceState(outState)
        // 6. 只保存轻量级 UI 状态标识
        outState.putInt("ui_state", uiState)
    }
 
    // 7. 在 onStop 中保存需要持久化的用户数据
    override fun onStop() {
        super.onStop()
        // 将草稿保存到数据库/DataStore
        // 这样即使进程死亡，用户数据也不会丢失
        viewModel.saveDraft()
    }
 
    // ... 省略其他方法
}

class ArticleActivity : AppCompatActivity() {
 
    // ViewModel 在配置变更时不会被销毁，数据得以保留
    private val viewModel: ArticleViewModel by viewModels()
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_article)
 
        // 如果 savedInstanceState 不为 null，说明是重建而非首次创建
        if (savedInstanceState != null) {
            // 恢复轻量级 UI 状态，比如用户正在编辑的草稿文本
            val draftText = savedInstanceState.getString("key_draft", "")
            // 将草稿文本回填到 EditText
            findViewById<EditText>(R.id.editDraft).setText(draftText)
        }
 
        // ViewModel 中的 LiveData/StateFlow 数据在旋转后依然存在
        // 只需重新 observe 即可，无需重新请求
        viewModel.articleList.observe(this) { articles ->
            // 更新 RecyclerView 的数据源
            adapter.submitList(articles)
        }
    }
 
    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        // 保存用户正在编辑但尚未提交的草稿内容
        val currentDraft = findViewById<EditText>(R.id.editDraft).text.toString()
        // 写入 Bundle，key 自定义，value 必须是可序列化的轻量数据
        outState.putString("key_draft", currentDraft)
    }
}

<!-- AndroidManifest.xml 中声明拦截方向和屏幕尺寸变化 -->
<activity
    android:name=".VideoPlayerActivity"
    android:configChanges="orientation|screenSize|screenLayout|smallestScreenSize" />

class VideoPlayerActivity : AppCompatActivity() {
 
    override fun onConfigurationChanged(newConfig: Configuration) {
        // 必须调用 super，否则会抛出 SuperNotCalledException
        super.onConfigurationChanged(newConfig)
 
        // 根据新的方向调整 UI 布局
        when (newConfig.orientation) {
            // 横屏时隐藏标题栏，让播放器全屏
            Configuration.ORIENTATION_LANDSCAPE -> {
                supportActionBar?.hide()
                enterFullScreenMode()
            }
            // 竖屏时恢复标题栏，退出全屏
            Configuration.ORIENTATION_PORTRAIT -> {
                supportActionBar?.show()
                exitFullScreenMode()
            }
        }
    }
}

class NewsActivity : AppCompatActivity() {
 
    // 用于追踪 Activity 是否处于前台
    private var isInForeground = false
 
    override fun onStart() {
        super.onStart()
        // Activity 变为可见，注册需要在可见期间监听的广播
        registerNetworkCallback()
        isInForeground = true
    }
 
    override fun onResume() {
        super.onResume()
        // 获得焦点，恢复动画、传感器监听等交互相关资源
        resumeAutoScrollBanner()
    }
 
    override fun onPause() {
        super.onPause()
        // 失去焦点，暂停动画以节省 CPU
        pauseAutoScrollBanner()
    }
 
    override fun onStop() {
        super.onStop()
        // 完全不可见，注销广播以避免后台无意义的回调
        unregisterNetworkCallback()
        isInForeground = false
    }
 
    override fun onRestart() {
        super.onRestart()
        // 从后台回到前台，检查是否需要刷新数据
        // 比如用户离开了 5 分钟，新闻列表可能已经过时
        checkAndRefreshIfNeeded()
    }
 
    private fun checkAndRefreshIfNeeded() {
        // 计算距离上次刷新的时间间隔
        val elapsed = System.currentTimeMillis() - lastRefreshTimestamp
        // 如果超过 5 分钟，自动触发一次刷新
        if (elapsed > 5 * 60 * 1000L) {
            viewModel.refreshNewsList()
        }
    }
}

class AlarmActivity : AppCompatActivity() {
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
 
        // 允许 Activity 显示在锁屏之上（API 27+）
        setShowWhenLocked(true)
        // 允许 Activity 解锁 Keyguard（配合使用）
        setTurnScreenOn(true)
 
        // 对于 API 26 及以下，需要使用 Window Flag（已废弃但仍有效）
        // window.addFlags(
        //     WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
        //     WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
        // )
 
        setContentView(R.layout.activity_alarm)
    }
}

<!-- res/values/themes.xml -->
<style name="Theme.Transparent" parent="Theme.MaterialComponents.DayNight.Dialog">
    <!-- 窗口背景设为透明 -->
    <item name="android:windowBackground">@android:color/transparent</item>
    <!-- 窗口本身是透明的 -->
    <item name="android:windowIsTranslucent">true</item>
    <!-- 不使用默认的窗口标题 -->
    <item name="android:windowNoTitle">true</item>
    <!-- 允许窗口浮动（不占满全屏） -->
    <item name="android:windowIsFloating">true</item>
</style>

<!-- AndroidManifest.xml 中为 Activity 指定透明主题 -->
<activity
    android:name=".ConfirmDialogActivity"
    android:theme="@style/Theme.Transparent" />

// 情况一：弹出普通 Dialog —— 不影响 Activity 生命周期
// Activity 不会收到 onPause()
AlertDialog.Builder(this)
    .setTitle("确认")                    // 设置对话框标题
    .setMessage("确定要删除吗？")          // 设置对话框内容
    .setPositiveButton("确定") { _, _ ->  // 确定按钮的点击回调
        deleteItem()                     // 执行删除操作
    }
    .setNegativeButton("取消", null)      // 取消按钮，无额外操作
    .show()                              // 显示对话框
 
// 情况二：启动 Dialog 主题的 Activity —— 底层 Activity 会收到 onPause()
val intent = Intent(this, ConfirmDialogActivity::class.java)
startActivity(intent)                    // 启动新的 Activity
// 此时当前 Activity 的 onPause() 会被调用

// ❌ 错误示范：在 onPause 中执行耗时的同步写入
override fun onPause() {
    super.onPause()
    // commit() 是同步操作，会阻塞主线程
    // 这会延迟下一个 Activity 的显示
    getSharedPreferences("prefs", MODE_PRIVATE)
        .edit()
        .putString("draft", longDraftText)  // 大量文本数据
        .commit()                            // 同步写入，阻塞!
}
 
// ✅ 正确做法：使用 apply() 异步写入，或移到 onStop()
override fun onPause() {
    super.onPause()
    // apply() 是异步操作，立即返回，不阻塞主线程
    getSharedPreferences("prefs", MODE_PRIVATE)
        .edit()
        .putString("draft", longDraftText)  // 同样的数据
        .apply()                             // 异步写入，不阻塞!
}

// Activity.java 源码中的关键片段（简化）
// mFinished 是 Activity 内部维护的布尔标志
private boolean mFinished;
 
// 当调用 finish() 时，mFinished 被置为 true
public void finish() {
    // ... 省略其他逻辑
    mFinished = true; // 标记：这个 Activity 是被主动结束的
    // 通知 ActivityTaskManager 完成销毁流程
}
 
// isFinishing() 只是简单地返回这个标志
public boolean isFinishing() {
    return mFinished; // 返回当前 Activity 是否处于"正在结束"状态
}

override fun onDestroy() {
    super.onDestroy()
 
    if (isFinishing) {
        // ---- 真正结束：执行不可逆的清理 ----
        // 清除本地草稿缓存，用户明确要离开了
        draftRepository.deleteDraft(articleId)
        // 关闭独占的数据库连接
        exclusiveDbConnection.close()
        // 通知服务端用户已离开编辑页面
        analyticsTracker.trackEvent("editor_closed_permanently")
    } else {
        // ---- 配置变更 / 系统回收：保守处理 ----
        // 不要删除草稿！用户马上就会回来
        // 不要关闭共享资源，新实例还需要用
        // 可以做一些轻量级的引用解除
        analyticsTracker.trackEvent("editor_recreating")
    }
 
    // ---- 无论哪种情况都要做的清理 ----
    // 取消协程作用域，防止泄漏（新实例会创建自己的作用域）
    coroutineScope.cancel()
    // 移除回调引用，避免持有旧 Activity 实例
    viewModel.callback = null
}

override fun onPause() {
    super.onPause()
    if (isFinishing) {
        // 用户主动离开，可以弹出"是否保存"的确认
        // （实际上这个逻辑更适合放在 onBackPressed 中）
    } else {
        // 只是被遮挡或进入后台，自动保存草稿
        saveDraftSilently()
    }
}

override fun onDestroy() {
    super.onDestroy()
 
    when {
        isFinishing -> {
            // 情况 1：用户主动结束，执行完整清理
            performFullCleanup()
        }
        isChangingConfigurations -> {
            // 情况 2：配置变更（如旋转屏幕），新实例即将创建
            // 可以传递一些昂贵的非 Parcelable 对象给新实例
            // （现代做法是通过 ViewModel 持有这些对象）
            retainExpensiveResources()
        }
        else -> {
            // 情况 3：系统内存回收，Activity 可能稍后被重建
            // 状态已通过 onSaveInstanceState 保存
            releaseMemoryHeavyResources()
        }
    }
}

class EditorActivity : AppCompatActivity() {
 
    // ---- 各类需要管理的资源 ----
    private lateinit var sensorManager: SensorManager          // 系统服务
    private lateinit var locationCallback: LocationCallback     // 位置回调
    private var mediaPlayer: MediaPlayer? = null                // 媒体播放器
    private var webSocketConnection: WebSocket? = null          // 网络长连接
    private var broadcastReceiver: BroadcastReceiver? = null    // 广播接收器
    private var serviceConnection: ServiceConnection? = null    // Service 绑定
    private var animatorSet: AnimatorSet? = null                // 属性动画
 
    override fun onDestroy() {
        super.onDestroy()
 
        // 1. 停止并释放媒体资源
        // MediaPlayer 持有底层 native 资源（音频解码器、AudioTrack）
        // 如果不显式 release()，native 内存不会被 Java GC 回收
        mediaPlayer?.apply {
            stop()       // 先停止播放
            release()    // 释放底层 native 资源
        }
        mediaPlayer = null  // 解除 Java 层引用
 
        // 2. 关闭网络长连接
        // WebSocket 连接如果不关闭，服务端会一直维持会话
        // 同时客户端的读写线程也不会停止
        webSocketConnection?.close(
            code = 1000,                    // 正常关闭的状态码
            reason = "Activity destroyed"   // 关闭原因
        )
        webSocketConnection = null
 
        // 3. 取消属性动画
        // 运行中的 Animator 会通过 Choreographer 持有对 View 的引用
        // View 又持有对 Activity 的引用，形成泄漏链
        animatorSet?.apply {
            cancel()            // 立即取消动画
            removeAllListeners() // 移除所有监听器，断开回调引用
        }
        animatorSet = null
 
        // 4. 反注册广播接收器
        // 通过 registerReceiver() 注册的接收器如果不反注册
        // 系统会在 Activity 销毁后打印泄漏警告日志
        broadcastReceiver?.let {
            unregisterReceiver(it)  // 从系统中移除注册
        }
        broadcastReceiver = null
 
        // 5. 解绑 Service
        // bindService() 建立的连接如果不 unbind
        // 会导致 ServiceConnectionLeaked 异常
        serviceConnection?.let {
            unbindService(it)   // 解除与 Service 的绑定
        }
        serviceConnection = null
 
        // 6. 注销传感器监听
        // 传感器监听器如果不注销，即使 Activity 销毁
        // SensorManager 仍会持续回调，浪费电量和 CPU
        sensorManager.unregisterListener(sensorEventListener)
 
        // 7. 移除位置更新回调
        // FusedLocationProviderClient 的回调同理
        fusedLocationClient.removeLocationUpdates(locationCallback)
    }
}

class WellManagedActivity : AppCompatActivity() {
 
    override fun onPause() {
        super.onPause()
        // ---- onPause：释放"前台独占"资源 ----
        // 相机预览：其他 App 可能需要使用相机
        cameraSource.stop()
        // 关键数据持久化：onPause 之后进程可能随时被杀
        saveUserProgress()
    }
 
    override fun onStop() {
        super.onStop()
        // ---- onStop：释放"用户不可见时不需要"的资源 ----
        // 停止动画：用户看不到了，没必要继续消耗 CPU/GPU
        lottieAnimationView.cancelAnimation()
        // 暂停视频播放
        videoPlayer.pause()
        // 反注册需要 UI 更新的广播接收器
        localBroadcastManager.unregisterReceiver(uiUpdateReceiver)
    }
 
    override fun onDestroy() {
        super.onDestroy()
        // ---- onDestroy：释放"与 Activity 实例绑定"的资源 ----
        // 这些资源在 Activity 重建时需要重新创建
        mediaPlayer?.release()      // native 资源
        webSocket?.close(1000, "")  // 网络连接
        coroutineScope.cancel()     // 协程作用域
        // 清除对 Activity 的强引用
        callback = null
    }
}

/**
 * 一个能感知生命周期的 WebSocket 管理器
 * 实现 DefaultLifecycleObserver 接口，自动响应宿主的生命周期事件
 */
class LifecycleAwareWebSocket(
    private val url: String,           // WebSocket 服务端地址
    private val okHttpClient: OkHttpClient // 共享的 OkHttp 客户端
) : DefaultLifecycleObserver {
 
    private var webSocket: WebSocket? = null  // 当前 WebSocket 连接实例
 
    // 当宿主（Activity/Fragment）进入 STARTED 状态时自动连接
    override fun onStart(owner: LifecycleOwner) {
        // 创建 WebSocket 连接请求
        val request = Request.Builder().url(url).build()
        // 建立连接，传入消息监听器
        webSocket = okHttpClient.newWebSocket(request, messageListener)
    }
 
    // 当宿主进入 STOPPED 状态时自动断开
    override fun onStop(owner: LifecycleOwner) {
        // 正常关闭 WebSocket 连接
        webSocket?.close(1000, "Lifecycle stopped")
        webSocket = null
    }
 
    // 当宿主被销毁时，自动从生命周期观察者列表中移除自己
    override fun onDestroy(owner: LifecycleOwner) {
        // 移除观察者，彻底断开与宿主的关联
        owner.lifecycle.removeObserver(this)
    }
}
 
// ---- 在 Activity 中使用 ----
class ChatActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
 
        // 创建 WebSocket 管理器并注册为生命周期观察者
        val ws = LifecycleAwareWebSocket("wss://chat.example.com", okHttpClient)
        // 一行代码完成注册，无需在 onDestroy 中手动清理
        lifecycle.addObserver(ws)
        // 从此 ws 会自动跟随 Activity 的生命周期连接/断开
    }
    // 注意：onDestroy() 中不需要任何关于 WebSocket 的清理代码
}

// ❌ 错误示范：匿名 Runnable 隐式持有 Activity 引用
class LeakyActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
 
        // 这个匿名 Runnable 是 LeakyActivity 的内部类
        // 它隐式持有 LeakyActivity.this 的引用
        val delayedTask = Runnable {
            // 10 秒后更新 UI
            textView.text = "Updated"
        }
        // 将 Runnable 投递到主线程 Handler 的消息队列
        // 如果 Activity 在 10 秒内被销毁
        // 这个 Runnable 仍然在消息队列中等待执行
        // 它持有的 Activity 引用阻止了 GC 回收
        Handler(Looper.getMainLooper()).postDelayed(delayedTask, 10_000)
    }
}

// ✅ 正确做法：在 onDestroy 中移除回调，或使用 lifecycleScope
class SafeActivity : AppCompatActivity() {
 
    // 保存 Handler 引用以便后续移除回调
    private val handler = Handler(Looper.getMainLooper())
    // 保存 Runnable 引用以便精确移除
    private val delayedTask = Runnable {
        textView.text = "Updated"
    }
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        handler.postDelayed(delayedTask, 10_000)
    }
 
    override fun onDestroy() {
        super.onDestroy()
        // 移除消息队列中所有与 delayedTask 关联的消息
        // 断开引用链，允许 Activity 被 GC 回收
        handler.removeCallbacks(delayedTask)
    }
}
 
// ✅ 更现代的做法：使用 lifecycleScope，自动跟随生命周期取消
class ModernActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // lifecycleScope 在 onDestroy 时自动取消所有协程
        // 无需手动清理，不会泄漏
        lifecycleScope.launch {
            delay(10_000)           // 挂起 10 秒，不阻塞主线程
            textView.text = "Updated" // Activity 若已销毁，协程已被取消，此行不执行
        }
    }
}

// ❌ 典型的单例泄漏
object EventBus {
    // listeners 列表的生命周期 = 进程生命周期
    private val listeners = mutableListOf<OnEventListener>()
 
    fun register(listener: OnEventListener) {
        listeners.add(listener) // Activity 被加入列表
    }
 
    fun unregister(listener: OnEventListener) {
        listeners.remove(listener)
    }
}
 
class LeakyActivity : AppCompatActivity(), OnEventListener {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        EventBus.register(this) // 将 Activity 自身注册为监听器
        // 如果忘记在 onDestroy 中调用 EventBus.unregister(this)
        // 单例 EventBus 会一直持有这个 Activity 的强引用
    }
}

// ❌ 将 Activity Context 传给单例
class ImageCache private constructor(context: Context) {
    // 这个 context 如果是 Activity，就会导致泄漏
    // 因为 ImageCache 是单例，生命周期 = 进程生命周期
    private val ctx = context  // 强引用！
 
    companion object {
        @Volatile
        private var instance: ImageCache? = null
 
        fun getInstance(context: Context): ImageCache {
            return instance ?: synchronized(this) {
                instance ?: ImageCache(
                    // ✅ 修复：始终使用 Application Context
                    // applicationContext 的生命周期 = 进程生命周期
                    // 不会导致任何 Activity 泄漏
                    context.applicationContext
                ).also { instance = it }
            }
        }
    }
}

┌─────────────────────────────────────────────────────────────────┐
│                     GC Root (GC 根)                             │
│                          │                                      │
│                    ┌─────▼──────┐                               │
│                    │  Singleton  │  ← 生命周期 = 进程            │
│                    │  (单例对象)  │                               │
│                    └─────┬──────┘                               │
│                          │ 强引用 (listeners / context)         │
│                    ┌─────▼──────────┐                           │
│                    │   Activity ⚠️   │  ← 已调用 onDestroy      │
│                    │  (应该被回收)    │     但无法被 GC 回收      │
│                    └─────┬──────────┘                           │
│                          │ 持有引用                              │
│              ┌───────────┼───────────┐                          │
│        ┌─────▼────┐ ┌────▼────┐ ┌────▼─────┐                   │
│        │ DecorView│ │ ViewTree│ │ Bitmaps  │  ← 几十 MB 内存   │
│        │ (根视图)  │ │ (视图树) │ │ (位图资源)│     全部无法释放   │
│        └──────────┘ └─────────┘ └──────────┘                   │
└─────────────────────────────────────────────────────────────────┘

dependencies {
    // 仅在 debug 构建中包含 LeakCanary
    // debugImplementation 确保 release 包中不会包含任何 LeakCanary 代码
    debugImplementation("com.squareup.leakcanary:leakcanary-android:2.14")
}

```text
┌──────────────────────────────────────────────────────────────┐
│  LeakCanary Leak Trace 示例                                  │
│                                                              │
│  ┌─ GC Root: Thread (main)                                  │
│  │                                                           │
│  ├─ android.os.HandlerThread                                │
│  │    ↓ instance field: mHandler                            │
│  │                                                           │
│  ├─ com.example.app.DataManager (Singleton)                 │
│  │    ↓ instance field: mCallback                           │
│  │    ~ 泄漏原因在这里：单例持有了 Activity 的回调引用 ~      │
│  │                                                           │
│  ╰→ com.example.app.DetailActivity (DESTROYED)              │
│       ↑ 这就是被泄漏的 Activity 实例                         │
│       ↑ 状态已经是 DESTROYED，但无法被 GC 回收               │
└──────────────────────────────────────────────────────────────┘

/**
 * 手动泄漏检测辅助工具
 * 在 debug 构建中使用，配合 Memory Profiler 定位泄漏
 */
object LeakDetectionHelper {
 
    // 使用 WeakReference 追踪 Activity 实例
    // 如果 Activity 被正常回收，WeakReference.get() 会返回 null
    private val trackedActivities = mutableListOf<WeakReference<Activity>>()
 
    /**
     * 在 Activity 的 onDestroy 中调用此方法
     * 将 Activity 加入追踪列表
     */
    fun trackActivity(activity: Activity) {
        // 用 WeakReference 包装，不会阻止 GC 回收
        trackedActivities.add(WeakReference(activity))
    }
 
    /**
     * 在合适的时机调用（比如点击 debug 菜单）
     * 检查是否有已销毁但未被回收的 Activity
     */
    fun checkLeaks(): List<String> {
        // 先主动建议 GC 运行（注意：这只是建议，不保证立即执行）
        Runtime.getRuntime().gc()
 
        val leakedActivities = mutableListOf<String>()
 
        // 使用迭代器遍历，方便在遍历过程中安全移除元素
        val iterator = trackedActivities.iterator()
        while (iterator.hasNext()) {
            val ref = iterator.next()
            val activity = ref.get()
 
            if (activity == null) {
                // WeakReference.get() 返回 null
                // 说明 Activity 已被 GC 正常回收，从列表中移除
                iterator.remove()
            } else if (activity.isDestroyed) {
                // Activity 仍然存在于内存中，但状态已经是 DESTROYED
                // 这就是泄漏！记录类名用于排查
                leakedActivities.add(activity::class.java.simpleName)
            }
            // 如果 activity 不为 null 且未 destroyed，说明它还在正常运行中
        }
 
        return leakedActivities
    }
 
    /**
     * 打印泄漏报告到 Logcat
     * 建议在 Application 中定期调用，或绑定到 debug 按钮
     */
    fun reportLeaks() {
        val leaks = checkLeaks()
        if (leaks.isNotEmpty()) {
            // 使用 Log.e 输出，方便在 Logcat 中用红色高亮过滤
            Log.e("LeakDetection",
                "⚠️ 检测到 ${leaks.size} 个泄漏的 Activity: ${leaks.joinToString()}")
        } else {
            Log.d("LeakDetection", "✅ 未检测到 Activity 泄漏")
        }
    }
}

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
 
        // 仅在 debug 构建中启用 StrictMode
        if (BuildConfig.DEBUG) {
            // ---- 线程策略：检测主线程上的不当操作 ----
            StrictMode.setThreadPolicy(
                StrictMode.ThreadPolicy.Builder()
                    .detectDiskReads()      // 检测主线程磁盘读取
                    .detectDiskWrites()     // 检测主线程磁盘写入
                    .detectNetwork()        // 检测主线程网络访问
                    .detectCustomSlowCalls() // 检测自定义的慢操作标记
                    .penaltyLog()           // 违规时输出到 Logcat
                    .penaltyFlashScreen()   // 违规时屏幕闪烁红色边框（非常直观）
                    .build()
            )
 
            // ---- VM 策略：检测虚拟机级别的资源泄漏 ----
            StrictMode.setVmPolicy(
                StrictMode.VmPolicy.Builder()
                    .detectLeakedSqlLiteObjects()    // 检测未关闭的 SQLite 游标
                    .detectLeakedClosableObjects()   // 检测未关闭的 Closeable 对象
                    .detectActivityLeaks()           // 检测 Activity 泄漏
                    .detectLeakedRegistrationObjects() // 检测未反注册的广播接收器等
                    .penaltyLog()                    // 违规时输出到 Logcat
                    .build()
            )
        }
    }
}

// 在 Activity 的 onCreate 中，setContentView 之前调用
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        // 必须在 super.onCreate 之前或之后、setContentView 之前调用
        // enableEdgeToEdge() 会自动处理以下事项：
        // 1. 调用 WindowCompat.setDecorFitsSystemWindows(window, false)
        //    告诉系统"我的内容要自己处理系统栏区域，不需要你帮我留白"
        // 2. 将状态栏背景设为透明
        // 3. 将导航栏背景设为透明（或在旧版三键导航上设为半透明遮罩）
        // 4. 根据系统版本自动选择最佳的兼容策略
        enableEdgeToEdge()
 
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
 
        // 核心开关：告诉 DecorView 不要自动为系统栏留出 padding
        // 这一行是 Edge-to-Edge 的本质——关闭系统的自动 insets 消费
        WindowCompat.setDecorFitsSystemWindows(window, false)
 
        // 将状态栏和导航栏背景设为透明
        // 注意：在 Android 10 以下，导航栏透明可能导致三键导航按钮看不清
        // 所以实际项目中通常需要根据 SDK 版本做条件判断
        window.statusBarColor = Color.TRANSPARENT
        window.navigationBarColor = Color.TRANSPARENT
    }
}

// 典型场景：为根布局设置 padding，避免内容被系统栏遮挡
ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main_container)) { view, windowInsets ->
    // 从 windowInsets 中提取 systemBars 类型的边距值
    // 这会返回一个 Insets 对象，包含 top/bottom/left/right 四个值
    val systemBarsInsets = windowInsets.getInsets(WindowInsetsCompat.Type.systemBars())
 
    // 将系统栏的边距值设置为 View 的 padding
    // 这样 View 的内容就不会绘制到系统栏区域下方
    // left/right 在横屏或有侧边导航栏的设备上会有值
    view.setPadding(
        systemBarsInsets.left,   // 左侧系统栏（横屏时可能出现）
        systemBarsInsets.top,    // 状态栏高度
        systemBarsInsets.right,  // 右侧系统栏（横屏时可能出现）
        systemBarsInsets.bottom  // 导航栏高度
    )
 
    // 返回 windowInsets 表示"我没有消费这些 insets"
    // 这样子 View 也能收到同样的 insets 信息并做出自己的调整
    // 如果返回 WindowInsetsCompat.CONSUMED，子 View 将不再收到 insets
    windowInsets
}

class EdgeToEdgeActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        // 启用 Edge-to-Edge
        enableEdgeToEdge()
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_edge_to_edge)
 
        // 获取各个需要处理 insets 的 View
        val toolbar = findViewById<MaterialToolbar>(R.id.toolbar)
        val recyclerView = findViewById<RecyclerView>(R.id.recycler_view)
        val fab = findViewById<FloatingActionButton>(R.id.fab)
 
        // 处理 Toolbar：让背景延伸到状态栏，但内容不被遮挡
        ViewCompat.setOnApplyWindowInsetsListener(toolbar) { view, insets ->
            // 只取状态栏的 top 值
            val statusBarInsets = insets.getInsets(WindowInsetsCompat.Type.statusBars())
            // 增加 Toolbar 的 top padding，使其内容（标题、菜单按钮）下移
            // 但 Toolbar 的背景色会自然填充到状态栏区域
            view.updatePadding(top = statusBarInsets.top)
            // 不消费 insets，让其他 View 也能处理
            insets
        }
 
        // 处理 RecyclerView：底部留出导航栏空间，但允许内容滚动到导航栏下方
        ViewCompat.setOnApplyWindowInsetsListener(recyclerView) { view, insets ->
            val navBarInsets = insets.getInsets(WindowInsetsCompat.Type.navigationBars())
            // 设置底部 padding 等于导航栏高度
            view.updatePadding(bottom = navBarInsets.bottom)
            // clipToPadding = false 是关键：
            // 它允许子项在滚动时绘制到 padding 区域内
            // 但当滚动到底部时，最后一项会停在 padding 边界上方
            view.clipToPadding = false
            insets
        }
 
        // 处理 FAB：通过 margin 将其上移，避免被导航栏遮挡
        ViewCompat.setOnApplyWindowInsetsListener(fab) { view, insets ->
            val navBarInsets = insets.getInsets(WindowInsetsCompat.Type.navigationBars())
            // 使用 margin 而非 padding，因为 FAB 是浮动元素
            val params = view.layoutParams as ViewGroup.MarginLayoutParams
            // 在原有 margin 基础上加上导航栏高度
            params.bottomMargin = navBarInsets.bottom + 16.dpToPx(view.context)
            view.layoutParams = params
            insets
        }
    }
}

// 示例：自定义 ViewGroup 消费掉 statusBars 的 insets
// 这样其子 View 就不需要再处理状态栏了
ViewCompat.setOnApplyWindowInsetsListener(customHeader) { view, insets ->
    val statusBars = insets.getInsets(WindowInsetsCompat.Type.statusBars())
    // 自己处理状态栏 padding
    view.updatePadding(top = statusBars.top)
 
    // 构造新的 insets，将 statusBars 部分清零
    // 这样子 View 收到的 insets 中 statusBars.top 将为 0
    WindowInsetsCompat.Builder(insets)
        .setInsets(WindowInsetsCompat.Type.statusBars(), Insets.NONE)
        .build()
}

class ImmersiveActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        enableEdgeToEdge()
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_immersive)
 
        // 获取兼容版本的 WindowInsetsController
        // 使用 WindowCompat 而非 window.insetsController，以确保向下兼容
        val insetsController = WindowCompat.getInsetsController(window, window.decorView)
 
        // === 控制系统栏图标颜色 ===
        // 当状态栏背景为浅色时，需要深色图标（时间、电量等）
        // isAppearanceLightStatusBars = true → 深色图标（适合浅色背景）
        // isAppearanceLightStatusBars = false → 浅色图标（适合深色背景）
        insetsController.isAppearanceLightStatusBars = true
 
        // 同理，控制导航栏按钮/手势指示器的颜色
        insetsController.isAppearanceLightNavigationBars = true
    }
 
    // 进入全屏沉浸模式（例如视频播放、游戏、图片查看）
    private fun enterImmersiveMode() {
        val insetsController = WindowCompat.getInsetsController(window, window.decorView)
 
        // 隐藏状态栏和导航栏
        // Type.systemBars() = statusBars() | navigationBars()
        insetsController.hide(WindowInsetsCompat.Type.systemBars())
 
        // 设置隐藏后的行为模式
        // BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE：
        //   用户从屏幕边缘滑动时，系统栏会短暂显示（半透明覆盖在内容上），
        //   几秒后自动隐藏。这是最常用的沉浸模式。
        // BEHAVIOR_DEFAULT：
        //   用户从屏幕边缘滑动时，系统栏会永久显示，
        //   需要再次调用 hide() 才能隐藏。
        insetsController.systemBarsBehavior =
            WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
    }
 
    // 退出全屏沉浸模式
    private fun exitImmersiveMode() {
        val insetsController = WindowCompat.getInsetsController(window, window.decorView)
        // 显示系统栏
        insetsController.show(WindowInsetsCompat.Type.systemBars())
    }
}

// 显示软键盘
// 前提：目标 EditText 必须已经获得焦点
insetsController.show(WindowInsetsCompat.Type.ime())
 
// 隐藏软键盘
insetsController.hide(WindowInsetsCompat.Type.ime())

@Composable
fun EdgeToEdgeScreen() {
    Scaffold(
        topBar = {
            TopAppBar(
                title = { Text("Edge-to-Edge Demo") },
                // TopAppBar 内部已经自动处理了 statusBars 的 insets
                // 无需手动设置 padding
            )
        },
        bottomBar = {
            NavigationBar {
                // NavigationBar 内部已经自动处理了 navigationBars 的 insets
            }
        }
    ) { innerPadding ->
        // Scaffold 会通过 innerPadding 参数传递已经计算好的安全区域 padding
        // 这个 padding 已经包含了 topBar 和 bottomBar 的高度以及系统栏的 insets
        LazyColumn(
            // 将 innerPadding 应用到 LazyColumn 的 contentPadding
            // 这样列表内容不会被 topBar/bottomBar/系统栏遮挡
            contentPadding = innerPadding,
            modifier = Modifier.fillMaxSize()
        ) {
            items(100) { index ->
                Text(
                    text = "Item #$index",
                    modifier = Modifier
                        .fillMaxWidth()
                        .padding(16.dp)
                )
            }
        }
    }
}