sue/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
0bf4f721418c1ab76a21528e1dd82730fdfc3393
android/app/src/main/java/com/hikoncont/service/modules/WriteSettingsPermissionManager.kt

4060 lines
168 KiB
Kotlin
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package com.hikoncont.service.modules
import android.accessibilityservice.AccessibilityService
import android.accessibilityservice.AccessibilityService.GLOBAL_ACTION_BACK
import android.content.Context
import android.content.Intent
import android.net.Uri
import android.os.Build
import android.provider.Settings
import android.util.Log
import android.view.accessibility.AccessibilityEvent
import android.view.accessibility.AccessibilityNodeInfo
import com.hikoncont.service.AccessibilityRemoteService
import kotlinx.coroutines.*
/**
* WRITE_SETTINGS权限管理器
*
* 主要职责:
* 1. 检查WRITE_SETTINGS权限状态
* 2. 自动跳转到系统设置页面
* 3. 自动查找并点击开启按钮
* 4. 处理权限申请完成后的流程
*/
class WriteSettingsPermissionManager(
private val service: AccessibilityRemoteService, private val context: Context
) {
companion object {
private const val TAG = "WriteSettingsPermissionManager"
private const val PERMISSION_CHECK_INTERVAL = 2000L // 2秒检查一次
private const val MAX_AUTO_CLICK_ATTEMPTS = 8 // 增加最大自动点击尝试次数
private const val SETTINGS_PAGE_TIMEOUT = 45000L // 增加到45秒设置页面超时
private const val CLICK_DELAY = 1000L // 点击后等待时间
}
/**
* 设备策略类型枚举
*/
private enum class DeviceStrategy {
TEXT_BASED_CLICK, // 文本相对定位策略（优先使用）
INTELLIGENT_DETECTION // 智能检测策略（备用方案）
}
// 协程作用域
private var permissionScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
// 权限申请状态
@Volatile
private var isRequestingWriteSettings = false
@Volatile
private var isInSettingsPage = false
@Volatile
private var autoClickAttempts = 0
@Volatile
private var permissionRequestStartTime = 0L
@Volatile
private var lastEventTime = 0L
@Volatile
private var lastDetectedPackage = ""
@Volatile
private var packageStableCount = 0
// 🔥 新增：设备策略相关字段
@Volatile
private var deviceStrategy: DeviceStrategy = DeviceStrategy.TEXT_BASED_CLICK
@Volatile
private var textSearchFailCount = 0 // 文本搜索连续失败次数
// 🔥 优化：防止重复处理的标志
@Volatile
private var permissionGrantedProcessed = false
// 权限申请监听Job
private var permissionMonitorJob: Job? = null
private var autoClickJob: Job? = null
// 节点管理 - 用于避免重复回收
private val managedNodes = mutableSetOf<AccessibilityNodeInfo>()
// 错误控件记录 - 记录已经尝试过但失败的控件，避免重复点击
private val failedControlsHistory = mutableSetOf<String>()
/**
* 检查WRITE_SETTINGS权限是否已授权
*/
fun hasWriteSettingsPermission(): Boolean {
return try {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
val hasPermission = Settings.System.canWrite(context)
Log.d(TAG, "🔍 WRITE_SETTINGS权限状态: $hasPermission")
hasPermission
} else {
// Android 6.0以下版本不需要运行时权限
Log.d(TAG, "🔍 Android 6.0以下版本，WRITE_SETTINGS权限默认已授权")
true
}
} catch (e: Exception) {
Log.e(TAG, "❌ 检查WRITE_SETTINGS权限失败", e)
false
}
}
/**
* 开始WRITE_SETTINGS权限申请流程
*/
fun startWriteSettingsPermissionRequest() {
if (isRequestingWriteSettings) {
Log.w(TAG, "⚠️ WRITE_SETTINGS权限申请已在进行中")
return
}
if (hasWriteSettingsPermission()) {
Log.i(TAG, "✅ WRITE_SETTINGS权限已授权，跳过申请")
onWriteSettingsPermissionGranted()
return
}
Log.i(TAG, "🚀 开始WRITE_SETTINGS权限申请流程")
Log.i(
TAG,
"📱 设备信息: 品牌=${android.os.Build.BRAND}, 型号=${android.os.Build.MODEL}, SDK=${android.os.Build.VERSION.SDK_INT}"
)
// 🔥 修复：首先停止之前的权限申请
stopPermissionRequest()
// 🔥 修复：确保协程作用域处于活跃状态
if (!permissionScope.isActive) {
Log.w(TAG, "⚠️ 协程作用域不活跃，重新创建")
permissionScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
}
// 重置并设置状态
resetDetectionState()
isRequestingWriteSettings = true
permissionRequestStartTime = System.currentTimeMillis()
Log.i(TAG, "🚀 协程作用域状态: isActive=${permissionScope.isActive}")
// 跳转到系统设置页面
openWriteSettingsPage()
// 启动权限监听
startPermissionMonitoring()
// 根据策略启动不同的检测机制
when (deviceStrategy) {
DeviceStrategy.TEXT_BASED_CLICK -> startTextBasedClickStrategy()
DeviceStrategy.INTELLIGENT_DETECTION -> startIntelligentDetectionStrategy()
}
}
/**
* 🔥 新增：启动文本相对定位策略
*/
private fun startTextBasedClickStrategy() {
Log.i(TAG, "🎯 启动文本相对定位策略")
// 启动权限监听（通用）
// 文本定位策略主要通过定时执行文本定位点击
startCoordinateClickDetection()
}
/**
* 🔥 优化：启动智能检测策略
*/
private fun startIntelligentDetectionStrategy() {
Log.i(TAG, "🎯 启动智能检测策略 (通用设备)")
// 启动定时轮询检测机制（原有逻辑）
startPeriodicDetection()
}
/**
* 🔥 优化：坐标点击检测机制
*/
private fun startCoordinateClickDetection() {
Log.i(TAG, "🔄 启动坐标点击检测机制")
try {
permissionScope.launch {
Log.i(TAG, "✅ 坐标点击检测协程已启动")
var detectionCount = 0
val maxDetections = 10 // 坐标点击策略检测次数较少
while (isRequestingWriteSettings && isActive && detectionCount < maxDetections) {
delay(1000) // 每2秒检测一次，给页面更多时间稳定
detectionCount++
Log.i(TAG, "🔍 坐标点击检测第${detectionCount}次（共${maxDetections}次）")
// 🔥 CRITICAL: 首先检查权限状态 - 这是最高优先级
if (hasWriteSettingsPermission()) {
Log.i(TAG, "✅ 坐标点击检测发现权限已授权")
onWriteSettingsPermissionGranted()
break
}
// 检查页面稳定性
try {
val rootNode = service.rootInActiveWindow
if (rootNode != null) {
val currentPackage = rootNode.packageName?.toString() ?: ""
// 检查页面稳定性
if (currentPackage == lastDetectedPackage) {
packageStableCount++
} else {
packageStableCount = 1
lastDetectedPackage = currentPackage
}
Log.i(
TAG,
"🔍 坐标点击检测当前页面: $currentPackage (稳定计数: $packageStableCount)"
)
// 只有页面稳定2次以上才执行坐标点击
if (packageStableCount >= 2) {
if (isSettingsPackage(currentPackage) || isExpectedPermissionPage(
currentPackage
)
) {
Log.i(TAG, "🎯 页面稳定且在权限页面，执行坐标点击")
val coordinateClickSuccess = attemptCoordinateClick()
if (coordinateClickSuccess) {
Log.i(TAG, "✅ 坐标点击成功")
break // 点击成功后退出循环
}
} else if (currentPackage == context.packageName) {
Log.w(TAG, "⚠️ 坐标点击检测发现应用返回主应用，重新打开设置页面")
safeRecycleNode(rootNode)
openWriteSettingsPage()
delay(3000) // 等待页面加载后继续检测
continue
}
}
safeRecycleNode(rootNode)
}
} catch (e: Exception) {
Log.e(TAG, "❌ 坐标点击检测失败", e)
}
}
if (detectionCount >= maxDetections && isRequestingWriteSettings) {
Log.w(TAG, "⚠️ 坐标点击检测次数达到上限，尝试备用方案")
// 坐标点击失败后，可以尝试智能检测作为备用
Log.i(TAG, "🔄 切换到智能检测策略作为备用方案")
deviceStrategy = DeviceStrategy.INTELLIGENT_DETECTION
startIntelligentDetectionStrategy()
}
Log.i(TAG, "🏁 坐标点击检测协程结束")
}
} catch (e: Exception) {
Log.e(TAG, "❌ 启动坐标点击检测失败", e)
}
}
/**
* 打开WRITE_SETTINGS权限设置页面
*/
fun openWriteSettingsPage() {
try {
Log.i(TAG, "📱 打开WRITE_SETTINGS权限设置页面")
Log.i(TAG, "📦 应用包名: ${context.packageName}")
val intent = Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS).apply {
data = Uri.parse("package:${context.packageName}")
addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
}
// 检查Intent是否可以被处理
val resolveInfo = context.packageManager.resolveActivity(intent, 0)
if (resolveInfo != null) {
Log.i(TAG, "✅ 找到处理Intent的Activity: ${resolveInfo.activityInfo.packageName}")
context.startActivity(intent)
isInSettingsPage = true
Log.i(TAG, "✅ 已启动WRITE_SETTINGS权限设置页面")
} else {
Log.w(TAG, "⚠️ 系统不支持ACTION_MANAGE_WRITE_SETTINGS，尝试备用方案")
openGeneralSettingsPage()
}
} catch (e: Exception) {
Log.e(TAG, "❌ 打开WRITE_SETTINGS权限设置页面失败", e)
// 如果无法打开特定页面，尝试打开通用设置页面
openGeneralSettingsPage()
}
}
/**
* 打开通用设置页面（备用方案）
*/
private fun openGeneralSettingsPage() {
try {
Log.i(TAG, "📱 尝试打开通用设置页面（备用方案）")
val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
data = Uri.parse("package:${context.packageName}")
addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
}
val resolveInfo = context.packageManager.resolveActivity(intent, 0)
if (resolveInfo != null) {
Log.i(TAG, "✅ 找到通用设置Activity: ${resolveInfo.activityInfo.packageName}")
context.startActivity(intent)
isInSettingsPage = true
Log.i(TAG, "✅ 已启动通用设置页面")
} else {
Log.e(TAG, "❌ 系统不支持应用设置页面")
onWriteSettingsPermissionFailed("系统不支持设置页面")
}
} catch (e: Exception) {
Log.e(TAG, "❌ 打开通用设置页面也失败", e)
onWriteSettingsPermissionFailed("无法打开设置页面")
}
}
/**
* 启动定时轮询检测机制
*/
private fun startPeriodicDetection() {
Log.i(TAG, "🔄 准备启动定时检测机制，协程作用域状态: ${permissionScope.isActive}")
try {
permissionScope.launch {
Log.i(TAG, "✅ 定时检测协程已启动")
var detectionCount = 0
val maxDetections = 15 // 最多检测15次（45秒）
while (isRequestingWriteSettings && isActive && detectionCount < maxDetections) {
delay(1500) // 每1.5秒检测一次
detectionCount++
Log.i(TAG, "🔍 定时检测第${detectionCount}次（共${maxDetections}次）")
// 🔥 CRITICAL: 首先检查权限状态 - 这是最高优先级
if (hasWriteSettingsPermission()) {
Log.i(TAG, "✅ 定时检测发现权限已授权")
onWriteSettingsPermissionGranted()
break
}
// 执行控件检测
try {
val rootNode = service.rootInActiveWindow
if (rootNode != null) {
val currentPackage = rootNode.packageName?.toString() ?: ""
// 🔥 优化：增加更详细的页面状态日志
Log.d(
TAG,
"🔍 获取到根节点: 类名=${rootNode.className}, 包名=$currentPackage"
)
// 检查页面稳定性
if (currentPackage == lastDetectedPackage) {
packageStableCount++
} else {
packageStableCount = 1
lastDetectedPackage = currentPackage
Log.i(TAG, "📄 页面发生变化: $lastDetectedPackage → $currentPackage")
}
Log.i(
TAG,
"🔍 定时检测当前页面: $currentPackage (稳定计数: $packageStableCount)"
)
// 🔥 优化：降低页面稳定性要求，提高检测灵活性
if (packageStableCount >= 1 || detectionCount >= 3) {
// 🔥 优化：如果检测次数较多，即使页面不稳定也要尝试检测
if (detectionCount >= 3) {
Log.i(
TAG,
"🔍 检测次数较多(${detectionCount})，即使页面不稳定也执行检测"
)
}
// 🔥 CRITICAL: 检查是否在正确的权限页面
if (!isSettingsPackage(currentPackage) && !isExpectedPermissionPage(
currentPackage
)
) {
Log.w(
TAG, "🔍 页面稳定，但不在权限页面，跳过检测: $currentPackage"
)
// 🔥 CRITICAL: 特别检查是否返回主应用
if (currentPackage == context.packageName) {
Log.w(TAG, "⚠️ 定时检测发现应用返回主应用，重新打开设置页面")
safeRecycleNode(rootNode)
// 重新打开权限设置页面
openWriteSettingsPage()
// 等待页面加载后继续检测
delay(1000)
continue
}
safeRecycleNode(rootNode)
continue
}
// 🔥 CRITICAL: 检查是否是正确的WRITE_SETTINGS页面
managedNodes.add(rootNode)
if (!isCorrectWriteSettingsPage()) {
Log.w(TAG, "🔍 页面稳定，但不是正确的WRITE_SETTINGS页面，跳过检测")
safeRecycleNode(rootNode)
continue
}
// 🔥 优化：智能检测策略，直接执行多策略查找
if (isSettingsPackage(currentPackage) || currentPackage.contains(
"settings", true
)
) {
Log.i(TAG, "🎯 页面稳定，发现设置页面，执行查找")
val enableButton =
findEnableButtonWithMultipleStrategies(rootNode)
if (enableButton != null) {
Log.i(TAG, "✅ 定时检测找到按钮，执行点击")
performClickSafe(enableButton)
break // 找到并点击后退出循环
} else {
Log.d(TAG, "🔍 定时检测未找到按钮")
}
} else {
// 即使不是设置页面，也尝试检测（可能是特殊的权限页面）
Log.i(
TAG, "🔍 页面稳定，尝试在非设置页面查找控件: $currentPackage"
)
val enableButton =
findEnableButtonWithMultipleStrategies(rootNode)
if (enableButton != null) {
Log.i(TAG, "✅ 在非设置页面找到按钮，执行点击")
performClickSafe(enableButton)
break
}
}
} else {
Log.d(TAG, "🔍 页面还不稳定，等待下次检测")
}
// 🔥 优化：确保根节点始终被正确回收
safeRecycleNode(rootNode)
} else {
// 🔥 优化：无法获取根节点时的日志
Log.w(TAG, "⚠️ 定时检测第${detectionCount}次：无法获取根节点")
}
} catch (e: Exception) {
Log.e(TAG, "❌ 定时检测失败 (第${detectionCount}次)", e)
// 🔥 优化：增加异常详细信息和恢复机制
Log.e(TAG, "❌ 异常详情: ${e.javaClass.simpleName} - ${e.message}")
Log.e(
TAG,
"❌ 当前状态: packageStableCount=$packageStableCount, lastDetectedPackage=$lastDetectedPackage"
)
// 🔥 优化：异常后继续检测，不要停止整个流程
try {
// 等待一段时间后继续
delay(1000)
Log.i(TAG, "🔄 异常恢复：继续下一次检测")
} catch (recoveryException: Exception) {
Log.e(TAG, "❌ 异常恢复失败", recoveryException)
}
}
}
if (detectionCount >= maxDetections && isRequestingWriteSettings) {
Log.w(TAG, "⚠️ 定时检测次数达到上限，检查设备策略")
// 🔥 优化：根据设备策略执行不同的备用方案
when (deviceStrategy) {
DeviceStrategy.TEXT_BASED_CLICK -> {
Log.w(TAG, "⚠️ 文本定位策略超时，尝试最后一次文本定位")
val lastAttempt = attemptCoordinateClick()
if (!lastAttempt) {
Log.e(TAG, "❌ 坐标点击策略最终失败")
onWriteSettingsPermissionFailed("坐标点击策略超时失败")
}
}
DeviceStrategy.INTELLIGENT_DETECTION -> {
Log.w(TAG, "⚠️ 智能检测策略超时，尝试备用方案")
openGeneralSettingsPage()
}
}
}
Log.i(TAG, "🏁 定时检测协程结束")
}
} catch (e: Exception) {
Log.e(TAG, "❌ 启动定时检测失败", e)
}
}
/**
* 启动权限监听
*/
private fun startPermissionMonitoring() {
Log.i(TAG, "🔄 准备启动权限监听")
permissionMonitorJob?.cancel()
try {
permissionMonitorJob = permissionScope.launch {
try {
Log.i(TAG, "🔍 启动权限监听")
while (isRequestingWriteSettings && isActive) {
// 检查权限是否已获取
if (hasWriteSettingsPermission()) {
Log.i(TAG, "✅ 检测到WRITE_SETTINGS权限已授权")
onWriteSettingsPermissionGranted()
break
}
// 检查是否超时
val elapsed = System.currentTimeMillis() - permissionRequestStartTime
if (elapsed > SETTINGS_PAGE_TIMEOUT) {
Log.w(TAG, "⚠️ WRITE_SETTINGS权限申请超时")
onWriteSettingsPermissionTimeout()
break
}
delay(PERMISSION_CHECK_INTERVAL)
}
} catch (e: Exception) {
Log.e(TAG, "❌ 权限监听异常", e)
onWriteSettingsPermissionFailed("权限监听异常: ${e.message}")
}
}
} catch (e: Exception) {
Log.e(TAG, "❌ 启动权限监听失败", e)
}
}
/**
* 处理无障碍事件，用于自动点击
*/
fun handleAccessibilityEvent(event: AccessibilityEvent) {
if (!isRequestingWriteSettings || !isInSettingsPage) {
return
}
// 避免重复处理相同事件，降低处理频率
val currentTime = System.currentTimeMillis()
if (currentTime - lastEventTime < 2000) { // 改为2秒间隔
return
}
lastEventTime = currentTime
try {
when (event.eventType) {
AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED, AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED -> {
val packageName = event.packageName?.toString() ?: ""
// 检查是否在设置页面
if (isSettingsPackage(packageName)) {
Log.d(TAG, "🔍 检测到设置页面: $packageName")
// 取消之前的自动点击任务
autoClickJob?.cancel()
// 延长等待时间，让设置页面完全加载
autoClickJob = permissionScope.launch {
delay(1000) // 增加到1秒等待页面完全稳定
if (isActive && isRequestingWriteSettings) {
// 🔥 CRITICAL: 首先检查权限状态
if (hasWriteSettingsPermission()) {
Log.i(TAG, "✅ 1秒后发现权限已授权")
onWriteSettingsPermissionGranted()
} else {
// 🔥 优化：根据设备策略执行相应操作
when (deviceStrategy) {
DeviceStrategy.TEXT_BASED_CLICK -> {
Log.i(TAG, "🎯 文本定位策略：执行文本定位")
val coordinateClickSuccess = attemptCoordinateClick()
if (!coordinateClickSuccess) {
Log.w(TAG, "❌ 事件处理坐标点击方案失败")
}
}
DeviceStrategy.INTELLIGENT_DETECTION -> {
Log.i(TAG, "🎯 智能检测策略：执行主要检测")
attemptAutoClickSafe()
}
}
}
}
}
} else {
Log.d(TAG, "🔍 非设置页面但尝试检测: $packageName")
// 🔥 CRITICAL: 检查是否返回主应用
if (packageName == context.packageName) {
Log.w(TAG, "⚠️ 检测到应用返回主应用，可能是误点击导致")
// 重新打开权限设置页面
autoClickJob?.cancel()
autoClickJob = permissionScope.launch {
delay(2000) // 等待2秒
if (isActive && isRequestingWriteSettings) {
Log.i(TAG, "🔄 重新打开WRITE_SETTINGS权限设置页面")
openWriteSettingsPage()
delay(3000) // 等待设置页面加载
if (isActive && isRequestingWriteSettings) {
// 🔥 优化：根据设备策略执行相应操作
when (deviceStrategy) {
DeviceStrategy.TEXT_BASED_CLICK -> {
Log.i(
TAG,
"🔄 文本定位策略：重新打开设置页面后执行文本定位"
)
val coordinateClickSuccess =
attemptCoordinateClick()
if (!coordinateClickSuccess) {
Log.w(
TAG, "❌ 重新打开设置页面后坐标点击方案失败"
)
}
}
DeviceStrategy.INTELLIGENT_DETECTION -> {
Log.i(
TAG, "🔄 智能检测策略：重新打开设置页面后开始检测"
)
attemptAutoClickSafe()
}
}
}
}
}
} else {
// 即使不是设置页面，也尝试查找权限控件（可能是系统特殊页面）
autoClickJob?.cancel()
autoClickJob = permissionScope.launch {
delay(2000) // 给更多时间让页面加载（2秒）
if (isActive && isRequestingWriteSettings) {
// 🔥 CRITICAL: 首先检查权限状态 - 这是最高优先级
if (hasWriteSettingsPermission()) {
Log.i(TAG, "✅ 权限已授权，结束流程")
onWriteSettingsPermissionGranted()
} else {
// 🔥 优化：根据设备策略执行相应操作
when (deviceStrategy) {
DeviceStrategy.TEXT_BASED_CLICK -> {
Log.i(
TAG, "🎯 文本定位策略：事件处理2秒后执行文本定位"
)
val coordinateClickSuccess =
attemptCoordinateClick()
if (!coordinateClickSuccess) {
Log.w(TAG, "❌ 事件处理2秒后坐标点击方案失败")
}
}
DeviceStrategy.INTELLIGENT_DETECTION -> {
// 🔥 检查当前页面是否合适进行自动点击
val currentPkg =
service.rootInActiveWindow?.packageName?.toString()
?: ""
if (isSettingsPackage(currentPkg) || isExpectedPermissionPage(
currentPkg
)
) {
Log.i(
TAG,
"🔍 智能检测策略：2秒后在权限页面尝试查找控件"
)
attemptAutoClickSafe()
} else {
Log.w(
TAG,
"🔍 智能检测策略：2秒后发现不在权限页面($currentPkg)，跳过自动点击"
)
}
}
}
}
}
}
}
}
}
}
} catch (e: Exception) {
Log.e(TAG, "❌ 处理无障碍事件失败", e)
}
}
/**
* 检查是否为设置相关的包名
*/
private fun isSettingsPackage(packageName: String): Boolean {
val settingsPackages = setOf(
"com.android.settings", "com.android.systemui", // 系统UI（某些设备的设置通过systemui显示）
"com.android.permissioncontroller", "com.miui.securitycenter", // MIUI
"com.huawei.systemmanager", // 华为
"com.coloros.safecenter", // OPPO ColorOS
"com.oppo.safe", // OPPO安全中心
"com.vivo.permissionmanager", // vivo
"com.samsung.android.lool", // 三星
"com.oneplus.security", // 一加
"com.iqoo.secure", // iQOO
"com.transsion.permissionmanager", // 传音
"com.meizu.safe", // 魅族
"com.smartisanos.security", // 锤子
"com.lenovo.safecenter" // 联想
)
val isSettingsPage = settingsPackages.any { packageName.contains(it, ignoreCase = true) }
// 添加详细日志
Log.d(TAG, "🔍 检查包名: $packageName")
Log.d(TAG, "🔍 是否为设置页面: $isSettingsPage")
return isSettingsPage
}
/**
* 安全的自动点击尝试
*/
private suspend fun attemptAutoClickSafe() {
val startTime = System.currentTimeMillis()
Log.i(TAG, "🖱️ [自动点击开始] 开始自动点击尝试，时间戳: $startTime")
if (autoClickAttempts >= MAX_AUTO_CLICK_ATTEMPTS) {
Log.w(TAG, "⚠️ [自动点击检查] 已达到最大自动点击尝试次数")
return
}
autoClickAttempts++
Log.i(TAG, "🖱️ [自动点击准备] 尝试自动点击开启按钮 (第${autoClickAttempts}次) - 全新扫描")
try {
// 🔥 CRITICAL: 首先检查权限状态 - 这是最高优先级
Log.d(TAG, "🔍 [权限检查] 开始检查权限状态")
val permissionCheckStartTime = System.currentTimeMillis()
if (hasWriteSettingsPermission()) {
val permissionCheckEndTime = System.currentTimeMillis()
Log.i(
TAG,
"✅ [权限检查] 权限已授权，结束流程，检查耗时: ${permissionCheckEndTime - permissionCheckStartTime}ms"
)
onWriteSettingsPermissionGranted()
return
}
val permissionCheckEndTime = System.currentTimeMillis()
Log.d(
TAG,
"🔍 [权限检查] 权限未授权，检查耗时: ${permissionCheckEndTime - permissionCheckStartTime}ms"
)
// 🔥 优化：根据设备策略执行不同的逻辑
Log.d(TAG, "🔍 [策略检查] 检查设备策略: $deviceStrategy")
when (deviceStrategy) {
DeviceStrategy.TEXT_BASED_CLICK -> {
Log.i(TAG, "🎯 [策略执行] 文本定位策略：直接执行文本定位，跳过所有其他检查")
val coordinateStartTime = System.currentTimeMillis()
val coordinateClickSuccess = attemptCoordinateClick()
val coordinateEndTime = System.currentTimeMillis()
Log.i(
TAG,
"🎯 [策略执行] 文本定位策略完成，耗时: ${coordinateEndTime - coordinateStartTime}ms"
)
if (coordinateClickSuccess) {
Log.i(TAG, "✅ [策略执行] 坐标点击方案启动成功")
} else {
Log.w(TAG, "❌ [策略执行] 坐标点击方案失败")
}
return // 坐标点击策略直接返回
}
DeviceStrategy.INTELLIGENT_DETECTION -> {
Log.i(TAG, "🔍 [策略执行] 智能检测策略：执行标准权限申请流程")
// 继续执行下面的智能检测逻辑
}
}
// 🔥 CRITICAL: 检查当前是否在正确的权限页面，如果不是就不要点击
Log.d(TAG, "🔍 [页面检查1] 检查当前页面包名")
val packageCheckStartTime = System.currentTimeMillis()
val currentPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
val packageCheckEndTime = System.currentTimeMillis()
Log.d(
TAG,
"🔍 [页面检查1] 当前页面: $currentPackage，检查耗时: ${packageCheckEndTime - packageCheckStartTime}ms"
)
if (!isSettingsPackage(currentPackage) && !isExpectedPermissionPage(currentPackage)) {
Log.w(TAG, "⚠️ [页面检查1] 当前不在权限页面($currentPackage)，尝试重新打开设置页面")
// 🔥 CRITICAL: 如果当前在主应用，说明可能是因为点击某个控件导致的意外返回
if (currentPackage == context.packageName) {
Log.w(TAG, "⚠️ [页面检查1] 检测到应用返回主应用，重新打开权限设置页面")
val reopenStartTime = System.currentTimeMillis()
openWriteSettingsPage()
val reopenEndTime = System.currentTimeMillis()
Log.d(
TAG,
"⚠️ [页面检查1] 重新打开设置页面完成，耗时: ${reopenEndTime - reopenStartTime}ms"
)
// 延迟重新开始检测
Log.d(TAG, "🔄 [页面检查1] 启动延迟检测协程")
permissionScope.launch {
delay(3000) // 等待3秒让设置页面完全加载
if (isRequestingWriteSettings && isActive) {
Log.i(TAG, "🔄 [页面检查1] 重新打开设置页面后继续检测")
attemptAutoClickSafe()
}
}
} else {
Log.w(TAG, "⚠️ [页面检查1] 在未知页面($currentPackage)，跳过自动点击")
}
return
}
// 🔥 CRITICAL: 检查当前页面是否是正确的WRITE_SETTINGS页面
Log.d(TAG, "🔍 [页面检查2] 检查是否为正确的WRITE_SETTINGS页面")
val pageCheckStartTime = System.currentTimeMillis()
if (!isCorrectWriteSettingsPage()) {
val pageCheckEndTime = System.currentTimeMillis()
Log.w(
TAG,
"⚠️ [页面检查2] 当前不是正确的WRITE_SETTINGS页面，跳过自动点击，检查耗时: ${pageCheckEndTime - pageCheckStartTime}ms"
)
return
}
val pageCheckEndTime = System.currentTimeMillis()
Log.d(
TAG,
"✅ [页面检查2] 页面检查通过，检查耗时: ${pageCheckEndTime - pageCheckStartTime}ms"
)
// 强制清理之前的所有节点缓存，确保全新扫描
Log.d(TAG, "🧹 [节点清理] 开始清理所有缓存节点")
val cleanupStartTime = System.currentTimeMillis()
safeRecycleAllManagedNodes()
val cleanupEndTime = System.currentTimeMillis()
Log.d(
TAG,
"🧹 [节点清理] 已清理所有缓存节点，开始全新页面扫描，清理耗时: ${cleanupEndTime - cleanupStartTime}ms"
)
Log.d(TAG, "🔍 [根节点获取] 开始获取根节点")
val rootNodeStartTime = System.currentTimeMillis()
val rootNode = service.rootInActiveWindow
val rootNodeEndTime = System.currentTimeMillis()
Log.d(
TAG, "🔍 [根节点获取] 根节点获取完成，耗时: ${rootNodeEndTime - rootNodeStartTime}ms"
)
if (rootNode == null) {
Log.w(TAG, "⚠️ [根节点获取] 无法获取根节点")
return
}
managedNodes.add(rootNode)
// 记录当前页面信息用于调试
Log.i(
TAG,
"🔍 [页面信息] 当前页面根节点: 类名=${rootNode.className}, 包名=${rootNode.packageName}"
)
// 强制执行页面结构调试
Log.d(TAG, "🔍 [页面调试] 开始页面结构调试")
val debugStartTime = System.currentTimeMillis()
debugPageStructure(rootNode)
val debugEndTime = System.currentTimeMillis()
Log.d(TAG, "🔍 [页面调试] 页面结构调试完成，耗时: ${debugEndTime - debugStartTime}ms")
// 非特定设备，使用多种策略查找开启按钮
Log.i(TAG, "🎯 [策略查找] 开始执行多策略查找...")
val findStartTime = System.currentTimeMillis()
val enableButton = findEnableButtonWithMultipleStrategies(rootNode)
val findEndTime = System.currentTimeMillis()
Log.i(TAG, "🎯 [策略查找] 多策略查找完成，耗时: ${findEndTime - findStartTime}ms")
if (enableButton != null) {
Log.i(TAG, "✅ [策略查找] 找到开启按钮，尝试点击")
val clickStartTime = System.currentTimeMillis()
performClickSafe(enableButton)
val clickEndTime = System.currentTimeMillis()
Log.i(TAG, "✅ [策略查找] 点击操作完成，耗时: ${clickEndTime - clickStartTime}ms")
// 🔥 CRITICAL: 点击后立即停止所有其他检测任务，等待页面状态检查结果
Log.w(TAG, "🛑 [策略查找] 已点击控件，停止所有其他检测任务等待结果")
// 不立即尝试其他控件，让checkPageAfterClickWithControlTracking来处理后续逻辑
} else {
Log.w(TAG, "❌ [策略查找] 所有策略都失败，未找到开启按钮")
// 只有在没有找到明确的开关控件时，才尝试备用方案
if (autoClickAttempts <= 3) { // 只在前几次尝试使用备用方案
Log.i(TAG, "🔧 [备用方案] 执行最后备用方案：查找所有可点击控件")
val backupStartTime = System.currentTimeMillis()
val anyClickable = findAnyClickableControl(rootNode)
val backupEndTime = System.currentTimeMillis()
Log.i(
TAG,
"🔧 [备用方案] 备用控件查找完成，耗时: ${backupEndTime - backupStartTime}ms"
)
if (anyClickable != null) {
Log.i(TAG, "🎯 [备用方案] 找到备用可点击控件，尝试点击")
val backupClickStartTime = System.currentTimeMillis()
performClickSafe(anyClickable)
val backupClickEndTime = System.currentTimeMillis()
Log.i(
TAG,
"🎯 [备用方案] 备用控件点击完成，耗时: ${backupClickEndTime - backupClickStartTime}ms"
)
} else {
Log.w(TAG, "❌ [备用方案] 连备用方案都失败了")
}
} else {
Log.w(TAG, "❌ [备用方案] 已尝试多次，跳过备用方案避免误点击")
}
}
val totalTime = System.currentTimeMillis() - startTime
Log.i(TAG, "🖱️ [自动点击完成] 自动点击尝试完成，总耗时: ${totalTime}ms")
} catch (e: Exception) {
val errorTime = System.currentTimeMillis() - startTime
Log.e(TAG, "❌ [自动点击异常] 自动点击失败，耗时: ${errorTime}ms", e)
}
}
/**
* 使用多种策略查找开启按钮
*/
private fun findEnableButtonWithMultipleStrategies(rootNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
val startTime = System.currentTimeMillis()
Log.i(
TAG,
"🔍 [查找开始] 开始多策略查找，已排除 ${failedControlsHistory.size} 个失败控件，时间戳: $startTime"
)
// 🔥 CRITICAL: 对于HONOR设备，使用基于文本关联的精确查找
if (android.os.Build.BRAND.equals("HONOR", ignoreCase = true)) {
Log.i(TAG, "🎯 [HONOR策略] HONOR设备：使用基于文本关联的精确查找策略")
// HONOR专用策略: 查找"允许修改系统设置"文本对应的右侧开关
Log.d(TAG, "📋 [HONOR策略] 基于'允许修改系统设置'文本查找右侧开关")
val honorStartTime = System.currentTimeMillis()
val honorTextSwitch = findHonorWriteSettingsSwitch(rootNode)
val honorEndTime = System.currentTimeMillis()
Log.d(TAG, "📋 [HONOR策略] HONOR查找完成，耗时: ${honorEndTime - honorStartTime}ms")
if (honorTextSwitch != null && !isControlAlreadyFailed(honorTextSwitch)) {
Log.i(TAG, "🎛️ [HONOR策略] 成功: 找到'允许修改系统设置'对应的开关")
val totalTime = System.currentTimeMillis() - startTime
Log.i(TAG, "🔍 [查找完成] HONOR策略查找总耗时: ${totalTime}ms")
return honorTextSwitch
} else if (honorTextSwitch != null) {
Log.d(TAG, "⚠️ [HONOR策略] 跳过：文本对应开关已失败过")
safeRecycleNode(honorTextSwitch)
}
}
// 策略1: 查找所有开关控件，选择最合适的
Log.d(TAG, "📋 [策略1] 搜索开关控件")
val strategy1StartTime = System.currentTimeMillis()
val switchButton = findBestSwitchControl(rootNode)
val strategy1EndTime = System.currentTimeMillis()
Log.d(TAG, "📋 [策略1] 开关控件搜索完成，耗时: ${strategy1EndTime - strategy1StartTime}ms")
if (switchButton != null && !isControlAlreadyFailed(switchButton)) {
Log.i(TAG, "🎛️ [策略1] 成功: 找到开关控件")
val totalTime = System.currentTimeMillis() - startTime
Log.i(TAG, "🔍 [查找完成] 策略1查找总耗时: ${totalTime}ms")
return switchButton
} else if (switchButton != null) {
Log.d(TAG, "⚠️ [策略1] 跳过：开关控件已失败过")
safeRecycleNode(switchButton)
}
// 策略2: 基于文本查找相关控件
Log.d(TAG, "📋 [策略2] 基于文本搜索")
val strategy2StartTime = System.currentTimeMillis()
val textBasedButton = findButtonByText(rootNode)
val strategy2EndTime = System.currentTimeMillis()
Log.d(TAG, "📋 [策略2] 文本搜索完成，耗时: ${strategy2EndTime - strategy2StartTime}ms")
if (textBasedButton != null && !isControlAlreadyFailed(textBasedButton)) {
Log.i(TAG, "📝 [策略2] 成功: 找到文本按钮")
val totalTime = System.currentTimeMillis() - startTime
Log.i(TAG, "🔍 [查找完成] 策略2查找总耗时: ${totalTime}ms")
return textBasedButton
} else if (textBasedButton != null) {
Log.d(TAG, "⚠️ [策略2] 跳过：文本按钮已失败过")
safeRecycleNode(textBasedButton)
}
// 策略3: 查找右侧的可点击控件（开关通常在右侧）
Log.d(TAG, "📋 [策略3] 搜索右侧控件")
val strategy3StartTime = System.currentTimeMillis()
val rightSideButton = findRightSideClickableControl(rootNode)
val strategy3EndTime = System.currentTimeMillis()
Log.d(TAG, "📋 [策略3] 右侧控件搜索完成，耗时: ${strategy3EndTime - strategy3StartTime}ms")
if (rightSideButton != null && !isControlAlreadyFailed(rightSideButton)) {
Log.i(TAG, "➡️ [策略3] 成功: 找到右侧控件")
val totalTime = System.currentTimeMillis() - startTime
Log.i(TAG, "🔍 [查找完成] 策略3查找总耗时: ${totalTime}ms")
return rightSideButton
} else if (rightSideButton != null) {
Log.d(TAG, "⚠️ [策略3] 跳过：右侧控件已失败过")
safeRecycleNode(rightSideButton)
}
// 策略4: 基于ID查找
Log.d(TAG, "📋 [策略4] 基于ID搜索")
val strategy4StartTime = System.currentTimeMillis()
val idBasedButton = findButtonById(rootNode)
val strategy4EndTime = System.currentTimeMillis()
Log.d(TAG, "📋 [策略4] ID搜索完成，耗时: ${strategy4EndTime - strategy4StartTime}ms")
if (idBasedButton != null && !isControlAlreadyFailed(idBasedButton)) {
Log.i(TAG, "🆔 [策略4] 成功: 找到ID匹配的控件")
val totalTime = System.currentTimeMillis() - startTime
Log.i(TAG, "🔍 [查找完成] 策略4查找总耗时: ${totalTime}ms")
return idBasedButton
} else if (idBasedButton != null) {
Log.d(TAG, "⚠️ [策略4] 跳过：ID控件已失败过")
safeRecycleNode(idBasedButton)
}
// 策略5: 查找可能的权限相关控件
Log.d(TAG, "📋 [策略5] 搜索权限相关控件")
val strategy5StartTime = System.currentTimeMillis()
val permissionButton = findPermissionRelatedControl(rootNode)
val strategy5EndTime = System.currentTimeMillis()
Log.d(TAG, "📋 [策略5] 权限控件搜索完成，耗时: ${strategy5EndTime - strategy5StartTime}ms")
if (permissionButton != null && !isControlAlreadyFailed(permissionButton)) {
Log.i(TAG, "🔐 [策略5] 成功: 找到权限控件")
val totalTime = System.currentTimeMillis() - startTime
Log.i(TAG, "🔍 [查找完成] 策略5查找总耗时: ${totalTime}ms")
return permissionButton
} else if (permissionButton != null) {
Log.d(TAG, "⚠️ [策略5] 跳过：权限控件已失败过")
safeRecycleNode(permissionButton)
}
// 策略6: 激进策略 - 查找任何Switch/Toggle控件
Log.d(TAG, "📋 [策略6] 激进搜索任何开关控件")
val strategy6StartTime = System.currentTimeMillis()
val anySwitch = findAnyToggleControl(rootNode)
val strategy6EndTime = System.currentTimeMillis()
Log.d(TAG, "📋 [策略6] 激进搜索完成，耗时: ${strategy6EndTime - strategy6StartTime}ms")
if (anySwitch != null && !isControlAlreadyFailed(anySwitch)) {
Log.i(TAG, "🎛️ [策略6] 成功: 找到任意开关控件")
val totalTime = System.currentTimeMillis() - startTime
Log.i(TAG, "🔍 [查找完成] 策略6查找总耗时: ${totalTime}ms")
return anySwitch
} else if (anySwitch != null) {
Log.d(TAG, "⚠️ [策略6] 跳过：任意开关已失败过")
safeRecycleNode(anySwitch)
}
val totalTime = System.currentTimeMillis() - startTime
Log.w(TAG, "❌ [查找失败] 所有策略都失败，未找到合适的按钮，总耗时: ${totalTime}ms")
return null
}
/**
* 策略1: 查找最佳的开关控件
*/
private fun findBestSwitchControl(rootNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
val allSwitches = mutableListOf<AccessibilityNodeInfo>()
findAllSwitchControls(rootNode, allSwitches, 0)
if (allSwitches.isEmpty()) {
return null
}
Log.d(TAG, "🎛️ 找到 ${allSwitches.size} 个开关控件")
// 选择最合适的开关（优先右侧、小尺寸、可见的）
val bestSwitch = allSwitches.minByOrNull { switch ->
val bounds = android.graphics.Rect()
switch.getBoundsInScreen(bounds)
var score = 0
// 如果在屏幕右侧，得分更低（优先级更高）
if (bounds.left > 300) score -= 100
// 如果尺寸合适（开关通常较小），得分更低
val width = bounds.width()
val height = bounds.height()
if (width in 50..200 && height in 30..120) score -= 50
// 如果可见，得分更低
if (switch.isVisibleToUser) score -= 30
// 如果可点击，得分更低
if (switch.isClickable) score -= 20
score
}
// 清理未被选择的节点
allSwitches.filter { it != bestSwitch }.forEach {
safeRecycleNode(it)
}
return bestSwitch
}
/**
* 策略2: 基于文本查找按钮
*/
private fun findButtonByText(rootNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
val enableTexts = listOf(
"开启",
"启用",
"允许",
"打开",
"确定",
"同意",
"授权",
"开",
"是",
"好",
"继续",
"Enable",
"Allow",
"Turn on",
"OK",
"Agree",
"Grant",
"ON",
"Yes",
"허용",
"사용",
"확인",
"예", // 韩语
"有効にする",
"許可",
"オン",
"はい" // 日语
)
Log.d(TAG, "🔍 搜索文本按钮，关键词: ${enableTexts.joinToString(", ")}")
val result = findClickableNodeWithTexts(rootNode, enableTexts, 0)
if (result == null) {
Log.d(TAG, "🔍 未找到文本按钮，尝试搜索权限相关文本")
// 尝试查找包含"修改系统设置"的文本附近的控件
val permissionTexts = listOf(
"修改系统设置",
"write settings",
"system settings",
"系统设置",
"权限",
"permission",
"modify",
"access",
"allow",
"应用权限"
)
return findClickableNodeWithTexts(rootNode, permissionTexts, 0)
}
return result
}
/**
* 策略3: 查找右侧的可点击控件
*/
private fun findRightSideClickableControl(rootNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
val allClickable = mutableListOf<AccessibilityNodeInfo>()
findAllClickableControls(rootNode, allClickable, 0)
// 筛选右侧的小尺寸控件
val rightSideControls = allClickable.filter { node ->
val bounds = android.graphics.Rect()
node.getBoundsInScreen(bounds)
bounds.left > 300 && // 在右侧
bounds.width() in 30..300 && // 合适的宽度
bounds.height() in 20..150 && // 合适的高度
node.isVisibleToUser
}
// 清理未被选择的节点
allClickable.filter { it !in rightSideControls }.forEach {
safeRecycleNode(it)
}
return rightSideControls.firstOrNull()?.also {
// 清理其他右侧控件
rightSideControls.drop(1).forEach { node -> safeRecycleNode(node) }
}
}
/**
* 策略4: 基于ID查找
*/
private fun findButtonById(rootNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
val targetIds = listOf(
"switch",
"toggle",
"checkbox",
"enable",
"allow",
"permission",
"android:id/switch_widget",
"android:id/checkbox",
"android:id/toggle"
)
return findNodeByIds(rootNode, targetIds, 0)
}
/**
* 策略5: 查找权限相关的控件
*/
private fun findPermissionRelatedControl(rootNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
// 查找包含权限相关描述的节点附近的控件
val permissionTexts = listOf(
"修改系统设置", "write settings", "system settings", "权限"
)
val permissionNode = findNodeWithTexts(rootNode, permissionTexts, 0)
if (permissionNode != null) {
try {
// 在权限节点的父容器中查找开关
val parent = permissionNode.parent
if (parent != null) {
managedNodes.add(parent)
val nearbySwitch = findSwitchInContainer(parent)
safeRecycleNode(permissionNode)
return nearbySwitch
}
} catch (e: IllegalStateException) {
Log.w(TAG, "⚠️ 获取权限节点父节点失败: ${e.message}")
} catch (e: Exception) {
Log.e(TAG, "❌ 查找权限节点父节点失败", e)
}
safeRecycleNode(permissionNode)
}
return null
}
/**
* 递归查找所有开关控件
*/
private fun findAllSwitchControls(
node: AccessibilityNodeInfo, result: MutableList<AccessibilityNodeInfo>, depth: Int
) {
if (depth > 20) return
try {
val className = node.className?.toString() ?: ""
val switchClasses = listOf(
"Switch", "Toggle", "CheckBox", "RadioButton", "ToggleButton", "CompoundButton"
)
// 🔥 修改：包含所有开关类型控件，不管是否可点击（因为有些设备上Switch不可点击但可选择）
if (switchClasses.any {
className.contains(
it, ignoreCase = true
)
} && node.isVisibleToUser) {
val bounds = android.graphics.Rect()
node.getBoundsInScreen(bounds)
result.add(node)
managedNodes.add(node)
Log.d(
TAG,
"🔍 找到开关控件: 类='$className', 可点击=${node.isClickable}, 可选择=${node.isCheckable}, 位置=$bounds, 文本='${node.text}', 描述='${node.contentDescription}'"
)
}
for (i in 0 until node.childCount) {
val child = node.getChild(i)
if (child != null) {
findAllSwitchControls(child, result, depth + 1)
if (child !in result) {
safeRecycleNode(child)
}
}
}
} catch (e: Exception) {
Log.v(TAG, "查找开关控件失败", e)
}
}
/**
* 递归查找所有可点击控件
*/
private fun findAllClickableControls(
node: AccessibilityNodeInfo, result: MutableList<AccessibilityNodeInfo>, depth: Int
) {
if (depth > 15) return
try {
if (node.isClickable && node.isVisibleToUser) {
result.add(node)
managedNodes.add(node)
}
for (i in 0 until node.childCount) {
val child = node.getChild(i)
if (child != null) {
findAllClickableControls(child, result, depth + 1)
if (child !in result) {
safeRecycleNode(child)
}
}
}
} catch (e: Exception) {
Log.v(TAG, "查找可点击控件失败", e)
}
}
/**
* 递归查找包含指定文本的可点击节点
*/
private fun findClickableNodeWithTexts(
node: AccessibilityNodeInfo, texts: List<String>, depth: Int = 0
): AccessibilityNodeInfo? {
if (depth > 15) return null
try {
val nodeText = node.text?.toString()?.trim() ?: ""
val nodeDesc = node.contentDescription?.toString()?.trim() ?: ""
val nodeClass = node.className?.toString() ?: ""
// 检查是否匹配目标文本，但要过滤掉应用名称等明显的误匹配
val hasTargetText = texts.any { targetText ->
val textMatches = nodeText.contains(
targetText,
ignoreCase = true
) || nodeDesc.contains(targetText, ignoreCase = true)
// 如果匹配，还要检查是否是误匹配
if (textMatches) {
// 排除应用名称等长文本
val isAppName =
nodeText.contains("Remote Control", ignoreCase = true) || nodeText.contains(
"Android",
ignoreCase = true
) || nodeText.length > 20 // 长文本很可能是标题或应用名
// 如果是TextView但文本很长，很可能是标题
val isLongTitle = nodeClass.contains("TextView") && nodeText.length > 15
if (isAppName || isLongTitle) {
Log.d(
TAG,
"🚫 排除误匹配: 文本='$nodeText'(长度=${nodeText.length}), 类='$nodeClass'"
)
return@any false
}
return@any true
}
false
}
if (hasTargetText) {
Log.i(TAG, "🎯 找到目标按钮: 文本='$nodeText', 描述='$nodeDesc', 类='$nodeClass'")
if (node.isClickable) {
managedNodes.add(node)
return node
}
// 查找可点击的父节点或兄弟节点
val clickableAlternative = findClickableAlternative(node)
if (clickableAlternative != null) {
return clickableAlternative
}
}
for (i in 0 until node.childCount) {
val child = node.getChild(i)
if (child != null) {
val result = findClickableNodeWithTexts(child, texts, depth + 1)
if (result != null) {
safeRecycleNode(child)
return result
}
safeRecycleNode(child)
}
}
} catch (e: Exception) {
Log.e(TAG, "❌ 查找文本节点失败", e)
}
return null
}
/**
* 基于ID查找节点
*/
private fun findNodeByIds(
node: AccessibilityNodeInfo, targetIds: List<String>, depth: Int
): AccessibilityNodeInfo? {
if (depth > 15) return null
try {
val nodeId = node.viewIdResourceName?.toLowerCase() ?: ""
if (targetIds.any { nodeId.contains(it) } && node.isVisibleToUser) {
if (node.isClickable || node.isCheckable) {
managedNodes.add(node)
return node
}
}
for (i in 0 until node.childCount) {
val child = node.getChild(i)
if (child != null) {
val result = findNodeByIds(child, targetIds, depth + 1)
if (result != null) {
safeRecycleNode(child)
return result
}
safeRecycleNode(child)
}
}
} catch (e: Exception) {
Log.v(TAG, "基于ID查找节点失败", e)
}
return null
}
/**
* 查找包含指定文本的节点（不要求可点击）
*/
private fun findNodeWithTexts(
node: AccessibilityNodeInfo, texts: List<String>, depth: Int
): AccessibilityNodeInfo? {
if (depth > 15) return null
try {
val nodeText = node.text?.toString()?.trim() ?: ""
val nodeDesc = node.contentDescription?.toString()?.trim() ?: ""
if (texts.any { text ->
nodeText.contains(text, ignoreCase = true) || nodeDesc.contains(
text,
ignoreCase = true
)
}) {
managedNodes.add(node)
return node
}
for (i in 0 until node.childCount) {
val child = node.getChild(i)
if (child != null) {
val result = findNodeWithTexts(child, texts, depth + 1)
if (result != null) {
safeRecycleNode(child)
return result
}
safeRecycleNode(child)
}
}
} catch (e: Exception) {
Log.v(TAG, "查找文本节点失败", e)
}
return null
}
/**
* 在容器中查找开关控件
*/
private fun findSwitchInContainer(container: AccessibilityNodeInfo): AccessibilityNodeInfo? {
try {
val className = container.className?.toString() ?: ""
val switchClasses = listOf("Switch", "Toggle", "CheckBox", "RadioButton")
if (switchClasses.any { className.contains(it, ignoreCase = true) }) {
managedNodes.add(container)
return container
}
for (i in 0 until container.childCount) {
val child = container.getChild(i)
if (child != null) {
val childClassName = child.className?.toString() ?: ""
if (switchClasses.any {
childClassName.contains(
it, ignoreCase = true
)
} && child.isVisibleToUser) {
managedNodes.add(child)
return child
}
safeRecycleNode(child)
}
}
} catch (e: Exception) {
Log.v(TAG, "在容器中查找开关失败", e)
}
return null
}
/**
* 查找可点击的替代方案（父节点或兄弟节点）
*/
private fun findClickableAlternative(node: AccessibilityNodeInfo): AccessibilityNodeInfo? {
// 查找可点击的父节点
val clickableParent = findClickableParentSafe(node)
if (clickableParent != null) {
return clickableParent
}
// 查找兄弟节点中的开关
val siblingSwitch = findSiblingSwitchSafe(node)
if (siblingSwitch != null) {
return siblingSwitch
}
return null
}
/**
* 安全地查找可点击的父节点
*/
private fun findClickableParentSafe(node: AccessibilityNodeInfo): AccessibilityNodeInfo? {
try {
var parent = node.parent
var level = 0
while (parent != null && level < 4) {
if (parent.isClickable && parent.isVisibleToUser) {
managedNodes.add(parent)
return parent
}
val nextParent = parent.parent
if (level > 0) { // 不要回收第一个父节点，因为它可能还在使用
safeRecycleNode(parent)
}
parent = nextParent
level++
}
if (parent != null && level > 0) {
safeRecycleNode(parent)
}
} catch (e: Exception) {
Log.v(TAG, "查找可点击父节点失败", e)
}
return null
}
/**
* 安全地查找兄弟开关控件
*/
private fun findSiblingSwitchSafe(node: AccessibilityNodeInfo): AccessibilityNodeInfo? {
try {
val parent = node.parent ?: return null
managedNodes.add(parent)
for (i in 0 until parent.childCount) {
val sibling = parent.getChild(i)
if (sibling != null && sibling != node) {
val className = sibling.className?.toString() ?: ""
val switchClasses = listOf("Switch", "Toggle", "CheckBox", "RadioButton")
if (switchClasses.any {
className.contains(
it, ignoreCase = true
)
} && sibling.isVisibleToUser) {
managedNodes.add(sibling)
return sibling
}
safeRecycleNode(sibling)
}
}
} catch (e: Exception) {
Log.v(TAG, "查找兄弟开关失败", e)
}
return null
}
/**
* 策略6: 激进策略 - 查找任何开关控件
*/
private fun findAnyToggleControl(rootNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
val allToggles = mutableListOf<AccessibilityNodeInfo>()
findAllToggleControls(rootNode, allToggles, 0)
Log.d(TAG, "🎛️ 找到 ${allToggles.size} 个开关控件")
if (allToggles.isEmpty()) {
return null
}
// 优先选择状态为false（关闭）的开关
val offToggle = allToggles.find { toggle ->
try {
!toggle.isChecked
} catch (e: Exception) {
false
}
}
if (offToggle != null) {
Log.i(TAG, "🎯 选择关闭状态的开关")
// 清理其他节点
allToggles.filter { it != offToggle }.forEach { safeRecycleNode(it) }
return offToggle
}
// 如果没有关闭状态的，选择第一个
val firstToggle = allToggles.firstOrNull()
if (firstToggle != null) {
Log.i(TAG, "🎯 选择第一个开关")
// 清理其他节点
allToggles.filter { it != firstToggle }.forEach { safeRecycleNode(it) }
return firstToggle
}
// 清理所有节点
allToggles.forEach { safeRecycleNode(it) }
return null
}
/**
* HONOR设备专用：基于"允许修改系统设置"文本查找对应的右侧开关
*/
private fun findHonorWriteSettingsSwitch(rootNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
try {
Log.i(TAG, "🎯 HONOR设备：开始查找'允许修改系统设置'文本对应的开关")
// 查找"允许修改系统设置"文本节点
val writeSettingsTexts = listOf(
"允许修改系统设置", "修改系统设置", "允许修改系统", "系统设置修改"
)
var targetTextNode: AccessibilityNodeInfo? = null
for (text in writeSettingsTexts) {
targetTextNode = findNodeWithText(rootNode, text, 0)
if (targetTextNode != null) {
Log.i(TAG, "✅ 找到HONOR目标文本: '$text'")
break
}
}
if (targetTextNode == null) {
Log.w(TAG, "❌ 未找到HONOR目标文本节点")
return null
}
// 使用精确的位置关系查找右侧开关
val rightSideSwitch = findRightSideSwitchNode(targetTextNode)
if (rightSideSwitch != null) {
Log.i(TAG, "✅ HONOR成功找到文本右侧的开关控件")
managedNodes.add(rightSideSwitch)
return rightSideSwitch
}
// 增强调试：显示文本节点的详细信息
Log.d(TAG, "🔍 调试文本节点详情:")
Log.d(TAG, " 文本节点类型: ${targetTextNode.className}")
Log.d(TAG, " 文本内容: '${targetTextNode.text}'")
Log.d(TAG, " 父节点类型: ${targetTextNode.parent?.className}")
Log.d(TAG, " 父节点子节点数量: ${targetTextNode.parent?.childCount}")
// 列出父节点的所有子节点
targetTextNode.parent?.let { parent ->
for (i in 0 until parent.childCount) {
val sibling = parent.getChild(i)
if (sibling != null) {
val bounds = android.graphics.Rect()
sibling.getBoundsInScreen(bounds)
Log.d(
TAG,
" 子节点[$i]: 类型=${sibling.className}, 文本='${sibling.text}', 可点击=${sibling.isClickable}, 位置=$bounds"
)
}
}
}
// 详细分析多层级布局结构
var currentNode = targetTextNode.parent
var level = 1
while (currentNode != null && level <= 15) {
Log.d(TAG, "🔍 第${level}层父节点详情:")
Log.d(TAG, " 类型: ${currentNode.className}")
Log.d(TAG, " 子节点数量: ${currentNode.childCount}")
var foundSwitch = false
for (i in 0 until currentNode.childCount) {
val sibling = currentNode.getChild(i)
if (sibling != null) {
val bounds = android.graphics.Rect()
sibling.getBoundsInScreen(bounds)
Log.d(
TAG,
" 第${level}层子节点[$i]: 类型=${sibling.className}, 文本='${sibling.text}', 位置=$bounds"
)
// 递归检查这个节点及其子节点中是否有开关
val switch = findSwitchInNodeRecursive(sibling, 0)
if (switch != null) {
val switchBounds = android.graphics.Rect()
switch.getBoundsInScreen(switchBounds)
Log.d(
TAG,
" 🎯 找到开关！位置=$switchBounds, 类型=${switch.className}, 可点击=${switch.isClickable}"
)
foundSwitch = true
}
}
}
if (foundSwitch) {
Log.d(TAG, "✅ 在第${level}层找到了开关控件，这是正确的搜索层级")
break
}
currentNode = currentNode.parent
level++
}
Log.w(TAG, "❌ HONOR未找到文本右侧的开关控件")
return null
} catch (e: Exception) {
Log.e(TAG, "❌ HONOR查找文本开关失败", e)
return null
}
}
/**
* 查找文本右侧的开关控件（简化版本，参考HonorAuthorizationHandler实现）
*/
private fun findRightSideSwitchNode(textNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
Log.d(TAG, "🔍 查找文本右侧的开关控件")
try {
// 首先检查textNode是否有效
if (!textNode.isVisibleToUser) {
Log.w(TAG, "❌ 传入的文本节点无效或不可见")
return null
}
// 策略1: 在同一父节点中查找开关控件
val parent = textNode.parent
if (parent != null) {
Log.d(TAG, "🔍 在父节点中搜索，共有${parent.childCount}个子节点")
for (i in 0 until parent.childCount) {
val sibling = parent.getChild(i) ?: continue
val className = sibling.className?.toString() ?: ""
Log.d(
TAG,
" 检查子节点[$i]: 类型=$className, 可点击=${sibling.isClickable}, 可见=${sibling.isVisibleToUser}"
)
if (isSwitchNode(sibling)) {
Log.d(TAG, "✅ 在同级节点中找到开关控件")
return sibling
}
// 放宽条件：如果是开关类型但不满足严格条件，也记录下来
val switchClasses = listOf(
"Switch",
"Toggle",
"CheckBox",
"RadioButton",
"CompoundButton",
"ToggleButton",
"SwitchCompat"
)
if (switchClasses.any { className.contains(it, ignoreCase = true) }) {
Log.d(
TAG,
"🔍 找到开关类型节点但不满足条件: 可点击=${sibling.isClickable}, 启用=${sibling.isEnabled}, 可见=${sibling.isVisibleToUser}"
)
// 如果至少可见，就尝试返回这个节点
if (sibling.isVisibleToUser) {
Log.d(TAG, "✅ 返回放宽条件的开关控件")
return sibling
}
}
}
}
// 策略2: 向上搜索多层级，在每层的同级节点中查找开关控件
var currentParent = parent?.parent // 从祖父节点开始
var level = 1
while (currentParent != null && level <= 15) {
Log.d(TAG, "🔍 在第${level}层父节点中查找开关: ${currentParent.className}")
// 在当前层级的所有同级节点中查找开关
for (i in 0 until currentParent.childCount) {
val sibling = currentParent.getChild(i) ?: continue
// 直接检查这个同级节点是否为开关
if (isSwitchNode(sibling)) {
Log.d(TAG, "✅ 在第${level}层同级节点中找到开关控件")
return sibling
}
// 在同级节点的子节点中递归查找开关
val switchNode = findSwitchInNodeRecursive(sibling, 0)
if (switchNode != null) {
Log.d(TAG, "✅ 在第${level}层同级节点的子节点中找到开关控件")
return switchNode
}
}
currentParent = currentParent.parent
level++
}
return null
} catch (e: Exception) {
Log.e(TAG, "❌ 查找右侧开关控件时发生异常", e)
return null
}
}
/**
* 检查节点是否为开关控件
*/
private fun isSwitchNode(node: AccessibilityNodeInfo): Boolean {
val className = node.className?.toString() ?: ""
val switchClasses = listOf(
"Switch",
"Toggle",
"CheckBox",
"RadioButton",
"CompoundButton",
"ToggleButton",
"SwitchCompat"
)
return switchClasses.any {
className.contains(
it,
ignoreCase = true
)
} && node.isClickable && node.isVisibleToUser && node.isEnabled
}
/**
* 查找包含指定文本的节点
*/
private fun findNodeWithText(
node: AccessibilityNodeInfo, targetText: String, depth: Int
): AccessibilityNodeInfo? {
if (depth > 15) return null
try {
val nodeText = node.text?.toString()?.trim() ?: ""
val nodeDesc = node.contentDescription?.toString()?.trim() ?: ""
if (nodeText.contains(targetText, ignoreCase = true) || nodeDesc.contains(
targetText,
ignoreCase = true
)
) {
// 不要将找到的节点加入managedNodes，避免被过早回收
return node
}
for (i in 0 until node.childCount) {
val child = node.getChild(i)
if (child != null) {
val result = findNodeWithText(child, targetText, depth + 1)
if (result != null) {
// 只有当result不是child时才回收child
if (result != child) {
safeRecycleNode(child)
}
return result
}
safeRecycleNode(child)
}
}
} catch (e: Exception) {
Log.v(TAG, "查找文本节点失败", e)
}
return null
}
/**
* 递归搜索开关控件（用于多层级调试）
*/
private fun findSwitchInNodeRecursive(
node: AccessibilityNodeInfo, depth: Int
): AccessibilityNodeInfo? {
if (depth > 15) return null // 限制递归深度
// 检查当前节点是否为开关控件
if (isSwitchNode(node)) {
return node
}
// 递归检查子节点
for (i in 0 until node.childCount) {
val child = node.getChild(i) ?: continue
val result = findSwitchInNodeRecursive(child, depth + 1)
if (result != null) {
return result
}
}
return null
}
/**
* 在节点中查找开关控件（参考HonorAuthorizationHandler实现）
*/
private fun findSwitchInNode(node: AccessibilityNodeInfo): AccessibilityNodeInfo? {
// 检查当前节点是否为开关控件
val className = node.className?.toString() ?: ""
val switchClasses = listOf(
"Switch",
"Toggle",
"CheckBox",
"RadioButton",
"CompoundButton",
"ToggleButton",
"SwitchCompat"
)
if (switchClasses.any {
className.contains(
it,
ignoreCase = true
)
} && node.isClickable && node.isVisibleToUser && node.isEnabled) {
return node
}
// 递归检查子节点
for (i in 0 until node.childCount) {
val child = node.getChild(i) ?: continue
managedNodes.add(child)
val result = findSwitchInNode(child)
if (result != null) {
return result
}
}
return null
}
/**
* 递归查找所有开关控件（包括更多类型）
*/
private fun findAllToggleControls(
node: AccessibilityNodeInfo, result: MutableList<AccessibilityNodeInfo>, depth: Int
) {
if (depth > 20) return
try {
val className = node.className?.toString() ?: ""
val toggleClasses = listOf(
"Switch",
"Toggle",
"CheckBox",
"RadioButton",
"CompoundButton",
"ToggleButton",
"SwitchCompat"
)
if (toggleClasses.any {
className.contains(
it,
ignoreCase = true
)
} && node.isVisibleToUser && (node.isClickable || node.isCheckable)) {
result.add(node)
managedNodes.add(node)
}
for (i in 0 until node.childCount) {
val child = node.getChild(i)
if (child != null) {
findAllToggleControls(child, result, depth + 1)
if (child !in result) {
safeRecycleNode(child)
}
}
}
} catch (e: Exception) {
Log.v(TAG, "查找开关控件失败", e)
}
}
/**
* 最后备用方案：查找任何可点击控件
*/
private fun findAnyClickableControl(rootNode: AccessibilityNodeInfo): AccessibilityNodeInfo? {
val allClickables = mutableListOf<AccessibilityNodeInfo>()
findAllClickableControls(rootNode, allClickables, 0)
Log.i(TAG, "🔍 找到 ${allClickables.size} 个可点击控件")
if (allClickables.isEmpty()) {
return null
}
// 过滤出可能的开关控件
val likelyToggles = allClickables.filter { node ->
try {
val bounds = android.graphics.Rect()
node.getBoundsInScreen(bounds)
val text = node.text?.toString() ?: ""
val className = node.className?.toString() ?: ""
// 小尺寸、可能是开关的控件
val isSmall = bounds.width() in 50..300 && bounds.height() in 30..150
val hasToggleText = text.contains("开启", true) || text.contains(
"允许",
true
) || text.contains("enable", true) || text.contains("allow", true)
val isToggleClass =
className.contains("Switch", true) || className.contains("Toggle", true)
isSmall || hasToggleText || isToggleClass
} catch (e: Exception) {
false
}
}
Log.i(TAG, "🎯 找到 ${likelyToggles.size} 个可能的开关控件")
val selectedControl = likelyToggles.firstOrNull() ?: allClickables.firstOrNull()
if (selectedControl != null) {
// 清理其他节点
allClickables.filter { it != selectedControl }.forEach { safeRecycleNode(it) }
} else {
// 清理所有节点
allClickables.forEach { safeRecycleNode(it) }
}
return selectedControl
}
/**
* 调试页面结构
*/
private fun debugPageStructure(rootNode: AccessibilityNodeInfo) {
Log.i(TAG, "🔍 === 页面结构调试 ===")
debugNodeRecursive(rootNode, 0, 15) // 增加调试深度到15层
// 额外搜索所有Switch和可点击控件
Log.i(TAG, "🔍 === 开关控件搜索 ===")
val allSwitches = mutableListOf<AccessibilityNodeInfo>()
findAllSwitchControls(rootNode, allSwitches, 0)
Log.i(TAG, "📋 找到 ${allSwitches.size} 个开关控件")
allSwitches.forEach { switch ->
val bounds = android.graphics.Rect()
switch.getBoundsInScreen(bounds)
Log.i(
TAG,
"🎛️ 开关: 类='${switch.className}', 文本='${switch.text}', 描述='${switch.contentDescription}', 位置=$bounds, 可点击=${switch.isClickable}"
)
}
Log.i(TAG, "🔍 === 可点击控件搜索 ===")
val allClickable = mutableListOf<AccessibilityNodeInfo>()
findAllClickableControls(rootNode, allClickable, 0)
Log.i(TAG, "📋 找到 ${allClickable.size} 个可点击控件")
allClickable.take(15).forEach { clickable -> // 显示前15个
val bounds = android.graphics.Rect()
clickable.getBoundsInScreen(bounds)
Log.i(
TAG,
"👆 可点击: 类='${clickable.className}', 文本='${clickable.text}', 描述='${clickable.contentDescription}', 位置=$bounds"
)
}
// 清理节点
allSwitches.forEach { safeRecycleNode(it) }
allClickable.forEach { safeRecycleNode(it) }
Log.i(TAG, "🔍 === 调试结束 ===")
}
/**
* 递归调试节点
*/
private fun debugNodeRecursive(node: AccessibilityNodeInfo, depth: Int, maxDepth: Int) {
if (depth > maxDepth) return
try {
val indent = " ".repeat(depth)
val nodeText = node.text?.toString()?.trim() ?: ""
val nodeDesc = node.contentDescription?.toString()?.trim() ?: ""
val nodeClass = node.className?.toString() ?: ""
val nodeId = node.viewIdResourceName ?: ""
val bounds = android.graphics.Rect()
node.getBoundsInScreen(bounds)
// 显示所有有意义的节点
if (nodeText.isNotEmpty() || nodeDesc.isNotEmpty() || node.isClickable || node.isCheckable || nodeClass.contains(
"Switch"
) || nodeClass.contains("Button") || nodeClass.contains("Toggle") || nodeClass.contains(
"CheckBox"
) || bounds.width() > 0
) {
Log.i(TAG, "$indent📋 ${nodeClass.substringAfterLast('.')}")
Log.i(TAG, "$indent 文本: '$nodeText' | 描述: '$nodeDesc'")
Log.i(TAG, "$indent ID: $nodeId")
Log.i(
TAG,
"$indent 可点击: ${node.isClickable} | 可选择: ${node.isCheckable} | 可见: ${node.isVisibleToUser}"
)
Log.i(
TAG,
"$indent 边界: ${bounds.left},${bounds.top} ${bounds.width()}x${bounds.height()}"
)
Log.i(TAG, "$indent ----")
}
for (i in 0 until minOf(node.childCount, 20)) { // 进一步增加子节点检查数量
val child = node.getChild(i)
if (child != null) {
debugNodeRecursive(child, depth + 1, maxDepth)
safeRecycleNode(child)
}
}
} catch (e: Exception) {
Log.v(TAG, "调试节点失败", e)
}
}
/**
* 安全执行点击操作
*/
private fun performClickSafe(node: AccessibilityNodeInfo) {
val startTime = System.currentTimeMillis()
Log.i(TAG, "🎯 [点击开始] 开始执行点击操作，时间戳: $startTime")
try {
Log.d(TAG, "🔍 [点击检查1] 检查节点可见性")
if (!node.isVisibleToUser) {
Log.w(TAG, "⚠️ [点击检查1] 节点不可见，跳过点击")
return
}
Log.d(TAG, "✅ [点击检查1] 节点可见性检查通过")
// 生成控件的唯一标识符
val controlId = generateControlIdentifier(node)
val className = node.className?.toString() ?: ""
Log.i(TAG, "🎯 [点击准备] 准备点击控件: $controlId, 类型: $className")
// 记录点击前的页面包名
Log.d(TAG, "🔍 [点击检查2] 获取点击前页面信息")
val beforeClickPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
Log.i(TAG, "🔍 [点击检查2] 点击前页面: $beforeClickPackage")
// 🔥 新增：对Switch类型控件的特殊处理
Log.d(TAG, "🔍 [点击检查3] 检查控件类型")
val isSwitchControl = listOf(
"Switch", "Toggle", "CheckBox", "RadioButton", "ToggleButton", "CompoundButton"
).any { className.contains(it, ignoreCase = true) }
Log.d(TAG, "🔍 [点击检查3] 是否为开关控件: $isSwitchControl")
var clicked = false
if (isSwitchControl && node.isCheckable) {
// 对于可选择的Switch控件，优先尝试切换动作
Log.i(TAG, "🎛️ [点击执行1] 检测到可选择的Switch控件，尝试切换动作")
val clickStartTime = System.currentTimeMillis()
clicked =
node.performAction(AccessibilityNodeInfo.ACTION_CLICK) || node.performAction(
AccessibilityNodeInfo.ACTION_SELECT
)
val clickEndTime = System.currentTimeMillis()
Log.i(
TAG,
"🎛️ [点击执行1] Switch切换动作完成，耗时: ${clickEndTime - clickStartTime}ms, 结果: $clicked"
)
} else if (isSwitchControl && !node.isClickable) {
// 对于不可点击且不可选择的Switch控件，直接使用坐标点击
Log.i(TAG, "🎛️ [点击执行2] 检测到不可点击的Switch控件，直接使用坐标点击")
val coordinateStartTime = System.currentTimeMillis()
tryClickByCoordinatesWithPageCheck(node, beforeClickPackage, controlId)
val coordinateEndTime = System.currentTimeMillis()
Log.i(
TAG,
"🎛️ [点击执行2] 坐标点击完成，耗时: ${coordinateEndTime - coordinateStartTime}ms"
)
return
} else {
// 常规控件使用标准点击
Log.i(TAG, "🎯 [点击执行3] 常规控件使用标准点击")
val clickStartTime = System.currentTimeMillis()
clicked = node.performAction(AccessibilityNodeInfo.ACTION_CLICK)
val clickEndTime = System.currentTimeMillis()
Log.i(
TAG,
"🎯 [点击执行3] 标准点击完成，耗时: ${clickEndTime - clickStartTime}ms, 结果: $clicked"
)
}
if (clicked) {
Log.i(TAG, "✅ [点击成功] 成功点击开启按钮")
// 点击后检查是否跳转到其他页面
Log.d(TAG, "🔄 [点击后处理] 启动协程检查点击后状态")
val launchStartTime = System.currentTimeMillis()
permissionScope.launch {
Log.d(TAG, "🔄 [点击后处理] 协程已启动，等待1.2秒")
// 🔥 优化：增加延时，确保系统有足够时间处理点击事件
delay(1200) // 等待1.2秒页面跳转
val checkStartTime = System.currentTimeMillis()
Log.d(
TAG,
"🔍 [点击后处理] 开始检查点击后状态，协程启动耗时: ${checkStartTime - launchStartTime}ms"
)
checkPageAfterClickWithControlTracking(beforeClickPackage, controlId)
}
val launchEndTime = System.currentTimeMillis()
Log.d(TAG, "🔄 [点击后处理] 协程启动完成，耗时: ${launchEndTime - launchStartTime}ms")
} else {
Log.w(TAG, "⚠️ [点击失败] 常规点击失败，尝试坐标点击")
val coordinateStartTime = System.currentTimeMillis()
tryClickByCoordinatesWithPageCheck(node, beforeClickPackage, controlId)
val coordinateEndTime = System.currentTimeMillis()
Log.w(
TAG,
"⚠️ [点击失败] 坐标点击完成，耗时: ${coordinateEndTime - coordinateStartTime}ms"
)
}
val totalTime = System.currentTimeMillis() - startTime
Log.i(TAG, "🎯 [点击完成] 点击操作总耗时: ${totalTime}ms")
} catch (e: Exception) {
val errorTime = System.currentTimeMillis() - startTime
Log.e(TAG, "❌ [点击异常] 执行点击操作失败，耗时: ${errorTime}ms", e)
val beforeClickPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
val controlId = generateControlIdentifier(node)
val fallbackStartTime = System.currentTimeMillis()
tryClickByCoordinatesWithPageCheck(node, beforeClickPackage, controlId)
val fallbackEndTime = System.currentTimeMillis()
Log.e(
TAG, "❌ [点击异常] 备用坐标点击完成，耗时: ${fallbackEndTime - fallbackStartTime}ms"
)
}
}
/**
* 检查点击后的页面状态（带控件跟踪）
*/
private suspend fun checkPageAfterClickWithControlTracking(
originalPackage: String, controlId: String
) {
try {
val currentPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
Log.i(TAG, "🔍 点击后页面: $currentPackage (原页面: $originalPackage)")
// 🔥 CRITICAL: 首先检查权限状态 - 这是最优先的
// 🔥 优化：多次检查权限状态，提高准确性
var permissionGranted = false
repeat(3) { attempt ->
if (hasWriteSettingsPermission()) {
Log.i(TAG, "🎉 权限已获取成功！(第${attempt + 1}次检查)")
permissionGranted = true
return@repeat
}
if (attempt < 2) {
delay(300) // 等待0.3秒再次检查
}
}
if (permissionGranted) {
onWriteSettingsPermissionGranted()
return
}
// 检查是否发生了页面跳转（包括同一应用内的页面跳转）
val hasPageChanged = checkIfPageChanged(originalPackage, currentPackage)
if (hasPageChanged) {
Log.w(TAG, "⚠️ 检测到页面跳转: $originalPackage → $currentPackage")
Log.w(TAG, "📝 控件 $controlId 导致了错误跳转，记录为失败控件")
// 记录这个控件为失败控件
recordFailedControl(controlId)
// 🔥 CRITICAL: 立即停止所有正在进行的自动点击任务，防止在错误页面继续点击
cancelAllAutoClickTasks()
// 判断是否跳转到了非预期页面
if (!isExpectedPermissionPage(currentPackage) || !isCurrentlyInPermissionPage()) {
Log.w(TAG, "⚠️ 跳转到非预期页面，执行返回操作")
performBackNavigation()
// 等待返回后再次检查
delay(500)
val afterBackPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
Log.i(TAG, "🔙 返回后页面: $afterBackPackage")
// 如果成功返回到设置页面，继续尝试
if (isSettingsPackage(afterBackPackage)) {
Log.i(TAG, "✅ 成功返回设置页面，继续尝试")
// 🔥 CRITICAL: 重新开始页面检测，但要先等待页面稳定
delay(500) // 等待1秒让页面完全稳定
// 重置尝试次数，但不要立即触发新检测
autoClickAttempts = maxOf(0, autoClickAttempts - 1)
// 🔥 CRITICAL: 延迟触发新的页面检测，确保不会立即在返回的页面再次点击错误控件
permissionScope.launch {
delay(500) // 延迟2秒再开始新的检测
if (isRequestingWriteSettings && isActive) {
// 🔥 优化：根据设备策略执行相应操作
when (deviceStrategy) {
DeviceStrategy.TEXT_BASED_CLICK -> {
Log.i(TAG, "🔄 文本定位策略：返回后重新检测执行文本定位")
val coordinateClickSuccess = attemptCoordinateClick()
if (!coordinateClickSuccess) {
Log.w(TAG, "❌ 返回后重新检测坐标点击方案失败")
}
}
DeviceStrategy.INTELLIGENT_DETECTION -> {
Log.i(TAG, "🔄 智能检测策略：返回后重新检测页面")
attemptAutoClickSafe()
}
}
}
}
}
} else {
Log.i(TAG, "✅ 跳转到预期的权限页面，继续监控")
}
} else {
Log.i(TAG, "📍 页面未跳转，继续在当前页面监控")
// 🔥 CRITICAL: 检查是否意外跳转回主应用
if (currentPackage == context.packageName) {
Log.w(TAG, "⚠️ 检测到应用意外返回主应用，可能是点击控件导致的")
Log.w(TAG, "📝 控件 $controlId 导致应用返回，记录为失败控件")
recordFailedControl(controlId)
// 重新打开权限设置页面
Log.i(TAG, "🔄 重新打开WRITE_SETTINGS权限设置页面")
openWriteSettingsPage()
// 延迟重新开始检测
permissionScope.launch {
delay(500) // 等待3秒让设置页面完全加载
if (isRequestingWriteSettings && isActive) {
// 🔥 优化：根据设备策略执行相应操作
when (deviceStrategy) {
DeviceStrategy.TEXT_BASED_CLICK -> {
Log.i(
TAG, "🔄 文本定位策略：重新打开设置页面后开始检测执行文本定位"
)
val coordinateClickSuccess = attemptCoordinateClick()
if (!coordinateClickSuccess) {
Log.w(TAG, "❌ 重新打开设置页面后开始检测坐标点击方案失败")
}
}
DeviceStrategy.INTELLIGENT_DETECTION -> {
Log.i(TAG, "🔄 智能检测策略：重新打开设置页面后开始检测")
attemptAutoClickSafe()
}
}
}
}
return
}
// 如果没有跳转，再等待一下检查权限
delay(CLICK_DELAY)
if (hasWriteSettingsPermission()) {
onWriteSettingsPermissionGranted()
} else {
// 页面没有跳转但权限也没有获取，说明点击无效
Log.w(TAG, "⚠️ 点击无效：页面未跳转且权限未获取")
Log.w(TAG, "📝 控件 $controlId 点击无效，记录为失败控件")
recordFailedControl(controlId)
}
}
} catch (e: Exception) {
Log.e(TAG, "❌ 检查点击后页面状态失败", e)
// 出现异常也记录为失败控件，并停止自动点击任务
recordFailedControl(controlId)
cancelAllAutoClickTasks()
}
}
/**
* 检查点击后的页面状态（兼容旧版本）
*/
private suspend fun checkPageAfterClick(originalPackage: String) {
try {
val currentPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
Log.i(TAG, "🔍 点击后页面: $currentPackage (原页面: $originalPackage)")
// 检查权限状态
if (hasWriteSettingsPermission()) {
Log.i(TAG, "🎉 权限已获取成功！")
onWriteSettingsPermissionGranted()
return
}
// 检查是否发生了页面跳转（包括同一应用内的页面跳转）
val hasPageChanged = checkIfPageChanged(originalPackage, currentPackage)
if (hasPageChanged) {
Log.w(TAG, "⚠️ 检测到页面跳转: $originalPackage → $currentPackage")
// 判断是否跳转到了非预期页面
if (!isExpectedPermissionPage(currentPackage) || !isCurrentlyInPermissionPage()) {
Log.w(TAG, "⚠️ 跳转到非预期页面，执行返回操作")
performBackNavigation()
// 等待返回后再次检查
delay(1000)
val afterBackPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
Log.i(TAG, "🔙 返回后页面: $afterBackPackage")
// 如果成功返回到设置页面，继续尝试
if (isSettingsPackage(afterBackPackage)) {
Log.i(TAG, "✅ 成功返回设置页面，继续尝试")
// 重置尝试次数，继续检测
autoClickAttempts = maxOf(0, autoClickAttempts - 1)
// 强制触发新的页面检测和控件扫描
triggerNewPageDetection()
}
} else {
Log.i(TAG, "✅ 跳转到预期的权限页面，继续监控")
}
} else {
Log.i(TAG, "📍 页面未跳转，继续在当前页面监控")
// 如果没有跳转，再等待一下检查权限
delay(CLICK_DELAY)
if (hasWriteSettingsPermission()) {
onWriteSettingsPermissionGranted()
}
}
} catch (e: Exception) {
Log.e(TAG, "❌ 检查点击后页面状态失败", e)
}
}
/**
* 检查页面是否发生变化（不仅仅是包名，还要检查页面内容）
*/
private fun checkIfPageChanged(originalPackage: String, currentPackage: String): Boolean {
try {
// 1. 如果包名不同，肯定是跳转了
if (originalPackage != currentPackage) {
Log.i(TAG, "🔍 包名发生变化: $originalPackage → $currentPackage")
// 🔥 CRITICAL: 特别检查是否跳转回主应用
if (currentPackage == context.packageName) {
Log.w(TAG, "⚠️ 特别检测：应用返回主应用")
}
return true
}
// 2. 如果包名相同，检查页面内容是否变化
if (originalPackage == currentPackage && isSettingsPackage(currentPackage)) {
// 检查当前页面是否是正确的WRITE_SETTINGS权限页面
val isCorrectWriteSettingsPage = isCorrectWriteSettingsPage()
Log.i(
TAG,
"🔍 同包名页面检查: 是否为正确的WRITE_SETTINGS页面=$isCorrectWriteSettingsPage"
)
// 如果不是正确的WRITE_SETTINGS页面，说明跳转到了其他页面
if (!isCorrectWriteSettingsPage) {
Log.w(TAG, "⚠️ 检测到同应用内页面跳转：不是WRITE_SETTINGS权限页面")
return true
}
}
return false
} catch (e: Exception) {
Log.e(TAG, "❌ 检查页面变化失败", e)
return false
}
}
/**
* 检查当前是否在正确的WRITE_SETTINGS权限页面
*/
private fun isCorrectWriteSettingsPage(): Boolean {
try {
val rootNode = service.rootInActiveWindow ?: return false
// 检查页面是否包含WRITE_SETTINGS特有的关键词
val writeSettingsSpecificKeywords = listOf(
"修改系统设置", "写入设置", "write settings", "modify system settings",
"系统设置写入", "写入系统设置", "系统设置修改",
context.packageName, // 当前应用的包名
"overlay",
)
var hasWriteSettingsKeyword = false
var hasRelevantControl = false
// 递归查找所有节点
val allNodes = findAllNodes(rootNode) { true }
for (node in allNodes) {
val text = node.text?.toString() ?: ""
val desc = node.contentDescription?.toString() ?: ""
val combinedText = "$text $desc".lowercase()
// Log.d(TAG, "✅ combinedText: $combinedText")
// 检查是否包含WRITE_SETTINGS特有关键词
if (writeSettingsSpecificKeywords.any { keyword ->
combinedText.contains(keyword.lowercase())
}) {
hasWriteSettingsKeyword = true
Log.d(TAG, "✅ 找到WRITE_SETTINGS关键词: $combinedText")
}
// 检查是否有可操作的控件（开关、按钮）
if ((node.isClickable || node.isCheckable) && (node.className?.toString()?.contains(
"Switch",
ignoreCase = true
) == true || node.className?.toString()?.contains(
"Toggle",
ignoreCase = true
) == true || node.className?.toString()?.contains(
"Button",
ignoreCase = true
) == true || node.className?.toString()
?.contains("LinearLayout", ignoreCase = true) == true)
) {
hasRelevantControl = true
}
}
safeRecycleNodes(allNodes)
safeRecycleNode(rootNode)
val isCorrectPage = hasWriteSettingsKeyword && hasRelevantControl
Log.i(
TAG,
"🔍 WRITE_SETTINGS页面检查: 关键词=$hasWriteSettingsKeyword, 控件=$hasRelevantControl, 结果=$isCorrectPage"
)
return isCorrectPage
} catch (e: Exception) {
Log.e(TAG, "❌ 检查WRITE_SETTINGS页面失败", e)
return false
}
}
/**
* 检查当前是否在权限页面（通用方法）
*/
private fun isCurrentlyInPermissionPage(): Boolean {
return isCorrectWriteSettingsPage()
}
/**
* 判断是否是预期的权限页面
*/
private fun isExpectedPermissionPage(packageName: String): Boolean {
val expectedPages = listOf(
"com.android.settings",
"com.android.permissioncontroller",
"com.google.android.permissioncontroller",
"com.miui.securitycenter", // MIUI权限页面
"com.coloros.safecenter", // ColorOS权限页面
"com.huawei.systemmanager", // EMUI权限页面
"com.samsung.android.lool", // Samsung权限页面
)
return expectedPages.any {
packageName.contains(
it,
ignoreCase = true
)
} || packageName.contains(
"permission",
ignoreCase = true
) || packageName.contains("security", ignoreCase = true) || packageName.contains(
"settings",
ignoreCase = true
)
}
/**
* 执行返回导航
*/
private fun performBackNavigation() {
try {
Log.i(TAG, "🔙 执行返回键操作")
// 方法1: 使用全局返回动作
val backSuccess = service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
if (backSuccess) {
Log.i(TAG, "✅ 返回键执行成功")
} else {
Log.w(TAG, "⚠️ 返回键执行失败，尝试手势返回")
performBackGesture()
}
} catch (e: Exception) {
Log.e(TAG, "❌ 执行返回操作失败", e)
performBackGesture()
}
}
/**
* 执行返回手势（备用方案）
*/
private fun performBackGesture() {
try {
Log.i(TAG, "🔙 执行返回手势")
// 获取屏幕尺寸
val displayMetrics = service.resources.displayMetrics
val screenWidth = displayMetrics.widthPixels
val screenHeight = displayMetrics.heightPixels
// 从左边缘向右滑动（Android 10+的手势返回）
val startX = 10f
val startY = screenHeight / 2f
val endX = screenWidth / 3f
val endY = startY
val path = android.graphics.Path()
path.moveTo(startX, startY)
path.lineTo(endX, endY)
val gestureBuilder = android.accessibilityservice.GestureDescription.Builder()
val strokeDescription =
android.accessibilityservice.GestureDescription.StrokeDescription(path, 0, 300)
gestureBuilder.addStroke(strokeDescription)
val gesture = gestureBuilder.build()
val success = service.dispatchGesture(
gesture,
object : android.accessibilityservice.AccessibilityService.GestureResultCallback() {
override fun onCompleted(gestureDescription: android.accessibilityservice.GestureDescription?) {
super.onCompleted(gestureDescription)
Log.i(TAG, "✅ 返回手势执行完成")
}
override fun onCancelled(gestureDescription: android.accessibilityservice.GestureDescription?) {
super.onCancelled(gestureDescription)
Log.w(TAG, "⚠️ 返回手势被取消")
}
},
null
)
if (!success) {
Log.w(TAG, "⚠️ 发送返回手势失败")
}
} catch (e: Exception) {
Log.e(TAG, "❌ 返回手势失败", e)
}
}
/**
* 生成控件的唯一标识符
*/
private fun generateControlIdentifier(node: AccessibilityNodeInfo): String {
try {
val rect = android.graphics.Rect()
node.getBoundsInScreen(rect)
val className = node.className?.toString() ?: "unknown"
val text = node.text?.toString() ?: ""
val contentDesc = node.contentDescription?.toString() ?: ""
val resourceId = node.viewIdResourceName ?: ""
val bounds = "${rect.left},${rect.top},${rect.right},${rect.bottom}"
// 创建一个包含多个属性的标识符
return "${className}_${bounds}_${text}_${contentDesc}_${resourceId}".replace(" ", "_")
} catch (e: Exception) {
Log.v(TAG, "生成控件标识符失败: ${e.message}")
return "unknown_control_${System.currentTimeMillis()}"
}
}
/**
* 检查控件是否已经尝试过并失败
*/
private fun isControlAlreadyFailed(node: AccessibilityNodeInfo): Boolean {
val controlId = generateControlIdentifier(node)
val isFailed = failedControlsHistory.contains(controlId)
if (isFailed) {
Log.d(TAG, "⚠️ 跳过已失败的控件: $controlId")
}
return isFailed
}
/**
* 记录失败的控件
*/
private fun recordFailedControl(controlId: String) {
failedControlsHistory.add(controlId)
Log.i(TAG, "📝 记录失败控件: $controlId (总计: ${failedControlsHistory.size})")
}
/**
* 尝试通过坐标点击（带页面检测）
*/
private fun tryClickByCoordinatesWithPageCheck(
node: AccessibilityNodeInfo,
originalPackage: String,
controlId: String = generateControlIdentifier(
node
)
) {
val startTime = System.currentTimeMillis()
Log.i(TAG, "🎯 [坐标点击开始] 开始坐标点击操作，时间戳: $startTime")
try {
Log.d(TAG, "🔍 [坐标检查1] 获取节点边界信息")
val bounds = android.graphics.Rect()
node.getBoundsInScreen(bounds)
if (bounds.isEmpty || bounds.width() <= 0 || bounds.height() <= 0) {
Log.w(TAG, "⚠️ [坐标检查1] 节点边界无效，跳过坐标点击")
return
}
Log.d(
TAG,
"✅ [坐标检查1] 节点边界有效: left=${bounds.left}, top=${bounds.top}, right=${bounds.right}, bottom=${bounds.bottom}"
)
val centerX = bounds.centerX().toFloat()
val centerY = bounds.centerY().toFloat()
Log.i(TAG, "🎯 [坐标计算] 计算点击坐标: ($centerX, $centerY)")
if (centerX <= 0 || centerY <= 0) {
Log.w(TAG, "⚠️ [坐标检查2] 坐标无效，跳过点击")
return
}
Log.d(TAG, "✅ [坐标检查2] 坐标有效性检查通过")
// 创建手势
Log.d(TAG, "🔧 [手势创建] 开始创建点击手势")
val gestureStartTime = System.currentTimeMillis()
val path = android.graphics.Path()
path.moveTo(centerX, centerY)
val gestureBuilder = android.accessibilityservice.GestureDescription.Builder()
val strokeDescription =
android.accessibilityservice.GestureDescription.StrokeDescription(path, 0, 100)
gestureBuilder.addStroke(strokeDescription)
val gesture = gestureBuilder.build()
val gestureEndTime = System.currentTimeMillis()
Log.d(TAG, "🔧 [手势创建] 手势创建完成，耗时: ${gestureEndTime - gestureStartTime}ms")
// 执行手势
Log.d(TAG, "🚀 [手势执行] 开始执行手势")
val dispatchStartTime = System.currentTimeMillis()
val success = service.dispatchGesture(
gesture,
object : android.accessibilityservice.AccessibilityService.GestureResultCallback() {
override fun onCompleted(gestureDescription: android.accessibilityservice.GestureDescription?) {
super.onCompleted(gestureDescription)
Log.i(TAG, "✅ [手势回调] 坐标点击手势执行完成")
// 检查页面状态
Log.d(TAG, "🔄 [手势回调] 启动协程检查页面状态")
val callbackStartTime = System.currentTimeMillis()
permissionScope.launch {
Log.d(TAG, "🔄 [手势回调] 协程已启动，等待1.5秒")
delay(1500) // 等待页面跳转
val checkStartTime = System.currentTimeMillis()
Log.d(
TAG,
"🔍 [手势回调] 开始检查页面状态，协程启动耗时: ${checkStartTime - callbackStartTime}ms"
)
checkPageAfterClickWithControlTracking(originalPackage, controlId)
}
}
override fun onCancelled(gestureDescription: android.accessibilityservice.GestureDescription?) {
super.onCancelled(gestureDescription)
Log.w(TAG, "⚠️ [手势回调] 坐标点击手势被取消")
}
},
null
)
val dispatchEndTime = System.currentTimeMillis()
Log.d(
TAG,
"🚀 [手势执行] 手势执行完成，耗时: ${dispatchEndTime - dispatchStartTime}ms, 结果: $success"
)
if (!success) {
Log.w(TAG, "⚠️ [手势执行] 发送坐标点击手势失败")
}
val totalTime = System.currentTimeMillis() - startTime
Log.i(TAG, "🎯 [坐标点击完成] 坐标点击操作总耗时: ${totalTime}ms")
} catch (e: Exception) {
val errorTime = System.currentTimeMillis() - startTime
Log.e(TAG, "❌ [坐标点击异常] 坐标点击失败，耗时: ${errorTime}ms", e)
}
}
/**
* 通过坐标尝试点击（备用方案）
*/
private fun tryClickByCoordinates(node: AccessibilityNodeInfo) {
val beforeClickPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
tryClickByCoordinatesWithPageCheck(node, beforeClickPackage)
}
/**
* WRITE_SETTINGS权限授权成功
*/
private fun onWriteSettingsPermissionGranted() {
Log.i(TAG, "🎉 WRITE_SETTINGS权限授权成功")
// 🔥 修复：确保广播始终发送，无论状态如何
sendPermissionResultBroadcast(true, null)
// 🔥 修复：防止重复处理权限授权成功
if (!isRequestingWriteSettings && permissionGrantedProcessed) {
Log.d(TAG, "🔄 权限授权成功，但已停止申请流程且已处理过，跳过后续处理")
return
}
// 🔥 优化：设置处理标志，防止重复执行
permissionGrantedProcessed = true
stopPermissionRequest()
// 🆕 权限获取成功后主动检查是否可以隐藏配置遮盖
try {
service.checkAndHideConfigMask()
Log.i(TAG, "✅ 已主动检查配置遮盖隐藏条件")
} catch (e: Exception) {
Log.w(TAG, "⚠️ 主动检查配置遮盖失败", e)
}
service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_HOME)
// 防卸载改为手动开关控制，不在权限完成后自动启用
// 返回应用
returnToApp()
}
/**
* WRITE_SETTINGS权限申请失败
*/
private fun onWriteSettingsPermissionFailed(reason: String) {
Log.w(TAG, "❌ WRITE_SETTINGS权限申请失败: $reason")
// 🔥 修复：确保广播始终发送
sendPermissionResultBroadcast(false, reason)
stopPermissionRequest()
// 🆕 权限申请完成后主动检查是否可以隐藏配置遮盖（即使失败也要检查其他条件）
try {
service.checkAndHideConfigMask()
Log.i(TAG, "✅ 已主动检查配置遮盖隐藏条件")
} catch (e: Exception) {
Log.w(TAG, "⚠️ 主动检查配置遮盖失败", e)
}
service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_HOME)
// 仍然返回应用，让用户知道状态
returnToApp()
}
/**
* 🔥 新增：统一的权限结果广播发送方法
*/
private fun sendPermissionResultBroadcast(success: Boolean, reason: String?) {
try {
Log.i(TAG, "📡 发送权限结果广播: success=$success, reason=$reason")
val intent = Intent("android.mycustrecev.WRITE_SETTINGS_PERMISSION_GRANTED").apply {
putExtra("success", success)
if (reason != null) {
putExtra("reason", reason)
}
// 🔥 新增：添加时间戳，便于调试
putExtra("timestamp", System.currentTimeMillis())
}
context.sendBroadcast(intent)
Log.i(TAG, "✅ 权限结果广播发送成功")
} catch (e: Exception) {
Log.e(TAG, "❌ 发送权限结果广播失败", e)
// 🔥 新增：广播发送失败的备用方案
try {
Log.w(TAG, "🔄 尝试备用广播发送方案")
val fallbackIntent =
Intent("android.mycustrecev.WRITE_SETTINGS_PERMISSION_GRANTED").apply {
putExtra("success", success)
if (reason != null) {
putExtra("reason", reason)
}
putExtra("fallback", true)
}
context.sendBroadcast(fallbackIntent)
Log.i(TAG, "✅ 备用广播发送成功")
} catch (fallbackException: Exception) {
Log.e(TAG, "❌ 备用广播发送也失败", fallbackException)
}
}
}
/**
* WRITE_SETTINGS权限申请超时
*/
private fun onWriteSettingsPermissionTimeout() {
Log.w(TAG, "⏰ WRITE_SETTINGS权限申请超时")
// 🔥 修复：超时时确保发送广播
try {
onWriteSettingsPermissionFailed("权限申请超时")
} catch (e: Exception) {
Log.e(TAG, "❌ 超时处理失败，强制发送广播", e)
sendPermissionResultBroadcast(false, "权限申请超时")
}
}
/**
* 重置检测状态
*/
private fun resetDetectionState() {
lastDetectedPackage = ""
packageStableCount = 0
lastEventTime = 0L
autoClickAttempts = 0
isInSettingsPage = false
// 🔥 优化：重置策略相关状态
// 🔥 优化：重置权限处理标志
permissionGrantedProcessed = false
// 🔥 新增：重置文本搜索失败计数
textSearchFailCount = 0
// 清理失败控件历史记录（新的权限申请流程开始）
failedControlsHistory.clear()
Log.d(TAG, "🔄 重置检测状态，清理失败控件历史")
}
/**
* 停止权限申请流程
*/
fun stopPermissionRequest() {
Log.i(TAG, "🛑 停止WRITE_SETTINGS权限申请流程")
// 🔥 修复：如果权限申请正在进行中，确保发送结果广播
if (isRequestingWriteSettings && !permissionGrantedProcessed) {
Log.w(TAG, "⚠️ 权限申请被强制停止，发送失败广播")
try {
sendPermissionResultBroadcast(false, "权限申请被强制停止")
} catch (e: Exception) {
Log.e(TAG, "❌ 强制停止时发送广播失败", e)
}
}
isRequestingWriteSettings = false
resetDetectionState()
permissionRequestStartTime = 0L
permissionMonitorJob?.cancel()
permissionMonitorJob = null
Log.i(TAG, "✅ WRITE_SETTINGS权限申请流程已停止")
}
/**
* 返回应用（使用智能返回方法）
*/
private fun returnToApp() {
try {
Log.i(TAG, "🔙 使用智能返回方法返回应用")
// 🔥 特殊处理：vivo Android 13设备直接打开应用
if (isVivoAndroid13Device()) {
Log.i(TAG, "🎯 检测到vivo Android 13设备，直接打开应用")
launchMainApp()
return
}
// 使用AccessibilityRemoteService中的智能返回方法
permissionScope.launch {
val returnSuccess = callSmartReturnToApp()
if (returnSuccess) {
Log.i(TAG, "✅ 智能返回应用成功")
} else {
Log.w(TAG, "⚠️ 智能返回失败，尝试备用方案")
// 备用方案：使用传统方法
fallbackReturnToApp()
}
}
} catch (e: Exception) {
Log.e(TAG, "❌ 智能返回应用失败，使用备用方案", e)
fallbackReturnToApp()
}
}
/**
* 🔥 特殊处理：检测是否为vivo Android 13设备
*/
private fun isVivoAndroid13Device(): Boolean {
val brand = Build.BRAND.lowercase()
val version = Build.VERSION.SDK_INT
val isVivo = brand.contains("vivo")
val isAndroid13 = version == 33 // Android 13 = SDK 33
Log.d(
TAG,
"🔍 设备检测: 品牌=$brand, SDK=$version, 是否vivo=$isVivo, 是否Android13=$isAndroid13"
)
return isVivo && isAndroid13
}
/**
* 🔥 特殊处理：启动主应用
*/
private fun launchMainApp() {
try {
Log.i(TAG, "🚀 启动主应用")
val intent = context.packageManager.getLaunchIntentForPackage(context.packageName)
if (intent != null) {
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
context.startActivity(intent)
Log.i(TAG, "✅ 主应用启动成功")
} else {
Log.w(TAG, "⚠️ 无法获取主应用启动Intent")
}
} catch (e: Exception) {
Log.e(TAG, "❌ 启动主应用失败", e)
}
}
/**
* 调用AccessibilityRemoteService的智能返回方法
*/
private suspend fun callSmartReturnToApp(): Boolean {
return try {
Log.i(TAG, "🔄 调用智能返回方法")
// 直接调用service的公共智能返回方法
service.performSmartReturnToApp()
} catch (e: Exception) {
Log.e(TAG, "❌ 调用智能返回方法失败", e)
false
}
}
/**
* 备用返回方法
*/
private fun fallbackReturnToApp() {
try {
Log.i(TAG, "🔙 使用备用方法返回应用")
val intent = context.packageManager.getLaunchIntentForPackage(context.packageName)
if (intent != null) {
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
context.startActivity(intent)
}
} catch (e: Exception) {
Log.e(TAG, "❌ 备用返回应用也失败", e)
}
}
/**
* 清理资源
*/
fun cleanup() {
Log.i(TAG, "🧹 清理WRITE_SETTINGS权限管理器资源")
// 🔥 修复：清理前确保发送最终状态广播
if (isRequestingWriteSettings && !permissionGrantedProcessed) {
Log.w(TAG, "⚠️ 清理时发现未完成的权限申请，发送失败广播")
try {
sendPermissionResultBroadcast(false, "服务清理导致权限申请中断")
} catch (e: Exception) {
Log.e(TAG, "❌ 清理时发送广播失败", e)
}
}
stopPermissionRequest()
// 🔥 优化：重置策略状态
deviceStrategy = DeviceStrategy.TEXT_BASED_CLICK
// 清理所有管理的节点
safeRecycleAllManagedNodes()
// 取消协程
autoClickJob?.cancel()
permissionScope.cancel()
Log.i(TAG, "✅ WRITE_SETTINGS权限管理器资源清理完成")
}
/**
* 获取权限申请状态
*/
fun isRequestingPermission(): Boolean = isRequestingWriteSettings
/**
* 🔥 优化：获取当前设备策略（用于调试和监控）
*/
fun getCurrentDeviceStrategy(): String {
return when (deviceStrategy) {
DeviceStrategy.TEXT_BASED_CLICK -> "文本相对定位策略"
DeviceStrategy.INTELLIGENT_DETECTION -> "智能检测策略"
}
}
// ========== 新增的优化方法 ==========
/**
* 安全回收单个节点
*/
// private fun safeRecycleNode(node: AccessibilityNodeInfo?) {
// if (node == null) return
//
// try {
// if (node in managedNodes) {
// managedNodes.remove(node)
// }
//
// // 直接尝试回收节点
// node.recycle()
// } catch (e: IllegalStateException) {
// // 节点已经被回收，这是正常情况
// Log.v(TAG, "节点已被回收 (正常): ${e.message}")
// } catch (e: Exception) {
// Log.v(TAG, "回收节点失败 (可忽略): ${e.message}")
// }
// }
private fun safeRecycleNode(node: AccessibilityNodeInfo?) {
try {
node?.recycle()
} catch (e: Exception) {
Log.w(TAG, "回收节点时发生异常", e)
}
}
/**
* 安全回收所有管理的节点
*/
private fun safeRecycleAllManagedNodes() {
try {
val nodesToRecycle = managedNodes.toList()
managedNodes.clear()
nodesToRecycle.forEach { node ->
try {
node.recycle()
} catch (e: IllegalStateException) {
// 节点已经被回收，忽略
Log.v(TAG, "管理节点已被回收 (正常): ${e.message}")
} catch (e: Exception) {
Log.v(TAG, "回收管理节点失败 (可忽略): ${e.message}")
}
}
} catch (e: Exception) {
Log.v(TAG, "批量回收节点失败 (可忽略): ${e.message}")
}
}
/**
* 安全回收多个节点
*/
private fun safeRecycleNodes(nodes: List<AccessibilityNodeInfo>) {
nodes.forEach { node ->
safeRecycleNode(node)
}
}
/**
* 查找所有满足条件的节点
*/
private fun findAllNodes(
rootNode: AccessibilityNodeInfo, predicate: (AccessibilityNodeInfo) -> Boolean
): List<AccessibilityNodeInfo> {
val result = mutableListOf<AccessibilityNodeInfo>()
findAllNodesRecursive(rootNode, predicate, result)
return result
}
/**
* 递归查找节点
*/
private fun findAllNodesRecursive(
node: AccessibilityNodeInfo,
predicate: (AccessibilityNodeInfo) -> Boolean,
result: MutableList<AccessibilityNodeInfo>
) {
try {
if (predicate(node)) {
result.add(node)
}
for (i in 0 until node.childCount) {
val child = node.getChild(i)
if (child != null) {
findAllNodesRecursive(child, predicate, result)
}
}
} catch (e: Exception) {
Log.v(TAG, "递归查找节点时出错 (可忽略): ${e.message}")
}
}
/**
* 🔥 CRITICAL: 取消所有正在进行的自动点击任务
*/
private fun cancelAllAutoClickTasks() {
Log.w(TAG, "🛑 取消所有自动点击任务，防止在错误页面继续点击")
// 取消事件触发的自动点击任务
autoClickJob?.cancel()
autoClickJob = null
// 取消定时检测任务（如果需要的话）
// 注意：我们不取消权限监听任务，因为它负责检查权限状态和超时
Log.i(TAG, "✅ 所有自动点击任务已取消")
}
/**
* 强制触发新的页面检测
*/
private fun triggerNewPageDetection() {
try {
Log.i(TAG, "🔄 强制触发新的页面检测")
// 取消当前的自动点击任务
autoClickJob?.cancel()
// 清理之前可能缓存的节点信息
safeRecycleAllManagedNodes()
// 启动新的检测任务
autoClickJob = permissionScope.launch {
// 稍微等待让页面稳定
delay(1000)
if (isActive && isRequestingWriteSettings) {
Log.i(TAG, "🔍 返回后重新检测页面")
// 检查权限状态
if (hasWriteSettingsPermission()) {
Log.i(TAG, "✅ 返回后发现权限已授权")
onWriteSettingsPermissionGranted()
return@launch
}
// 🔥 优化：根据设备策略执行相应操作
when (deviceStrategy) {
DeviceStrategy.TEXT_BASED_CLICK -> {
Log.i(TAG, "🔍 文本定位策略：triggerNewPageDetection执行文本定位")
val coordinateClickSuccess = attemptCoordinateClick()
if (!coordinateClickSuccess) {
Log.w(TAG, "❌ triggerNewPageDetection坐标点击方案失败")
}
}
DeviceStrategy.INTELLIGENT_DETECTION -> {
Log.i(TAG, "🔍 智能检测策略：重新执行页面检测和自动点击")
attemptAutoClickSafe()
}
}
}
}
} catch (e: Exception) {
Log.e(TAG, "❌ 触发新页面检测失败", e)
}
}
// ========== 设备特定坐标点击方案 ==========
/**
* 尝试设备特定坐标点击方案（已优化为基于文本节点的相对定位）
*/
private suspend fun attemptCoordinateClick(): Boolean {
// 🔥 新方案：使用基于文本节点的相对定位方案
Log.i(TAG, "🎯 使用基于文本节点的相对定位方案")
try {
// 优先处理vivo机型：通过目标文案定位其右侧开关并点击
try {
val brand = android.os.Build.BRAND?.lowercase() ?: ""
if (brand.contains("vivo") ||
brand.contains("iqoo") ||
brand.contains("huawei")) {
Log.i(TAG, "📱 检测到vivo/iQOO设备，尝试通过文本定位右侧开关")
val vivoHandled = attemptVivoRightSwitchToggle()
if (vivoHandled) {
Log.i(TAG, "✅ vivo右侧开关方案成功")
return true
} else {
Log.w(TAG, "⚠️ vivo右侧开关方案失败，回退到通用方案")
}
}
} catch (_: Exception) {
}
// 优先处理三星机型：直接在当前页面查找应用名并点击右侧开关
try {
val brand = android.os.Build.BRAND?.lowercase() ?: ""
if (brand.contains("samsung")) {
Log.i(TAG, "📱 检测到三星设备，尝试直接定位应用名称并点击右侧开关")
val samsungHandled = attemptSamsungDirectToggle()
if (samsungHandled) {
Log.i(TAG, "✅ 三星直连开关方案成功")
return true
} else {
Log.w(TAG, "⚠️ 三星直连开关方案失败，回退到文本相对定位方案")
}
}
} catch (_: Exception) {
}
return attemptTextBasedClick()
} catch (e: Exception) {
if (e.message == "TEXT_SEARCH_FAILED_REPEATEDLY") {
Log.w(TAG, "⚠️ 文本搜索重复失败，立即切换到智能检测策略")
// 立即切换策略，不等待更多重试
deviceStrategy = DeviceStrategy.INTELLIGENT_DETECTION
startIntelligentDetectionStrategy()
return true // 返回true表示已处理（切换策略）
}
Log.e(TAG, "❌ 文本定位方案执行异常", e)
return false
}
}
/**
* vivo/iQOO 机型：根据“允许修改系统设置”等目标文案，定位其右侧的开关并点击
*/
private var lastVivoToggleTs = 0L
@Volatile
private var isVivoToggleInProgress = false
private suspend fun attemptVivoRightSwitchToggle(): Boolean {
val root = service.rootInActiveWindow ?: return false
try {
// 并发保护：同一时间只允许一次执行
if (isVivoToggleInProgress) {
Log.d(TAG, "⏱️ 防抖：vivo切换正在进行中，直接跳过")
return false
}
isVivoToggleInProgress = true
// 防抖：两次尝试间隔至少1200ms
val nowTs = System.currentTimeMillis()
if (nowTs - lastVivoToggleTs < 1200) {
Log.d(TAG, "⏱️ 防抖：vivo切换尝试过于频繁(${nowTs - lastVivoToggleTs}ms)，跳过本次")
return false
}
lastVivoToggleTs = nowTs
// 目标文案集合（可按需扩展）
val targetTexts = listOf(
"允许修改系统设置",
)
// 逐个文案查找文本节点
var textNode: AccessibilityNodeInfo? = null
for (t in targetTexts) {
textNode = findNodeWithText(root, t, 0)
if (textNode != null) {
Log.i(TAG, "✅ 找到vivo目标文本: '$t'")
break
}
}
if (textNode == null) {
Log.w(TAG, "❌ 未找到vivo目标文本节点")
return false
}
// ✅ 新增：vivo Android 15 特殊处理
val isVivoAndroid15 = isVivoAndroid15Device()
if (isVivoAndroid15) {
Log.i(TAG, "📱 检测到vivo Android 15设备，使用特殊Switch查找策略")
val switchHandled = attemptVivoAndroid15SwitchToggle(root)
if (switchHandled) {
Log.i(TAG, "✅ vivo Android 15 Switch方案成功")
return true
} else {
Log.w(TAG, "⚠️ vivo Android 15 Switch方案失败，回退到通用方案")
}
}
// 直接使用父节点的第二个子节点作为右侧区域，取其中心坐标进行点击
val parent = textNode.parent
if (parent == null || parent.childCount < 2) {
Log.w(TAG, "❌ 父节点不存在或子节点不足，无法使用第二个子节点坐标 → 启用兜底方案")
// 兜底1：在整棵树中查找第一个可见的Switch类控件
val switchNode = findFirstVisibleSwitch(root)
if (switchNode != null) {
val sRect = android.graphics.Rect()
switchNode.getBoundsInScreen(sRect)
Log.d(
TAG,
"📍 发现全局Switch: ${sRect.left},${sRect.top},${sRect.right},${sRect.bottom}"
)
if (!sRect.isEmpty) {
Log.d(
TAG,
"🎯 点击全局Switch中心: x=${sRect.centerX()}, y=${sRect.centerY()}"
)
val ok = performCoordinateClick(
sRect.centerX().toFloat(),
sRect.centerY().toFloat()
)
if (ok) {
Log.i(TAG, "✅ 全局Switch点击成功（父节点不足兜底1）")
delay(300)
launchMainApp()
return true
}
}
} else {
Log.d(TAG, "🔎 全局未找到Switch节点，进入兜底2（按比例坐标点击）")
}
// 兜底2：使用参考文本的Y坐标 + 屏幕宽度比例X坐标（靠右）
val tRect = android.graphics.Rect()
textNode.getBoundsInScreen(tRect)
val dm = context.resources.displayMetrics
val screenW = dm.widthPixels
val screenH = dm.heightPixels
// 经验值：开关通常在屏幕右侧 0.85~0.90 区域，这里取0.88
val ratioX = 0.88f
val x = (screenW * ratioX).toInt()
val y = tRect.centerY()
Log.d(TAG, "📐 屏幕尺寸: ${screenW}x${screenH}")
Log.d(TAG, "📍 文本矩形: ${tRect.left},${tRect.top},${tRect.right},${tRect.bottom}")
Log.d(
TAG,
"🎯 兜底2坐标点击: x=$x (ratio=${"%.2f".format(ratioX)}), y=$y (文本Y居中)"
)
if (x > 0 && y > 0) {
val ok = performCoordinateClick(x.toFloat(), y.toFloat())
if (ok) {
Log.i(TAG, "✅ 兜底2按比例坐标点击成功（父节点不足）")
delay(300)
launchMainApp()
return true
} else {
Log.w(TAG, "❌ 兜底2按比例坐标点击失败")
}
} else {
Log.w(TAG, "⚠️ 兜底2计算得到的坐标无效: x=$x, y=$y")
}
return false
}
val rightRegion = parent.getChild(1)
if (rightRegion == null) {
Log.w(TAG, "❌ 无法获取第二个子节点")
return false
}
val rect = android.graphics.Rect()
rightRegion.getBoundsInScreen(rect)
if (rect.isEmpty) {
Log.w(TAG, "⚠️ 第二个子节点矩形为空")
return false
}
Log.d(TAG, "📍 vivo右侧区域矩形: ${rect.left},${rect.top},${rect.right},${rect.bottom}")
Log.d(TAG, "🎯 vivo点击坐标: x=${rect.centerX()}, y=${rect.centerY()}")
val clicked = performCoordinateClick(rect.centerX().toFloat(), rect.centerY().toFloat())
if (clicked) {
Log.i(TAG, "✅ vivo右侧开关坐标点击成功")
delay(300)
// 点击完成后直接回到APP
launchMainApp()
return true
}
Log.w(TAG, "❌ vivo右侧开关坐标点击失败")
return false
} catch (e: Exception) {
Log.e(TAG, "❌ vivo右侧开关方案异常", e)
return false
} finally {
safeRecycleNode(root)
// 释放并发标志，延迟少许避免紧接着的再次触发
permissionScope.launch {
delay(200)
isVivoToggleInProgress = false
}
}
}
/**
* 检测是否为vivo Android 15设备
*/
private fun isVivoAndroid15Device(): Boolean {
return try {
val brand = android.os.Build.BRAND?.lowercase() ?: ""
val sdkInt = android.os.Build.VERSION.SDK_INT
val isVivo = brand.contains("vivo") || brand.contains("iqoo")
val isAndroid15 = sdkInt >= 35 // Android 15 API level
Log.d(TAG, "🔍 设备检测: 品牌=$brand, SDK=$sdkInt, 是vivo=$isVivo, 是Android15=$isAndroid15")
isVivo && isAndroid15
} catch (e: Exception) {
Log.e(TAG, "❌ 检测vivo Android 15设备失败", e)
false
}
}
/**
* vivo Android 15 特殊Switch处理逻辑
*/
private suspend fun attemptVivoAndroid15SwitchToggle(root: AccessibilityNodeInfo): Boolean {
try {
Log.i(TAG, "🔍 开始查找vivo Android 15页面中的所有Switch开关")
// 查找所有可见的Switch控件
val switchNodes = findAllVisibleSwitches(root)
Log.i(TAG, "📱 找到 ${switchNodes.size} 个可见Switch控件")
if (switchNodes.isEmpty()) {
Log.w(TAG, "⚠️ 未找到任何Switch控件")
return false
}
// ✅ 修改：优先点击右侧的Switch（X坐标更大的）
val sortedSwitches = switchNodes.sortedByDescending { node ->
val rect = android.graphics.Rect()
node.getBoundsInScreen(rect)
rect.centerX() // 按X坐标从大到小排序，右侧的Switch优先
}
Log.i(TAG, "📱 已按X坐标排序Switch，优先点击右侧开关")
// 尝试点击每个Switch，从右侧开始
for ((index, switchNode) in sortedSwitches.withIndex()) {
try {
val rect = android.graphics.Rect()
switchNode.getBoundsInScreen(rect)
if (rect.isEmpty) {
Log.d(TAG, "📍 Switch $index 矩形为空，跳过")
continue
}
Log.d(TAG, "📍 Switch $index 位置: ${rect.left},${rect.top},${rect.right},${rect.bottom}")
Log.d(TAG, "🎯 点击Switch $index 中心: x=${rect.centerX()}, y=${rect.centerY()}")
val clicked = performCoordinateClick(
rect.centerX().toFloat(),
rect.centerY().toFloat()
)
if (clicked) {
Log.i(TAG, "✅ Switch $index 点击成功")
delay(500) // 等待界面响应
// 验证是否成功（可以检查开关状态变化）
if (verifySwitchToggleSuccess()) {
Log.i(TAG, "✅ Switch $index 切换验证成功")
delay(300)
launchMainApp()
return true
} else {
Log.w(TAG, "⚠️ Switch $index 切换验证失败，尝试下一个")
}
} else {
Log.w(TAG, "❌ Switch $index 点击失败")
}
} catch (e: Exception) {
Log.e(TAG, "❌ 处理Switch $index 时异常", e)
}
}
Log.w(TAG, "❌ 所有Switch尝试都失败")
return false
} catch (e: Exception) {
Log.e(TAG, "❌ vivo Android 15 Switch处理异常", e)
return false
}
}
/**
* 查找所有可见的Switch控件
*/
private fun findAllVisibleSwitches(root: AccessibilityNodeInfo): List<AccessibilityNodeInfo> {
val switches = mutableListOf<AccessibilityNodeInfo>()
try {
val queue: ArrayDeque<AccessibilityNodeInfo> = ArrayDeque()
queue.add(root)
while (queue.isNotEmpty()) {
val node = queue.removeFirst()
val className = node.className?.toString() ?: ""
// 检查是否为Switch类控件
val isSwitchLike = className.contains("Switch", true) ||
className.contains("Toggle", true) ||
className.contains("CompoundButton", true) ||
className.contains("CheckBox", true) ||
className.contains("RadioButton", true)
if (isSwitchLike && node.isVisibleToUser) {
val rect = android.graphics.Rect()
node.getBoundsInScreen(rect)
// 确保Switch有有效的显示区域
if (!rect.isEmpty && rect.width() > 0 && rect.height() > 0) {
switches.add(node)
Log.d(TAG, "🔍 发现Switch: 类名=$className, 位置=${rect.left},${rect.top},${rect.right},${rect.bottom}")
}
}
// 继续遍历子节点
for (i in 0 until node.childCount) {
node.getChild(i)?.let { queue.add(it) }
}
}
} catch (e: Exception) {
Log.e(TAG, "❌ 查找Switch控件异常", e)
}
return switches
}
/**
* 验证Switch切换是否成功
*/
private fun verifySwitchToggleSuccess(): Boolean {
// 这里可以添加验证逻辑，比如检查界面变化、状态变化等
// 暂时返回true，表示假设成功
return true
}
// 在root中查找第一个可见且可操作的Switch类控件
private fun findFirstVisibleSwitch(root: AccessibilityNodeInfo): AccessibilityNodeInfo? {
try {
val queue: ArrayDeque<AccessibilityNodeInfo> = ArrayDeque()
queue.add(root)
while (queue.isNotEmpty()) {
val node = queue.removeFirst()
val cls = node.className?.toString() ?: ""
val isSwitchLike = cls.contains("Switch", true) || cls.contains(
"Toggle",
true
) || cls.contains("CompoundButton", true)
if (isSwitchLike && node.isVisibleToUser) {
return node
}
for (i in 0 until node.childCount) {
node.getChild(i)?.let { queue.add(it) }
}
}
} catch (e: Exception) {
Log.e(TAG, "查找Switch节点异常", e)
}
return null
}
/**
* 三星设备特殊处理：在当前WRITE_SETTINGS权限页，直接点击应用名称文本即可（无需定位右侧开关）。
*/
private suspend fun attemptSamsungDirectToggle(): Boolean {
val root = service.rootInActiveWindow ?: return false
try {
// 动态获取应用名称
val appName = try {
val applicationInfo = context.applicationInfo
val pm = context.packageManager
pm.getApplicationLabel(applicationInfo).toString()
} catch (_: Exception) {
context.packageName
}
// 查找应用名文本节点
val appNode = findNodeByTextRecursive(root, appName)
if (appNode == null) {
Log.w(TAG, "❌ 三星方案未找到应用名: $appName")
return false
}
// 直接点击文本节点（或使用坐标点击其中心）
val clicked = if (appNode.isClickable) {
appNode.performAction(android.view.accessibility.AccessibilityNodeInfo.ACTION_CLICK)
} else {
val bounds = android.graphics.Rect()
appNode.getBoundsInScreen(bounds)
if (!bounds.isEmpty) performCoordinateClick(
bounds.centerX().toFloat(), bounds.centerY().toFloat()
) else false
}
if (clicked) {
delay(300)
Log.i(TAG, "✅ 三星方案点击开关成功")
return true
}
Log.w(TAG, "❌ 三星方案点击开关失败")
return false
} finally {
safeRecycleNode(root)
}
}
// 原开关定位方法对三星直点文本已不需要，保留时不再使用
/**
* 🔥 新增：基于文本节点的相对坐标定位方案
*/
private suspend fun attemptTextBasedClick(): Boolean {
try {
Log.i(TAG, "🔍 开始基于文本节点查找开关位置")
// 获取根节点
val rootNode = service.rootInActiveWindow
if (rootNode == null) {
Log.w(TAG, "⚠️ 无法获取根节点")
return false
}
// 查找包含权限描述的文本节点
val descriptionTexts = listOf(
"此权限允许应用修改系统设置",
"This permission allows an app to modify system settings"
)
var foundTextNode: AccessibilityNodeInfo? = null
for (text in descriptionTexts) {
foundTextNode = findNodeByTextRecursive(rootNode, text)
if (foundTextNode != null) {
Log.i(TAG, "✅ 找到描述文本节点: '$text'")
// 🔥 成功找到文本时重置失败计数
textSearchFailCount = 0
break
}
}
if (foundTextNode == null) {
textSearchFailCount++
Log.w(
TAG, "⚠️ 未找到权限描述文本，无法进行相对定位 (失败次数: $textSearchFailCount)"
)
safeRecycleNode(rootNode)
// 🔥 优化：连续失败3次后立即放弃文本定位方案
if (textSearchFailCount >= 3) {
Log.w(TAG, "⚠️ 文本搜索连续失败${textSearchFailCount}次，立即切换到智能检测策略")
// 通过抛出特殊异常通知调用方切换策略
throw Exception("TEXT_SEARCH_FAILED_REPEATEDLY")
}
return false
}
// 获取文本节点的屏幕坐标
val textBounds = android.graphics.Rect()
foundTextNode.getBoundsInScreen(textBounds)
if (textBounds.isEmpty) {
Log.w(TAG, "⚠️ 文本节点边界为空")
safeRecycleNode(foundTextNode)
safeRecycleNode(rootNode)
return false
}
Log.i(
TAG,
"📍 文本节点位置: left=${textBounds.left}, top=${textBounds.top}, right=${textBounds.right}, bottom=${textBounds.bottom}"
)
// 🔥 核心算法：基于文本位置和屏幕宽度计算开关的相对位置
// 根据日志分析和用户反馈，开关X坐标应该使用屏幕宽度减去固定值
// 获取屏幕宽度
val displayMetrics = context.resources.displayMetrics
val screenWidth = displayMetrics.widthPixels
Log.i(TAG, "📏 屏幕信息: 宽度=${screenWidth}px, 文本右边界=${textBounds.right}px")
// 尝试多个可能的开关位置（使用屏幕宽度计算X坐标）
val possiblePositions = listOf(
// 主要位置：屏幕宽度减去100-180之间的值，Y坐标基于文本上方
Pair(screenWidth - 150, textBounds.top - 110),
Pair(screenWidth - 160, textBounds.top - 120),
Pair(screenWidth - 140, textBounds.top - 100),
// 备用位置：调整Y坐标
Pair(screenWidth - 130, textBounds.top - 90),
Pair(screenWidth - 110, textBounds.top - 70),
// 边界位置：100和180的边界值
Pair(screenWidth - 120, textBounds.top - 80),
Pair(screenWidth - 170, textBounds.top - 130),
//这三个是为了适配google模拟器1080*2400 sdk36
Pair(screenWidth - 70, textBounds.top - 180),
Pair(screenWidth - 70, textBounds.top - 200),
Pair(screenWidth - 70, textBounds.top - 210),
)
// 记录点击前的页面包名
val beforeClickPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
for (i in possiblePositions.indices) {
val (x, y) = possiblePositions[i]
// 确保坐标有效
if (x <= 0 || y <= 0) {
Log.w(TAG, "⚠️ 计算出的坐标无效: ($x, $y)")
continue
}
Log.i(TAG, "🎯 尝试相对定位点击 ${i + 1}/${possiblePositions.size}: ($x, $y)")
// 执行坐标点击
val clickSuccess = performCoordinateClick(x.toFloat(), y.toFloat())
if (!clickSuccess) {
Log.w(TAG, "⚠️ 相对定位点击 ${i + 1} 执行失败")
continue
}
// 等待点击生效
delay(200)
// 检查权限状态
if (hasWriteSettingsPermission()) {
Log.i(TAG, "🎉 相对定位点击 ${i + 1} 成功获取权限！")
performBackNavigation()
performBackNavigation()
safeRecycleNode(foundTextNode)
safeRecycleNode(rootNode)
onWriteSettingsPermissionGranted()
return true
}
// 检查是否页面跳转了
val currentPackage = service.rootInActiveWindow?.packageName?.toString() ?: ""
if (checkIfPageChanged(beforeClickPackage, currentPackage)) {
Log.w(TAG, "⚠️ 相对定位点击 ${i + 1} 导致页面跳转，执行返回")
performBackNavigation()
delay(500) // 等待返回
}
Log.d(TAG, "🔍 相对定位点击 ${i + 1} 未获取权限，继续尝试下一个位置")
}
Log.w(TAG, "❌ 所有相对定位点击都未成功获取权限")
safeRecycleNode(foundTextNode)
safeRecycleNode(rootNode)
return false
} catch (e: Exception) {
Log.e(TAG, "❌ 基于文本节点的定位方案执行失败", e)
return false
}
}
/**
* 🔥 新增：递归查找包含指定文本的节点
*/
private fun findNodeByTextRecursive(
node: AccessibilityNodeInfo?, targetText: String
): AccessibilityNodeInfo? {
if (node == null) return null
try {
// 检查当前节点的文本
val nodeText = node.text?.toString()
if (!nodeText.isNullOrEmpty() && nodeText.contains(targetText, ignoreCase = true)) {
Log.d(TAG, "🔍 找到匹配文本: '$nodeText'")
return node
}
// 检查内容描述
val contentDesc = node.contentDescription?.toString()
if (!contentDesc.isNullOrEmpty() && contentDesc.contains(
targetText, ignoreCase = true
)
) {
Log.d(TAG, "🔍 找到匹配内容描述: '$contentDesc'")
return node
}
// 递归检查子节点
for (i in 0 until node.childCount) {
val child = node.getChild(i)
val result = findNodeByTextRecursive(child, targetText)
if (result != null) {
return result
}
safeRecycleNode(child)
}
} catch (e: Exception) {
Log.e(TAG, "❌ 递归查找文本节点失败", e)
}
return null
}
/**
* 执行单个坐标点击
*/
private suspend fun performCoordinateClick(x: Float, y: Float): Boolean {
return try {
Log.i(TAG, "🖱️ 执行坐标点击: ($x, $y)")
// 创建手势路径
val path = android.graphics.Path()
path.moveTo(x, y)
// 构建手势描述
val gestureBuilder = android.accessibilityservice.GestureDescription.Builder()
val strokeDescription =
android.accessibilityservice.GestureDescription.StrokeDescription(path, 0, 100)
gestureBuilder.addStroke(strokeDescription)
val gesture = gestureBuilder.build()
// 使用协程来处理手势完成回调
var gestureCompleted = false
var gestureSuccess = false
val success = service.dispatchGesture(
gesture,
object : android.accessibilityservice.AccessibilityService.GestureResultCallback() {
override fun onCompleted(gestureDescription: android.accessibilityservice.GestureDescription?) {
super.onCompleted(gestureDescription)
Log.i(TAG, "✅ 坐标点击手势执行完成")
gestureCompleted = true
gestureSuccess = true
}
override fun onCancelled(gestureDescription: android.accessibilityservice.GestureDescription?) {
super.onCancelled(gestureDescription)
Log.w(TAG, "⚠️ 坐标点击手势被取消")
gestureCompleted = true
gestureSuccess = false
}
},
null
)
if (!success) {
Log.w(TAG, "⚠️ 发送坐标点击手势失败")
return false
}
// 等待手势完成，最多等待1秒
var waitTime = 0
while (!gestureCompleted && waitTime < 1000) {
delay(50)
waitTime += 50
}
gestureSuccess
} catch (e: Exception) {
Log.e(TAG, "❌ 执行坐标点击失败", e)
false
}
}
}
Reference in New Issue View Git Blame Copy Permalink