移动应用深度场景自动化：统一状态机与分层事件拦截设计实践

你是不是也遇到过这样的场景：深夜想沉浸式看个电影，结果刚躺下，手机就弹出一条工作消息，屏幕瞬间亮起，刺眼的光线瞬间破坏了酝酿已久的观影氛围。或者，精心挑选了一部电影，却发现手机音量忽大忽小，通知音效时不时打断剧情，体验感大打折扣。

这背后暴露的，是移动应用在“观影模式”这类深度场景下的设计缺失。很多开发者以为，一个简单的“勿扰模式”开关就能解决问题，但用户的实际体验却充满了“坑”：状态切换不及时、与其他功能冲突、退出后状态残留……这些细节的失控，直接导致了功能的“伪自动化”，用户需要手动干预的环节一个没少。

本文要解决的，正是这个看似简单、实则暗藏玄机的“观影模式自动化”问题。它不是一个简单的功能开关，而是一个涉及 状态管理、事件监听、系统资源协调 的综合性工程问题。我们将深入两个最关键的底层设计（ 统一状态机 与 分层事件拦截 ），并针对三个最常见的开发痛点（ 状态同步、冲突仲裁、优雅退出 ）提供可落地的解决方案。无论你是负责播放器SDK、还是开发带有音视频功能的应用，这篇文章都能帮你构建一个真正“无感”且可靠的深度场景模式。

1. 观影模式自动化：为什么简单的开关背后是复杂的工程？

在深入代码之前，我们必须先理解“观影模式自动化”的本质。它不是一个独立的功能，而是一个 场景感知与系统资源协调 的框架。用户的核心诉求是：进入观影场景后，系统能自动、静默地处理好一切干扰，并在退出后无痕恢复。这要求我们的设计必须回答几个关键问题：

1. 如何精准定义“观影”这个场景？ 是简单的全屏播放？还是包含了投屏、小窗播放？触发条件是什么？
2. 需要管理哪些系统状态？ 屏幕亮度、音量、勿扰模式、导航栏、手势、传感器（如旋转锁定）等，这些状态如何统一保存和恢复？
3. 如何应对系统和其他应用的事件干扰？ 来电、通知、低电量提醒、其他媒体播放，这些事件应该如何被优雅地处理或屏蔽？
4. 当多个状态管理需求冲突时，谁来仲裁？ 例如，用户手动调高了亮度，观影模式是否应该覆盖？还是应该暂时退出？

传统的“开关式”设计之所以坑多，是因为它通常只做了两件事：监听播放开始事件，然后调用一堆 setXXX() 方法；监听播放结束事件，再调用一堆 revertXXX() 方法。这种线性思维无法处理复杂的、并发的、可中断的真实世界事件流。

因此，一个健壮的观影模式自动化系统，必须建立在两个核心的底层设计之上： 统一状态机 和 分层事件拦截 。接下来，我们将逐一拆解。

2. 核心底层设计一：统一状态机（Unified State Machine）

状态混乱是万恶之源。想象一下，你的应用里有三个地方可以修改屏幕亮度：系统设置、手动拖动亮度条、观影模式。如果没有一个中心化的状态管理，很容易出现A改完被B覆盖，或者退出观影后无法恢复到“用户真正想要的亮度”。

2.1 状态机的设计思想

我们需要的不是一个简单的布尔值 isMovieMode ，而是一个能管理 多个关联状态 及其 快照 的机器。它的核心职责是：

• 状态定义 ：明确哪些状态属于“观影上下文”（如：屏幕亮度、媒体音量、系统铃声模式、自动旋转开关等）。
• 快照与恢复 ：在进入模式前，保存这些状态的当前值（快照）；在退出模式时，精准恢复到快照，而不是一个硬编码的默认值。
• 状态冲突仲裁 ：当观影模式试图修改一个状态，而该状态可能正被用户或其他模块修改时，有一套处理规则。

2.2 一个精简的状态机实现示例

