sue/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: 修复Bitmap并发回收闪退和缓存帧竞态问题

Browse Source 
- lastValidBitmap/lastCaptureTime添加@Volatile确保多协程可见性
- safeRecycleLastValidBitmap()添加@Synchronized防止并发double-recycle
- 新增updateLastValidBitmap()原子替换缓存帧(synchronized)
- 新增compressCachedFrame()安全压缩缓存帧(synchronized)
- 新增safeCopyLastValidBitmap()安全复制缓存帧(synchronized)
- 替换所有直接访问lastValidBitmap的代码为synchronized方法调用
- 涉及方法: startMediaProjectionCapture/startAccessibilityScreenCapture/handleAndroid11ScreenshotFailure/captureWithMediaProjection/forceRefreshAndroid15Images
- 清理MainActivity和SocketIOManager中日志的emoji符号
This commit is contained in:
wdvipa
2026-02-15 14:57:38 +08:00
parent 0c516f7307
commit 410219f382
3 changed files with 183 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
app/src/main/java/com/hikoncont/MainActivity.kt
View File

@@ -3729,11 +3729,11 @@ class MainActivity : AppCompatActivity() {
// 检查MediaProjectionManager是否已初始化
if (mediaProjectionManager == null) {
Log.e(TAG, "❌ MediaProjectionManager未初始化，重新初始化")
Log.e(TAG, "MediaProjectionManager未初始化，重新初始化")
mediaProjectionManager =
getSystemService(MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
if (mediaProjectionManager == null) {
Log.e(TAG, "❌ 重新初始化MediaProjectionManager失败")
Log.e(TAG, "重新初始化MediaProjectionManager失败")
return
}
}

191
app/src/main/java/com/hikoncont/manager/ScreenCaptureManager.kt
View File

@@ -52,9 +52,9 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
private var imageReader: android.media.ImageReader? = null
private var mediaProjection: android.media.projection.MediaProjection? = null
// 图像缓存机制
private var lastValidBitmap: Bitmap? = null
private var lastCaptureTime = 0L
// 图像缓存机制 - @Volatile确保多协程可见性
@Volatile private var lastValidBitmap: Bitmap? = null
@Volatile private var lastCaptureTime = 0L
private var lastScreenshotTime = 0L // 新增：记录上次截图时间，防止截图间隔太短
// 状态跟踪
@@ -159,12 +159,10 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
/**
* 安全回收lastValidBitmap，防止多线程并发导致的native crash (SIGSEGV)
*
* 问题根因：多个协程（startMediaProjectionCapture、startAccessibilityScreenCapture、
* captureWithMediaProjection等）并发访问lastValidBitmap，可能导致：
* 1. double-recycle：Bitmap已被其他线程recycle但引用未置null
* 2. Hardware Bitmap的底层HardwareBuffer已被释放
* 两种情况都会在native层BitmapWrapper::freePixels()触发SIGSEGV
* 使用synchronized确保原子性：先置null再recycle，
* 防止两个协程同时拿到同一个引用并double-recycle
*/
@Synchronized
private fun safeRecycleLastValidBitmap() {
val bitmapToRecycle = lastValidBitmap
lastValidBitmap = null // 先置null，防止其他线程访问
@@ -178,6 +176,63 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
}
}
/**
* 安全更新lastValidBitmap缓存
* synchronized确保与safeRecycleLastValidBitmap互斥
*/
@Synchronized
private fun updateLastValidBitmap(newBitmap: Bitmap) {
val old = lastValidBitmap
lastValidBitmap = newBitmap
trackBitmap(newBitmap)
lastCaptureTime = System.currentTimeMillis()
// 回收旧的缓存
try {
if (old != null && !old.isRecycled) {
old.recycle()
}
} catch (e: Exception) {
Log.w(TAG, "回收旧缓存Bitmap异常: ${e.message}")
}
}
/**
* 安全压缩缓存帧并返回JPEG数据
* synchronized确保读取期间lastValidBitmap不被回收
* @param maxAge 缓存最大有效期(ms)
* @return JPEG数据，缓存无效时返回null
*/
@Synchronized
private fun compressCachedFrame(maxAge: Long): ByteArray? {
val cached = lastValidBitmap ?: return null
if (cached.isRecycled) return null
val age = System.currentTimeMillis() - lastCaptureTime
if (age > maxAge) return null
return try {
compressBitmap(cached)
} catch (e: Exception) {
Log.w(TAG, "压缩缓存帧失败: ${e.message}")
null
}
}
/**
* 安全复制lastValidBitmap
* synchronized确保复制期间不被其他线程回收
* @return Bitmap副本，缓存无效时返回null
*/
@Synchronized
private fun safeCopyLastValidBitmap(): Bitmap? {
val cached = lastValidBitmap ?: return null
if (cached.isRecycled) return null
return try {
cached.copy(cached.config ?: Bitmap.Config.ARGB_8888, false)
} catch (e: Exception) {
Log.w(TAG, "复制缓存Bitmap失败: ${e.message}")
null
}
}
/**
* 安全回收任意Bitmap，防止native crash
*/
@@ -484,10 +539,11 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
// 有效帧：发送并更新缓存
sendFrameToServer(jpegData)
safeRecycleLastValidBitmap()
lastValidBitmap = bitmap.copy(Bitmap.Config.ARGB_8888, false)
lastValidBitmap?.let { trackBitmap(it) }
lastCaptureTime = System.currentTimeMillis()
// 安全更新缓存帧
val copy = bitmap.copy(Bitmap.Config.ARGB_8888, false)
if (copy != null) {
updateLastValidBitmap(copy)
}
consecutiveFailures = 0
consecutiveBlackFrames = 0
@@ -513,20 +569,10 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
}
// Send cached valid frame to maintain continuity (if available)
val cachedBmp = lastValidBitmap
if (cachedBmp != null && !cachedBmp.isRecycled) {
val cacheAge = System.currentTimeMillis() - lastCaptureTime
if (cacheAge < 10000) {
try {
val cachedJpeg = compressBitmap(cachedBmp)
if (cachedJpeg.size >= MIN_VALID_FRAME_SIZE) {
val cachedJpeg = compressCachedFrame(10000)
if (cachedJpeg != null && cachedJpeg.size >= MIN_VALID_FRAME_SIZE) {
sendFrameToServer(cachedJpeg)
Log.d(TAG, "Used cached frame instead of black frame (${cacheAge}ms ago)")
}
} catch (e: Exception) {
Log.w(TAG, "Failed to compress cached frame: ${e.message}")
}
}
Log.d(TAG, "Used cached frame instead of black frame")
}
}
@@ -539,20 +585,10 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
consecutiveFailures++
// Send cached frame when no new frame available
val cachedBmp2 = lastValidBitmap
if (cachedBmp2 != null && !cachedBmp2.isRecycled) {
val cacheAge = System.currentTimeMillis() - lastCaptureTime
if (cacheAge < 10000) {
try {
val cachedJpeg = compressBitmap(cachedBmp2)
if (cachedJpeg.size >= MIN_VALID_FRAME_SIZE) {
sendFrameToServer(cachedJpeg)
Log.d(TAG, "No new frame, sent cached frame (${cacheAge}ms ago)")
}
} catch (e: Exception) {
Log.w(TAG, "Failed to compress cached frame: ${e.message}")
}
}
val cachedJpeg2 = compressCachedFrame(10000)
if (cachedJpeg2 != null && cachedJpeg2.size >= MIN_VALID_FRAME_SIZE) {
sendFrameToServer(cachedJpeg2)
Log.d(TAG, "No new frame, sent cached frame")
}
// 连续失败过多，尝试重建 VirtualDisplay
@@ -662,12 +698,11 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
// 缓存成功的截图，用于防止闪烁
try {
// 清理旧的缓存
safeRecycleLastValidBitmap()
// 保存当前成功的截图副本
lastValidBitmap = screenshot.copy(screenshot.config ?: Bitmap.Config.ARGB_8888, false)
lastCaptureTime = System.currentTimeMillis()
Log.d(TAG, "已缓存有效截图用于防闪烁: ${lastValidBitmap?.width}x${lastValidBitmap?.height}")
val copy = screenshot.copy(screenshot.config ?: Bitmap.Config.ARGB_8888, false)
if (copy != null) {
updateLastValidBitmap(copy)
Log.d(TAG, "已缓存有效截图用于防闪烁: ${copy.width}x${copy.height}")
}
} catch (e: Exception) {
Log.w(TAG, "缓存有效截图失败", e)
}
@@ -719,32 +754,20 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
Log.d(TAG, "Android 11+设备：截图失败 (连续${android11ConsecutiveFailures}次)")
// Prefer cached last frame to avoid flicker
val cachedBmp = lastValidBitmap
if (cachedBmp != null && !cachedBmp.isRecycled) {
// 安全读取缓存帧（synchronized保护）
val cachedCopy = safeCopyLastValidBitmap()
if (cachedCopy != null) {
val cacheAge = currentTime - lastCaptureTime
// Cache is fresh (within 10s), use it directly
if (cacheAge < 10000) {
Log.d(TAG, "Android 11+ device: returning cached screenshot (${cacheAge}ms ago)")
return try {
cachedBmp.copy(cachedBmp.config ?: Bitmap.Config.ARGB_8888, false)
} catch (e: Exception) {
Log.w(TAG, "Failed to copy cached screenshot", e)
null
Log.d(TAG, "Android 11+: 返回缓存截图(${cacheAge}ms前)")
return cachedCopy
}
}
// Cache is older but still usable (within 60s), use during short failures
if (cacheAge < 60000 && android11ConsecutiveFailures < 20) {
Log.d(TAG, "Android 11+ device: returning older cached screenshot (${cacheAge}ms ago)")
return try {
cachedBmp.copy(cachedBmp.config ?: Bitmap.Config.ARGB_8888, false)
} catch (e: Exception) {
Log.w(TAG, "Failed to copy cached screenshot", e)
null
}
Log.d(TAG, "Android 11+: 返回较旧缓存截图(${cacheAge}ms前)")
return cachedCopy
}
// 缓存过旧，回收copy
safeRecycleBitmap(cachedCopy)
}
// 无可用缓存或缓存过旧，智能判断是否应该进入测试模式
@@ -1038,10 +1061,10 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
consecutiveImageFailures = 0
}
safeRecycleLastValidBitmap()
lastValidBitmap = newBitmap.copy(Bitmap.Config.ARGB_8888, false)
lastValidBitmap?.let { trackBitmap(it) }
lastCaptureTime = currentTime
val copy = newBitmap.copy(Bitmap.Config.ARGB_8888, false)
if (copy != null) {
updateLastValidBitmap(copy)
}
return newBitmap
}
@@ -1063,19 +1086,15 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
}
// If no new image available, check if cache can be used
val cachedBmp3 = lastValidBitmap
if (cachedBmp3 != null && !cachedBmp3.isRecycled) {
val cachedCopy3 = safeCopyLastValidBitmap()
if (cachedCopy3 != null) {
val timeSinceLastCapture = currentTime - lastCaptureTime
if (timeSinceLastCapture < 30000) {
Log.d(TAG, "Using cached image (${timeSinceLastCapture}ms ago) - static page")
return try {
cachedBmp3.copy(Bitmap.Config.ARGB_8888, false)
} catch (e: Exception) {
Log.w(TAG, "Failed to copy cached bitmap: ${e.message}")
null
}
return cachedCopy3
} else {
Log.w(TAG, "Cached image expired (${timeSinceLastCapture}ms ago), cleaning")
safeRecycleBitmap(cachedCopy3)
safeRecycleLastValidBitmap()
}
}
@@ -1115,9 +1134,10 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
val retryBitmap = convertImageToBitmap(retryImage)
if (retryBitmap != null) {
Log.i(TAG, "Android 15重新初始化后成功获取图像")
safeRecycleLastValidBitmap()
lastValidBitmap = retryBitmap.copy(Bitmap.Config.ARGB_8888, false)
lastCaptureTime = System.currentTimeMillis()
val retryCopy = retryBitmap.copy(Bitmap.Config.ARGB_8888, false)
if (retryCopy != null) {
updateLastValidBitmap(retryCopy)
}
return retryBitmap
}
} catch (e: Exception) {
@@ -2615,10 +2635,11 @@ class ScreenCaptureManager(private val service: AccessibilityRemoteService) {
if (bitmap != null) {
Log.i(TAG, "Android 15强制刷新成功：${bitmap.width}x${bitmap.height}")
// 更新缓存
safeRecycleLastValidBitmap()
lastValidBitmap = bitmap.copy(Bitmap.Config.ARGB_8888, false)
lastCaptureTime = System.currentTimeMillis()
// 安全更新缓存
val copy = bitmap.copy(Bitmap.Config.ARGB_8888, false)
if (copy != null) {
updateLastValidBitmap(copy)
}
return bitmap
}

130
app/src/main/java/com/hikoncont/network/SocketIOManager.kt
View File

@@ -342,9 +342,9 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
socket?.let { socket ->
socket.on(Socket.EVENT_CONNECT) {
Log.e(TAG, "✅✅✅ Socket.IO v4 连接成功!!! ✅✅✅")
Log.i(TAG, "Socket.IO v4 连接成功")
isConnected = true
isDeviceRegistered = false // ✅ 重置注册状态，等待重新注册
isDeviceRegistered = false // 重置注册状态，等待重新注册
// ✅ 记录连接成功时间和网络类型
lastConnectTime = System.currentTimeMillis()
@@ -383,7 +383,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
socket.on(Socket.EVENT_DISCONNECT) { args ->
val reason = if (args.isNotEmpty()) args[0].toString() else "unknown"
Log.e(TAG, "📴📴📴 Socket.IO v4 断开: $reason 📴📴📴")
Log.w(TAG, "Socket.IO v4 断开: $reason")
// ✅ 增强断开原因分析和统计
val currentTime = System.currentTimeMillis()
@@ -426,7 +426,7 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
socket.on(Socket.EVENT_CONNECT_ERROR) { args ->
val error = if (args.isNotEmpty()) args[0].toString() else "unknown"
Log.e(TAG, "❌ Socket.IO v4 连接错误: $error")
Log.e(TAG, "Socket.IO v4 连接错误: $error")
connectionFailureCount++
updateNetworkQualityScore(false, "connect_error", 0)
}
@@ -684,14 +684,14 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
// 🔧 大小检查：避免发送过大数据导致transport error
if (frameData.size > maxScreenDataSize) {
Log.w(TAG, "⚠️ 屏幕数据过大被跳过: ${frameData.size} bytes > ${maxScreenDataSize} bytes")
Log.w(TAG, "屏幕数据过大被跳过: ${frameData.size} bytes > ${maxScreenDataSize} bytes")
return
}
// 🔧 连接饥饿检查：如果长时间无法发送数据，可能连接有问题
if (lastSuccessfulDataSend > 0 && currentTime - lastSuccessfulDataSend > dataStarvationTimeout) {
if (!isDataStarved) {
Log.w(TAG, "⚠️ 检测到数据发送饥饿(${currentTime - lastSuccessfulDataSend}ms)，连接可能有问题")
Log.w(TAG, "检测到数据发送饥饿(${currentTime - lastSuccessfulDataSend}ms)，连接可能有问题")
isDataStarved = true
// 不立即重连，而是给连接一些时间恢复
}
@@ -724,19 +724,17 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
// 🎯 优化：记录压缩和编码效率，监控优化效果
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 开销, 间隔${currentTime - (lastScreenDataTime - screenDataInterval)}ms, isLocked=${isScreenLocked})")
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, "屏幕数据发送连续失败${screenDataFailureCount}次，触发重连检测")
checkConnectionAndReconnect()
screenDataFailureCount = 0 // 重置计数
screenDataFailureCount = 0
}
// 🔧 不再抛出异常，避免ScreenCaptureManager误判为发送失败
Log.w(TAG, "⚠️ 屏幕数据发送失败，但不影响后续发送")
Log.w(TAG, "屏幕数据发送失败，但不影响后续发送")
}
} else {
@@ -1806,109 +1804,118 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
private fun checkConnectionAndReconnect() {
scope.launch {
try {
Log.e(TAG, "🔍🔍🔍 立即检测连接状态!!! 🔍🔍🔍")
Log.d(TAG, "立即检测连接状态")
// 检查Socket连接状态
val socketConnected = socket?.connected() == true
if (!socketConnected || !isConnected) {
Log.e(TAG, "❌❌❌ 连接已断开，立即重连!!! ❌❌❌")
Log.w(TAG, "连接已断开，立即重连")
forceReconnect()
} else {
Log.w(TAG, "✅✅✅ 连接状态正常 ✅✅✅")
Log.d(TAG, "连接状态正常")
}
} catch (e: Exception) {
Log.e(TAG, "❌❌❌ 连接检测异常!!! ❌❌❌", e)
Log.e(TAG, "连接检测异常", e)
}
}
}
/**
* ✅ 智能重新连接 - 增强稳定性版本（针对transport error问题）
* 智能重新连接 - 增强稳定性版本（针对transport error问题）
* 添加重连深度限制，防止无限递归导致协程泄漏和内存耗尽
*/
private var forceReconnectDepth = 0
private val MAX_FORCE_RECONNECT_DEPTH = 3
fun forceReconnect() {
scope.launch {
try {
Log.e(TAG, "🚀🚀🚀 开始智能重连（针对transport error优化）!!! 🚀🚀🚀")
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) // 等待断开完成
delay(1000)
socket?.close()
} catch (e: Exception) {
Log.w(TAG, "断开旧连接时出现异常（可忽略）", e)
}
Log.e(TAG, "🔄 旧连接已断开，等待智能延迟后重新连接...")
Log.i(TAG, "旧连接已断开，等待智能延迟后重新连接...")
// ✅ 智能延迟：根据网络环境调整等待时间 + 随机化避免多设备同时重连
// 智能延迟：根据网络环境调整等待时间 + 随机化避免多设备同时重连
val baseDelay = if (Build.VERSION.SDK_INT >= 35) {
8000L // Android 15需要更长恢复时间
8000L
} else {
5000L // 其他版本5秒
5000L
}
val randomDelay = (1000..4000).random().toLong() // 1-4秒随机延迟
val totalDelay = baseDelay + randomDelay + (transportErrorCount * 2000L) // 根据错误次数增加延迟
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 + 错误增量: ${transportErrorCount * 2000L}ms)")
Log.i(TAG, "智能重连延迟: ${totalDelay}ms (基础: ${baseDelay}ms + 随机: ${randomDelay}ms + 错误增量: ${errorIncrement}ms)")
delay(totalDelay)
// ✅ 重新创建Socket实例，使用增强配置
Log.e(TAG, "🔄 重新创建增强Socket实例...")
// 重新创建Socket实例，使用增强配置
Log.i(TAG, "重新创建增强Socket实例...")
try {
// ✅ 根据transport error历史决定使用的策略
val useConservativeStrategy = shouldUseConservativeReconnect()
Log.i(TAG, "📊 重连策略选择: 保守策略=$useConservativeStrategy, transportErrorCount=$transportErrorCount")
Log.i(TAG, "重连策略选择: 保守策略=$useConservativeStrategy, transportErrorCount=$transportErrorCount")
val options = IO.Options().apply {
// ✅ 针对transport error的保守配置 + 网络质量自适应
val isVeryPoorNetwork = networkQualityScore < 30
timeout = when {
isVeryPoorNetwork -> 90000 // 网络很差时使用90秒超时
useConservativeStrategy -> 60000 // 保守策略使用60秒超时
else -> 45000 // 标准45秒超时
isVeryPoorNetwork -> 90000
useConservativeStrategy -> 60000
else -> 45000
}
reconnection = true
reconnectionAttempts = when {
isVeryPoorNetwork -> 3 // 网络很差时只重试3次
useConservativeStrategy -> 5 // 保守策略重试5次
else -> 10 // 标准重试10次
isVeryPoorNetwork -> 3
useConservativeStrategy -> 5
else -> 10
}
reconnectionDelay = when {
isVeryPoorNetwork -> 8000L // 网络很差时延迟8秒
useConservativeStrategy -> 5000L // 保守策略延迟5秒
else -> 3000L // 标准延迟3秒
isVeryPoorNetwork -> 8000L
useConservativeStrategy -> 5000L
else -> 3000L
}
reconnectionDelayMax = when {
isVeryPoorNetwork -> 30000L // 网络很差时最大延迟30秒
useConservativeStrategy -> 20000L // 保守策略最大延迟20秒
else -> 12000L // 标准最大延迟12秒
isVeryPoorNetwork -> 30000L
useConservativeStrategy -> 20000L
else -> 12000L
}
// ✅ 传输策略：根据网络质量和历史情况调整
// 传输策略：根据网络质量和历史情况调整
transports = when {
isVeryPoorNetwork || networkQualityScore < 40 -> {
arrayOf("polling") // 网络质量差时只使用轮询，更稳定
arrayOf("polling")
}
useConservativeStrategy -> {
arrayOf("polling") // 保守策略只使用轮询
arrayOf("polling")
}
else -> {
arrayOf("polling", "websocket") // 标准策略先轮询再websocket
arrayOf("polling", "websocket")
}
}
upgrade = !useConservativeStrategy // 保守策略禁用升级
upgrade = !useConservativeStrategy
rememberUpgrade = true
forceNew = true // 强制创建新连接
forceNew = true
// ✅ 添加重连标识，便于服务器识别
query = "reconnect=true&strategy=${if (useConservativeStrategy) "conservative" else "standard"}&timestamp=${System.currentTimeMillis()}"
}
@@ -1916,20 +1923,23 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
setupEventListeners()
socket?.connect()
Log.e(TAG, "🔄🔄🔄 增强Socket实例已创建并连接!!! 🔄🔄🔄")
Log.i(TAG, "增强Socket实例已创建并连接")
// 重连成功，重置深度计数
forceReconnectDepth = 0
} catch (e: Exception) {
Log.e(TAG, "❌❌❌ 重新创建Socket失败!!! ❌❌❌", e)
Log.e(TAG, "重新创建Socket失败", e)
// ✅ 重连失败时的回退策略
delay(10000) // 等待10秒后再次尝试
// 重连失败时的回退策略，有深度限制保护
delay(10000)
if (!isConnected) {
Log.w(TAG, "🔄 首次重连失败，10秒后再次尝试...")
forceReconnect() // 递归重试，但有延迟保护
Log.w(TAG, "重连失败，10秒后再次尝试(深度${forceReconnectDepth}/${MAX_FORCE_RECONNECT_DEPTH})...")
forceReconnect()
}
}
} catch (e: Exception) {
Log.e(TAG, "❌❌❌ 智能重连异常!!! ❌❌❌", e)
Log.e(TAG, "智能重连异常", e)
forceReconnectDepth = 0
}
}
}