以下是一个用 Kotlin 实现的、概念化的统一状态机核心类。在实际项目中，你可能需要根据平台（Android/iOS/Flutter/React Native）进行调整。

// 文件路径：core/scene/MovieModeStateManager.kt
import android.content.Context
import android.provider.Settings

/**
 * 观影模式状态管理器
 * 核心思想：统一管理所有与观影相关的系统/应用状态，并提供快照与恢复能力。
 */
class MovieModeStateManager(private val context: Context) {

    // 定义需要管理的状态枚举
    enum class SystemState {
        SCREEN_BRIGHTNESS, // 屏幕亮度（0-255）
        MEDIA_VOLUME,      // 媒体音量（0-100）
        RINGER_MODE,       // 铃声模式（正常、震动、静音）
        AUTO_ROTATE,       // 自动旋转开关
        NOTIFICATION_POLICY // 通知策略（勿扰）
    }

    // 状态快照存储
    private val stateSnapshot = mutableMapOf<SystemState, Any?>()

    // 当前是否处于观影模式
    private var isActive = false

    /**
     * 进入观影模式
     * 1. 保存当前状态快照
     * 2. 应用观影模式预设状态
     */
    fun enterMovieMode() {
        if (isActive) return

        // 步骤1：保存快照
        saveStateSnapshot()

        // 步骤2：应用预设状态（这里以Android为例）
        applyMovieModeStates()

        isActive = true
        // 可以在这里发送一个全局事件，通知其他模块模式已切换
        // EventBus.getDefault().post(MovieModeEvent.ENTERED)
    }

    /**
     * 退出观影模式
     * 1. 根据快照恢复所有状态
     * 2. 清理快照
     */
    fun exitMovieMode() {
        if (!isActive) return

        // 步骤1：恢复状态
        restoreStateFromSnapshot()

        // 步骤2：清理（可选，防止内存泄漏）
        stateSnapshot.clear()

        isActive = false
        // EventBus.getDefault().post(MovieModeEvent.EXITED)
    }

    /**
     * 保存状态快照
     * 注意：获取某些系统设置需要权限（如WRITE_SETTINGS）。
     * 实际项目中应做好权限检查和兼容性处理。
     */
    private fun saveStateSnapshot() {
        // 保存屏幕亮度（需适配不同Android版本）
        val brightness = Settings.System.getInt(
            context.contentResolver,
            Settings.System.SCREEN_BRIGHTNESS,
            255
        )
        stateSnapshot[SystemState.SCREEN_BRIGHTNESS] = brightness

        // 保存媒体音量（通过AudioManager）
        val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as android.media.AudioManager
        val mediaVolume = audioManager.getStreamVolume(android.media.AudioManager.STREAM_MUSIC)
        stateSnapshot[SystemState.MEDIA_VOLUME] = mediaVolume

        // 保存铃声模式
        val ringerMode = audioManager.ringerMode
        stateSnapshot[SystemState.RINGER_MODE] = ringerMode

        // 保存自动旋转设置
        val autoRotate = Settings.System.getInt(
            context.contentResolver,
            Settings.System.ACCELEROMETER_ROTATION,
            0
        )
        stateSnapshot[SystemState.AUTO_ROTATE] = autoRotate

        // 通知策略（勿扰模式）快照较为复杂，此处略去具体实现
        // stateSnapshot[SystemState.NOTIFICATION_POLICY] = saveCurrentNotificationPolicy()
    }

    /**
     * 应用观影模式预设状态
     */
    private fun applyMovieModeStates() {
        // 设置一个适合观影的亮度（例如，根据环境光传感器动态计算，这里用固定值演示）
        val targetBrightness = calculateTargetBrightness()
        Settings.System.putInt(
            context.contentResolver,
            Settings.System.SCREEN_BRIGHTNESS,
            targetBrightness
        )

        // 设置媒体音量到80%（避免突然最大声吓到用户）
        val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as android.media.AudioManager
        val maxVolume = audioManager.getStreamMaxVolume(android.media.AudioManager.STREAM_MUSIC)
        val targetVolume = (maxVolume * 0.8).toInt()
        audioManager.setStreamVolume(
            android.media.AudioManager.STREAM_MUSIC,
            targetVolume,
            0 // 无标志
        )

        // 将铃声模式设置为静音或震动
        audioManager.ringerMode = android.media.AudioManager.RINGER_MODE_VIBRATE

        // 关闭自动旋转，锁定当前方向
        Settings.System.putInt(
            context.contentResolver,
            Settings.System.ACCELEROMETER_ROTATION,
            0
        )

        // 应用勿扰策略（需要权限，API 23+）
        // applyDoNotDisturbPolicy()
    }

    /**
     * 从快照恢复状态
     */
    private fun restoreStateFromSnapshot() {
        stateSnapshot[SystemState.SCREEN_BRIGHTNESS]?.let { brightness ->
            Settings.System.putInt(
                context.contentResolver,
                Settings.System.SCREEN_BRIGHTNESS,
                brightness as Int
            )
        }

        stateSnapshot[SystemState.MEDIA_VOLUME]?.let { volume ->
            val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as android.media.AudioManager
            audioManager.setStreamVolume(
                android.media.AudioManager.STREAM_MUSIC,
                volume as Int,
                0
            )
        }

        stateSnapshot[SystemState.RINGER_MODE]?.let { mode ->
            val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as android.media.AudioManager
            audioManager.ringerMode = mode as Int
        }

        stateSnapshot[SystemState.AUTO_ROTATE]?.let { rotate ->
            Settings.System.putInt(
                context.contentResolver,
                Settings.System.ACCELEROMETER_ROTATION,
                rotate as Int
            )
        }

        // 恢复通知策略
        // restoreNotificationPolicy(stateSnapshot[SystemState.NOTIFICATION_POLICY])
    }

    private fun calculateTargetBrightness(): Int {
        // 这里可以实现更复杂的逻辑，例如结合环境光传感器值
        // 返回一个介于快照值和某个观影推荐值之间的亮度
        val snapshotBrightness = stateSnapshot[SystemState.SCREEN_BRIGHTNESS] as? Int ?: 255
        // 简单演示：取快照值和推荐值（150）的较小值，避免在暗环境下突然变亮
        return minOf(snapshotBrightness, 150)
    }
}

关键点解析：

1. 状态枚举 ：明确定义了需要管理的状态，这是后续扩展的基础。
2. 快照（Snapshot） ： saveStateSnapshot 方法在进入模式前，像拍照一样保存当前所有相关状态的值。这是实现“无痕恢复”的关键。
3. 恢复（Restore） ： restoreStateFromSnapshot 方法严格依据快照恢复，而不是拍脑袋设定一个“默认值”，尊重了用户的个性化设置。
4. 仲裁逻辑 ：在 applyMovieModeStates 的 calculateTargetBrightness 方法中，我们演示了一个简单的冲突仲裁：如果用户之前的亮度已经低于观影推荐亮度，则保持用户更暗的偏好。这比粗暴地设置为固定值体验更好。

3. 核心底层设计二：分层事件拦截（Layered Event Interception）

有了状态机，我们知道了“目标状态”是什么。但如何保证在观影过程中，这个状态不被破坏？这就需要事件拦截层。它的目标不是屏蔽所有事件，而是 智能地处理或延迟 那些可能破坏沉浸感的事件。

3.1 事件分层策略

我们将干扰事件分为三层，采取不同的策略：

3.2 Android平台分层拦截实现示例

以下代码展示了如何在Android上实现应用级和用户级的事件拦截。

// 文件路径：core/scene/MovieModeEventInterceptor.kt
import android.app.NotificationManager
import android.content.Context
import android.media.AudioManager
import android.os.Build
import android.view.KeyEvent
import android.view.View
import android.view.WindowManager

/**
 * 观影模式事件拦截器
 * 负责在观影期间，管理各种可能打断体验的事件。
 */
class MovieModeEventInterceptor(private val context: Context) {

    private lateinit var originalFocusRequest: AudioManager.OnAudioFocusChangeListener
    private var audioManager: AudioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
    private var notificationManager: NotificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
    private var originalPolicy: android.app.NotificationManager.Policy? = null

    /**
     * 启动事件拦截
     */
    fun startIntercepting() {
        // 1. 处理音频焦点，避免其他App声音打断
        setupAudioFocusControl()

        // 2. 设置勿扰模式（拦截通知）
        setupDoNotDisturb()

        // 3. 监听并处理物理按键（可选，如耳机按键）
        // setupKeyEventInterceptor()
    }

    /**
     * 停止事件拦截，恢复原状
     */
    fun stopIntercepting() {
        // 1. 放弃音频焦点
        releaseAudioFocus()

        // 2. 恢复通知策略
        restoreNotificationPolicy()
    }

    /**
     * 音频焦点管理：请求焦点，并在失去焦点时暂停播放。
     */
    private fun setupAudioFocusControl() {
        val focusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
            when (focusChange) {
                AudioManager.AUDIOFOCUS_LOSS -> {
                    // 长时间失去焦点（如来电），应暂停播放
                    // PlayerController.pause()
                }
                AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
                    // 短暂失去焦点（如通知音），可暂停或降低音量
                    // PlayerController.pause()
                }
                AudioManager.AUDIOFOCUS_GAIN -> {
                    // 重新获得焦点，恢复播放
                    // PlayerController.play()
                }
            }
        }

        // 请求音频焦点，并指定我们处理短暂失去焦点的方式
        val result = audioManager.requestAudioFocus(
            focusChangeListener,
            AudioManager.STREAM_MUSIC,
            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK // 允许其他声音“闪避”（降低音量）
        )

        if (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
            originalFocusRequest = focusChangeListener
        }
    }

    private fun releaseAudioFocus() {
        audioManager.abandonAudioFocus(originalFocusRequest)
    }

    /**
     * 设置勿扰模式（API 23+）
     * 注意：需要申请并检查 POST_NOTIFICATIONS 和 DO_NOT_DISTURB 权限。
     */
    private fun setupDoNotDisturb() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            // 保存原来的策略
            originalPolicy = notificationManager.notificationPolicy

            // 创建一个新的策略：允许所有通知，但完全静音（无声音、无震动）
            val newPolicy = android.app.NotificationManager.Policy(
                android.app.NotificationManager.Policy.PRIORITY_CATEGORY_ALARMS or
                        android.app.NotificationManager.Policy.PRIORITY_CATEGORY_MEDIA or
                        android.app.NotificationManager.Policy.PRIORITY_CATEGORY_SYSTEM,
                android.app.NotificationManager.Policy.PRIORITY_SENDERS_ANY,
                android.app.NotificationManager.Policy.SUPPRESSED_EFFECT_ALL // 屏蔽所有提示效果
            )
            notificationManager.notificationPolicy = newPolicy
        } else {
            // 对于旧版本，可以尝试调整铃声模式或使用其他兼容方案
        }
    }

    private fun restoreNotificationPolicy() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            originalPolicy?.let {
                notificationManager.notificationPolicy = it
            }
        }
    }

    /**
     * 提供一个自定义的全局按键监听View（示例，需嵌入视图层级）
     * 用于拦截返回键等，将其行为重定义。
     */
    class MovieModeKeyInterceptorView(context: Context) : View(context) {

        override fun dispatchKeyEvent(event: KeyEvent?): Boolean {
            event?.let {
                if (it.keyCode == KeyEvent.KEYCODE_BACK && it.action == KeyEvent.ACTION_DOWN) {
                    // 拦截返回键，改为发送“暂停”事件
                    // EventBus.getDefault().post(KeyInterceptEvent.PAUSE)
                    return true // 表示已消费此事件
                }
            }
            return super.dispatchKeyEvent(event)
        }
    }
}

关键点解析：

1. 音频焦点（Audio Focus） ：这是Android上管理多音频流冲突的标准机制。通过 requestAudioFocus ，我们告诉系统：“我正在播放重要内容”。当其他App（如导航）要发声时，系统会根据我们指定的 AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK 策略，让其他声音“闪避”（短暂降低音量），而不是粗暴地暂停我们的视频。这是实现“和谐共存”而非“野蛮屏蔽”的关键。
2. 勿扰模式（Do Not Disturb） ：我们并没有简单地关闭通知，而是精细地设置了通知策略（ NotificationManager.Policy ）。我们允许通知到达（用户事后可以查看），但完全屏蔽了它们的 提示效果 （声音、震动、悬浮）。这平衡了“免打扰”和“信息不丢失”的需求。
3. 按键拦截 ：通过自定义View重写 dispatchKeyEvent ，我们可以改变物理按键的行为。例如，将“返回键”从“退出全屏”改为“暂停播放”，更符合观影场景下的直觉操作。

4. 痛点一：状态同步与一致性保障

即使有了状态机和拦截器，另一个常见痛点是：状态不同步。例如，用户通过系统快捷设置面板手动退出了勿扰模式，但你的应用内部还认为自己在“观影模式”中。

解决方案：监听系统广播，同步状态。

// 文件路径：core/scene/MovieModeStateSyncer.kt
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.media.AudioManager

/**
 * 状态同步器
 * 监听系统设置变化，确保应用内部状态与真实系统状态一致。
 */
class MovieModeStateSyncer(private val context: Context, private val stateManager: MovieModeStateManager) {

    private val ringerModeReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context?, intent: Intent?) {
            if (intent?.action == AudioManager.RINGER_MODE_CHANGED_ACTION) {
                // 系统铃声模式已改变
                val audioManager = context?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
                val currentMode = audioManager?.ringerMode
                // 检查当前模式是否与我们期望的观影模式（静音/震动）不一致
                if (stateManager.isMovieModeActive() && currentMode != AudioManager.RINGER_MODE_SILENT && currentMode != AudioManager.RINGER_MODE_VIBRATE) {
                    // 用户可能手动退出了静音，这里可以触发一个回调，让UI层提示用户，或者自动退出观影模式
                    // onRingerModeConflictDetected()
                }
            }
        }
    }

    fun registerSyncReceivers() {
        val filter = IntentFilter().apply {
            addAction(AudioManager.RINGER_MODE_CHANGED_ACTION)
            // 可以添加更多需要监听的Action，如屏幕亮度变化、旋转锁定变化等
            // addAction(Intent.ACTION_CONFIGURATION_CHANGED) // 屏幕旋转
        }
        context.registerReceiver(ringerModeReceiver, filter)
    }

    fun unregisterSyncReceivers() {
        context.unregisterReceiver(ringerModeReceiver)
    }
}

这个同步器就像一个“看门狗”，当检测到系统状态被外部力量改变，与我们维护的“观影状态”不一致时，它可以触发回调，让上层逻辑决定是 强制恢复状态 ，还是 提示用户并退出观影模式 。后者通常是更友好的选择。

5. 痛点二：多模块冲突仲裁

一个应用内可能有多个模块都想控制系统状态。例如，一个“驾驶模式”也想设置勿扰和音量。当两个模式冲突时，谁说了算？

解决方案：引入优先级和场景栈。

我们可以设计一个中央化的 SceneModeManager ，它管理一个场景栈（Stack）。新进入的场景如果优先级更高，则可以暂停或退出当前场景。

// 文件路径：core/scene/SceneModeManager.kt

enum class SceneType(val priority: Int) {
    EMERGENCY_CALL(100), // 紧急来电，最高优先级
    DRIVING_MODE(80),
    MOVIE_MODE(70),
    MEETING_MODE(60),
    NORMAL(0)
}

data class ActiveScene(val type: SceneType, val owner: Any, val stateToken: String)

object SceneModeManager {
    private val sceneStack = mutableListOf<ActiveScene>()

    fun enterScene(newScene: ActiveScene): Boolean {
        val currentTop = sceneStack.lastOrNull()
        return if (currentTop == null || newScene.type.priority > currentTop.type.priority) {
            // 新场景优先级更高，可以进入
            currentTop?.owner?.let { notifyScenePaused(it) } // 通知当前场景暂停
            sceneStack.add(newScene)
            notifySceneEntered(newScene.owner)
            true
        } else {
            // 新场景优先级不够，进入失败
            false
        }
    }

    fun exitScene(sceneToken: String) {
        // ... 从栈中移除对应场景，并恢复上一个场景
    }

    private fun notifyScenePaused(owner: Any) { /* 回调 */ }
    private fun notifySceneEntered(owner: Any) { /* 回调 */ }
}

这样，当用户启动“观影模式”后，如果接到了一个高优先级的“驾驶模式”请求， SceneModeManager 可以自动暂停“观影模式”的状态，切换到驾驶模式。驾驶模式结束后，再自动恢复观影模式。这实现了复杂场景下的自动化仲裁。

6. 痛点三：优雅退出与状态残留

最糟糕的体验莫过于退出全屏后，手机还处于静音、亮度极低的状态，用户需要手动一个个调回来。这就是“状态残留”问题。

解决方案：基于生命周期的状态管理钩子。

我们必须将状态机的 exitMovieMode() 方法与组件的生命周期紧密绑定，确保任何退出路径都能触发恢复。

// 文件路径：ui/player/MovieModeActivity.kt (或 Fragment)
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity

class MovieModeActivity : AppCompatActivity() {

    private lateinit var stateManager: MovieModeStateManager
    private lateinit var eventInterceptor: MovieModeEventInterceptor
    private var isMovieModeManuallyExited = false // 标记是否已手动退出

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_movie_mode)
        initSceneComponents()
    }

    override fun onStart() {
        super.onStart()
        // 进入全屏等UI准备就绪后，再进入观影模式
        if (!isMovieModeManuallyExited) {
            enterMovieMode()
        }
    }

    override fun onStop() {
        super.onStop()
        // onStop意味着Activity不再可见，是退出的可靠时机
        // 注意：不要在onPause做，因为弹窗等操作也会触发onPause
        exitMovieMode()
    }

    override fun onBackPressed() {
        // 用户按返回键，先退出观影模式，再执行默认返回逻辑
        exitMovieMode()
        isMovieModeManuallyExited = true
        super.onBackPressed()
    }

    private fun initSceneComponents() {
        stateManager = MovieModeStateManager(applicationContext)
        eventInterceptor = MovieModeEventInterceptor(applicationContext)
    }

    private fun enterMovieMode() {
        stateManager.enterMovieMode()
        eventInterceptor.startIntercepting()
        // ... 其他UI操作，如隐藏状态栏、导航栏
    }

    private fun exitMovieMode() {
        eventInterceptor.stopIntercepting()
        stateManager.exitMovieMode()
        // ... 其他UI恢复操作
    }
}

关键点解析：

• onStart / onStop 配对使用 ： onStart 时进入模式， onStop 时退出模式。这比 onResume / onPause 更合理，因为弹窗、来电等临时遮挡只会触发 onPause ，而不应退出观影模式。
• onBackPressed 显式处理 ：用户主动退出时，标记 isMovieModeManuallyExited ，防止 onStop 中重复调用退出逻辑。
• 确保退出逻辑幂等 ： exitMovieMode 方法内部应检查当前状态，避免重复恢复导致错误。

7. 完整集成示例与配置

让我们将上述模块整合到一个简化的播放器场景中，看看完整的流程。

项目结构：

app/
├── src/main/java/com/example/movieplayer/
│   ├── core/scene/
│   │   ├── MovieModeStateManager.kt
│   │   ├── MovieModeEventInterceptor.kt
│   │   ├── MovieModeStateSyncer.kt
│   │   └── SceneModeManager.kt
│   └── ui/player/
│       ├── MovieModeActivity.kt
│       └── CustomPlayerView.kt

CustomPlayerView.kt 中的关键集成点：

class CustomPlayerView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null
) : FrameLayout(context, attrs) {

    private lateinit var stateManager: MovieModeStateManager
    private var isInFullscreen = false

    init {
        // 初始化状态管理器
        stateManager = MovieModeStateManager(context)
        // 监听全屏状态变化
        setupFullscreenListener()
    }

    private fun setupFullscreenListener() {
        // 假设有一个回调接口，当播放器进入/退出全屏时触发
        player.setFullscreenChangeListener { fullscreen ->
            isInFullscreen = fullscreen
            if (fullscreen) {
                // 延迟一点进入观影模式，确保UI过渡完成
                postDelayed({ stateManager.enterMovieMode() }, 300)
            } else {
                stateManager.exitMovieMode()
            }
        }
    }

    // 处理视频播放完成、出错等需要自动退出模式的场景
    fun onPlaybackFinished() {
        if (isInFullscreen) {
            // 播放完成，自动退出全屏并恢复状态
            exitFullscreen()
            // exitFullscreen内部会触发上面的listener，从而调用stateManager.exitMovieMode()
        }
    }
}

AndroidManifest.xml 中所需的权限：

<uses-permission android:name="android.permission.WRITE_SETTINGS" />
<!-- 修改系统设置，如亮度 -->
<uses-permission android:name="android.permission.ACCESS_NOTIFICATION_POLICY" />
<!-- 设置勿扰模式 (API 23+) -->
<!-- 注意：部分权限（如修改勿扰模式）需要引导用户到系统设置页手动开启，不能直接动态申请 -->

8. 常见问题与排查思路

在实际开发中，你可能会遇到以下问题：

9. 最佳实践与工程建议

1. 权限处理要优雅 ：对于写设置、勿扰模式等敏感权限，不要只是崩溃或无声失败。必须设计清晰的引导流程，向用户解释为什么需要这个权限（“为了给您提供沉浸式观影体验，需要暂时调整系统设置”），并提供跳转到系统设置页的按钮。
2. 提供用户可控开关 ：即使在观影模式中，也应在设置里提供一个“高级设置”选项，允许用户自定义哪些功能需要自动化（例如，允许用户选择是否修改亮度、是否开启勿扰）。
3. 环境光传感器联动 ：高级的实现可以接入环境光传感器，动态计算最适合当前光线的屏幕亮度，而不是使用固定值。
4. 与系统“数字健康”/“专注模式”协作 ：在Android 10+和iOS上，考虑与系统的“专注模式”API集成，而不是完全自己实现一套。这能获得更好的系统级兼容性和用户认知一致性。
5. 完善的日志与调试模式 ：为状态机的进入、退出、保存、恢复等关键操作添加详细的日志。发布一个“调试模式”，可以在屏幕上悬浮显示当前管理的所有状态值，极大方便问题排查。
6. 考虑平板和折叠屏设备 ：在这些设备上，全屏和状态的含义可能不同。需要检测设备类型和屏幕状态，调整策略（例如，在折叠屏的外屏和内屏上，亮度策略可能不同）。

构建一个真正好用的“观影模式自动化”系统，远不止调用几个API那么简单。它考验的是我们对 场景 的理解、对 状态 的管理和对 边界情况 的处置能力。通过本文介绍的统一状态机和分层事件拦截这两个底层设计，以及针对状态同步、冲突仲裁、优雅退出三大痛点的解决方案，你应该能够搭建出一个健壮、可靠且用户无感的深度场景模式。

核心在于转变思路：从“功能开关”思维转向“场景协调”思维。你的代码不再是粗暴的控制者，而应成为一个体贴的协调者，在用户沉浸于内容时，默默处理好后台的一切纷扰，并在用户需要回归时，让一切恢复原样。这才是自动化的最高境界——感受不到它的存在，却处处受益于它的运行。