基于Rokid AI眼镜的智能家电故障诊断助手开发实践

// 设备连接管理器
class DeviceConnectionManager(private val context: Context) {
    private val bluetoothHelper: BluetoothHelper
    private val TAG = "DeviceConnectionManager"
    
    init {
        bluetoothHelper = BluetoothHelper(
            context as AppCompatActivity,
            { status -> handleInitStatus(status) },
            { deviceFound() }
        )
    }
    
    fun initializeConnection() {
        // 1. 检查必要权限
        if (!checkRequiredPermissions()) {
            requestPermissions()
            return
        }
        
        // 2. 初始化蓝牙模块
        bluetoothHelper.checkPermissions()
    }
    
    private fun handleInitStatus(status: BluetoothHelper.INIT_STATUS) {
        when (status) {
            BluetoothHelper.INIT_STATUS.NotStart -> Log.d(TAG, "Bluetooth init not started")
            BluetoothHelper.INIT_STATUS.INITING -> Log.d(TAG, "Bluetooth initializing...")
            BluetoothHelper.INIT_STATUS.INIT_END -> {
                Log.d(TAG, "Bluetooth initialized successfully")
                connectToGlasses()
            }
        }
    }
    
    private fun connectToGlasses() {
        val glassesDevice = findTargetDevice()
        glassesDevice?.let { device ->
            // 3. 初始化蓝牙连接
            CxrApi.getInstance().initBluetooth(context, device, object : BluetoothStatusCallback {
                override fun onConnectionInfo(socketUuid: String?, macAddress: String?, rokidAccount: String?, glassesType: Int) {
                    socketUuid?.let { uuid ->
                        macAddress?.let { address ->
                            // 4. 建立稳定连接
                            CxrApi.getInstance().connectBluetooth(context, uuid, address, object : BluetoothStatusCallback {
                                override fun onConnected() {
                                    Log.d(TAG, "Successfully connected to Rokid Glasses")
                                    startWifiConnection() // 启动Wi-Fi连接用于大文件传输
                                }
                                
                                override fun onDisconnected() {
                                    Log.e(TAG, "Connection lost, attempting reconnect...")
                                    scheduleReconnect()
                                }
                                
                                override fun onFailed(errorCode: ValueUtil.CxrBluetoothErrorCode?) {
                                    handleConnectionError(errorCode)
                                }
                                
                                override fun onConnectionInfo(socketUuid: String?, macAddress: String?, rokidAccount: String?, glassesType: Int) {}
                            })
                        }
                    }
                }
                
                override fun onConnected() {}
                override fun onDisconnected() {}
                override fun onFailed(errorCode: ValueUtil.CxrBluetoothErrorCode?) {}
            })
        } ?: run {
            showNoDeviceFoundDialog()
        }
    }
    
    private fun startWifiConnection() {
        // 5. 初始化Wi-Fi P2P连接
        val wifiStatus = CxrApi.getInstance().initWifiP2P(object : WifiP2PStatusCallback {
            override fun onConnected() {
                Log.d(TAG, "Wi-Fi P2P connected successfully")
                initializeDiagnosticServices() // 初始化诊断服务
            }
            
            override fun onDisconnected() {
                Log.w(TAG, "Wi-Fi P2P disconnected, falling back to Bluetooth")
            }
            
            override fun onFailed(errorCode: ValueUtil.CxrWifiErrorCode?) {
                when (errorCode) {
                    ValueUtil.CxrWifiErrorCode.WIFI_DISABLED -> enableWifi()
                    else -> Log.e(TAG, "Wi-Fi connection failed: $errorCode")
                }
            }
        })
        
        if (wifiStatus == ValueUtil.CxrStatus.REQUEST_FAILED) {
            Log.w(TAG, "Wi-Fi initialization failed, continuing with Bluetooth only")
        }
    }
    
    private fun initializeDiagnosticServices() {
        // 6. 设置设备状态监听器
        setupDeviceListeners()
        // 7. 加载家电识别模型
        loadApplianceModels()
        // 8. 初始化AR渲染引擎
        initArEngine()
    }
}

class ApplianceVisualRecognizer {
    private val applianceClassifier: Interpreter // TensorFlow Lite模型
    private val faultDetector: YoloDetector // 基于YOLO的故障检测器
    private val frameProcessor = FrameProcessor()
    
    fun initializeModels(context: Context) {
        // 加载设备分类模型
        val applianceModel = loadModelFile(context, "appliance_classifier.tflite")
        applianceClassifier = Interpreter(applianceModel)
        
        // 加载故障检测模型
        faultDetector = YoloDetector(context, "fault_detector.onnx")
    }
    
    fun processFrame(frame: Bitmap): RecognitionResult {
        // 1. 预处理图像
        val processedFrame = frameProcessor.preprocess(frame, 224, 224)
        
        // 2. 设备类型识别
        val applianceType = recognizeApplianceType(processedFrame)
        
        // 3. 根据设备类型加载特定故障检测器
        val faultModel = loadFaultModelForAppliance(applianceType)
        
        // 4. 故障特征检测
        val faultRegions = detectFaultRegions(frame, faultModel)
        
        // 5. 生成识别结果
        return RecognitionResult(
            applianceType = applianceType,
            faultRegions = faultRegions,
            confidence = calculateConfidence(applianceType, faultRegions)
        )
    }
    
    private fun recognizeApplianceType(frame: Bitmap): String {
        val inputBuffer = TensorImage(DataType.UINT8).apply {
            load(frame)
        }
        
        val outputBuffer = TensorBuffer.createFixedSize(intArrayOf(1, 10), DataType.FLOAT32)
        
        applianceClassifier.run(inputBuffer.buffer, outputBuffer.buffer)
        
        val probabilities = outputBuffer.floatArray
        val maxIndex = probabilities.indices.maxByOrNull { probabilities[it] } ?: 0
        
        return APPLIANCE_TYPES[maxIndex] // ["refrigerator", "washing_machine", "air_conditioner", ...]
    }
    
    // 通过Rokid SDK获取实时帧
    fun startCameraStream() {
        CxrApi.getInstance().openGlassCamera(1280, 720, 85) { status, frameData ->
            if (status == ValueUtil.CxrStatus.RESPONSE_SUCCEED && frameData != null) {
                val bitmap = convertByteArrayToBitmap(frameData)
                val result = processFrame(bitmap)
                displayArOverlay(result) // 在眼镜端显示AR叠加
                analyzeFaultResult(result) // 分析故障结果
            }
        }
    }
    
    companion object {
        private val APPLIANCE_TYPES = arrayOf(
            "refrigerator", "washing_machine", "air_conditioner",
            "microwave", "oven", "dishwasher", "water_heater"
        )
    }
}

class FaultDiagnosisEngine {
    private val knowledgeBase = HashMap<String, ApplianceFaultTree>()
    private val conversationState = mutableMapOf<String, Any>()
    
    fun initialize() {
        // 加载家电故障知识库
        loadKnowledgeBaseFromAssets()
    }
    
    fun handleVoiceInput(transcript: String, applianceType: String): DiagnosisResponse {
        // 1. 解析用户意图
        val intent = parseUserIntent(transcript)
        
        // 2. 根据当前对话状态处理
        return when (intent) {
            "describe_fault" -> handleFaultDescription(transcript, applianceType)
            "confirm_symptom" -> handleSymptomConfirmation(transcript)
            "request_solution" -> provideRepairSolution(applianceType)
            "request_expert" -> requestExpertAssistance()
            else -> generateDefaultResponse()
        }
    }
    
    private fun handleFaultDescription(transcript: String, applianceType: String): DiagnosisResponse {
        // 1. 提取关键症状
        val symptoms = extractSymptoms(transcript)
        
        // 2. 匹配知识库
        val possibleFaults = knowledgeBase[applianceType]?.findMatchingFaults(symptoms)
        
        // 3. 生成诊断问题
        if (possibleFaults?.size ?: 0 > 1) {
            // 需要更多信息来缩小范围
            conversationState["possible_faults"] = possibleFaults
            return DiagnosisResponse(
                question = generateClarifyingQuestion(possibleFaults),
                type = "clarification"
            )
        } else if (possibleFaults?.isNotEmpty() == true) {
            // 已识别具体故障
            val fault = possibleFaults[0]
            conversationState["diagnosed_fault"] = fault
            return DiagnosisResponse(
                solution = fault.solution,
                severity = fault.severity,
                diyRepairable = fault.diyRepairable,
                estimatedCost = fault.estimatedCost,
                type = "diagnosis_complete"
            )
        } else {
            // 未找到匹配故障
            return DiagnosisResponse(
                message = "未找到匹配的故障类型，请描述更多细节或尝试重新描述",
                type = "no_match"
            )
        }
    }
    
    // 通过Rokid SDK发送TTS内容
    fun sendVoiceResponse(response: DiagnosisResponse) {
        when (response.type) {
            "diagnosis_complete" -> {
                val content = "诊断完成：${response.solution}。" +
                        "故障严重程度：${response.severity}。" +
                        if (response.diyRepairable) "您可以自行尝试修复。" else "建议联系专业维修人员。"
                CxrApi.getInstance().sendTtsContent(content)
            }
            "clarification" -> {
                CxrApi.getInstance().sendTtsContent(response.question)
            }
            else -> {
                CxrApi.getInstance().sendTtsContent(response.message ?: "抱歉，我没有理解您的意思。")
            }
        }
    }
    
    // 处理ASR结果
    fun onAsrResult(content: String) {
        val applianceType = conversationState["current_appliance"] as? String ?: "unknown"
        val response = handleVoiceInput(content, applianceType)
        sendVoiceResponse(response)
        
        // 如果诊断完成，显示AR维修指引
        if (response.type == "diagnosis_complete") {
            showArRepairGuide(response.diagnosedFault)
        }
    }
    
    // 设置ASR监听器
    fun setupAsrListener() {
        CxrApi.getInstance().setAiEventListener(object : AiEventListener {
            override fun onAiKeyDown() {
                // 用户按下语音键
                Log.d("DiagnosisEngine", "Voice input started")
            }
            
            override fun onAiKeyUp() {
                // 语音输入结束，等待ASR结果
            }
            
            override fun onAiExit() {
                // 退出AI场景
                clearConversationState()
            }
        })
    }
}

class ArRepairGuidanceSystem {
    private val repairSteps = mutableListOf<RepairStep>()
    private var currentStepIndex = 0
    
    data class RepairStep(
        val title: String,
        val description: String,
        val imageResource: String?, // Base64编码的图片
        val warning: String?,
        val toolsRequired: List<String>,
        val estimatedTime: Int // 分钟
    )
    
    fun generateRepairGuide(fault: ApplianceFault): List<RepairStep> {
        return when (fault.applianceType) {
            "washing_machine" -> generateWashingMachineGuide(fault)
            "refrigerator" -> generateRefrigeratorGuide(fault)
            "air_conditioner" -> generateAirConditionerGuide(fault)
            else -> generateGenericGuide(fault)
        }
    }
    
    private fun generateWashingMachineGuide(fault: ApplianceFault): List<RepairStep> {
        return when (fault.faultType) {
            "drain_pump_failure" -> listOf(
                RepairStep(
                    title = "安全准备",
                    description = "断开电源，关闭进水阀门，排空残留水",
                    imageResource = loadImageAsBase64("washing_machine_safety.png"),
                    warning = "⚠️ 务必断电操作，避免触电风险",
                    toolsRequired = listOf("毛巾", "水桶"),
                    estimatedTime = 5
                ),
                RepairStep(
                    title = "拆卸底板",
                    description = "使用十字螺丝刀卸下洗衣机底部面板螺丝，小心取下面板",
                    imageResource = loadImageAsBase64("washing_machine_panel_removal.png"),
                    warning = null,
                    toolsRequired = listOf("十字螺丝刀", "磁性托盘"),
                    estimatedTime = 10
                ),
                RepairStep(
                    title = "检查排水泵",
                    description = "找到排水泵（通常位于右下角），检查是否有异物堵塞，测试泵体是否转动灵活",
                    imageResource = loadImageAsBase64("washing_machine_drain_pump.png"),
                    warning = "🔍 仔细检查叶轮是否有硬币、发夹等异物",
                    toolsRequired = listOf("手电筒", "镊子"),
                    estimatedTime = 15
                ),
                RepairStep(
                    title = "更换排水泵",
                    description = "拔下电源插头，松开固定螺丝，取出旧泵，安装新泵并重新连接",
                    imageResource = loadImageAsBase64("washing_machine_pump_replacement.png"),
                    warning = "⚡ 确保电源线连接牢固，防水圈安装到位",
                    toolsRequired = listOf("新排水泵", "螺丝刀套装"),
                    estimatedTime = 20
                ),
                RepairStep(
                    title = "测试与复原",
                    description = "重新安装面板，连接电源和水源，运行测试程序检查是否正常排水",
                    imageResource = loadImageAsBase64("washing_machine_test.png"),
                    warning = "💧 首次测试建议在卫生间进行，防止漏水",
                    toolsRequired = listOf("纸巾", "测试程序"),
                    estimatedTime = 10
                )
            )
            else -> generateGenericGuide(fault)
        }
    }
    
    fun displayCurrentStep() {
        if (currentStepIndex < repairSteps.size) {
            val step = repairSteps[currentStepIndex]
            val customViewJson = createArOverlayJson(step)
            CxrApi.getInstance().updateCustomView(customViewJson)
        }
    }
    
    private fun createArOverlayJson(step: RepairStep): String {
        return """
        {
          "type": "LinearLayout",
          "props": {
            "layout_width": "match_parent",
            "layout_height": "match_parent",
            "orientation": "vertical",
            "gravity": "center",
            "backgroundColor": "#88000000",
            "padding": "20dp"
          },
          "children": [
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "${step.title}",
                "textSize": "24sp",
                "textColor": "#FF00FF00",
                "textStyle": "bold",
                "marginBottom": "10dp"
              }
            },
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "${step.description}",
                "textSize": "18sp",
                "textColor": "#FFFFFFFF",
                "marginBottom": "15dp"
              }
            },
            ${if (step.imageResource != null) """
            {
              "type": "ImageView",
              "props": {
                "layout_width": "200dp",
                "layout_height": "200dp",
                "name": "step_image_${currentStepIndex}",
                "scaleType": "center_inside",
                "marginBottom": "15dp"
              }
            },
            """ else ""}
            ${if (step.warning != null) """
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "${step.warning}",
                "textSize": "16sp",
                "textColor": "#FFFF0000",
                "textStyle": "bold",
                "marginBottom": "10dp"
              }
            },
            """ else ""}
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "所需工具: ${step.toolsRequired.joinToString(", ")}",
                "textSize": "16sp",
                "textColor": "#FF00FFFF",
                "marginBottom": "5dp"
              }
            },
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "预估时间: ${step.estimatedTime}分钟",
                "textSize": "16sp",
                "textColor": "#FF00FFFF"
              }
            },
            {
              "type": "LinearLayout",
              "props": {
                "layout_width": "match_parent",
                "layout_height": "wrap_content",
                "orientation": "horizontal",
                "gravity": "center",
                "marginTop": "20dp"
              },
              "children": [
                {
                  "type": "ImageView",
                  "props": {
                    "layout_width": "48dp",
                    "layout_height": "48dp",
                    "name": "prev_icon",
                    "scaleType": "center"
                  }
                },
                {
                  "type": "TextView",
                  "props": {
                    "layout_width": "wrap_content",
                    "layout_height": "wrap_content",
                    "text": "${currentStepIndex + 1}/${repairSteps.size}",
                    "textSize": "18sp",
                    "textColor": "#FFFFFFFF",
                    "marginStart": "15dp",
                    "marginEnd": "15dp"
                  }
                },
                {
                  "type": "ImageView",
                  "props": {
                    "layout_width": "48dp",
                    "layout_height": "48dp",
                    "name": "next_icon",
                    "scaleType": "center"
                  }
                }
              ]
            }
          ]
        }
        """.trimIndent()
    }
    
    fun navigateToNextStep() {
        if (currentStepIndex < repairSteps.size - 1) {
            currentStepIndex++
            displayCurrentStep()
        } else {
            showCompletionScreen()
        }
    }
    
    fun navigateToPreviousStep() {
        if (currentStepIndex > 0) {
            currentStepIndex--
            displayCurrentStep()
        }
    }
    
    private fun showCompletionScreen() {
        val completionJson = """
        {
          "type": "LinearLayout",
          "props": {
            "layout_width": "match_parent",
            "layout_height": "match_parent",
            "orientation": "vertical",
            "gravity": "center",
            "backgroundColor": "#CC00CC00",
            "padding": "30dp"
          },
          "children": [
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "维修完成！",
                "textSize": "32sp",
                "textColor": "#FFFFFFFF",
                "textStyle": "bold",
                "marginBottom": "20dp"
              }
            },
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "请进行最终测试，确保设备正常运行",
                "textSize": "22sp",
                "textColor": "#FFFFFFFF",
                "marginBottom": "30dp",
                "gravity": "center"
              }
            },
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "✅ 按任意键结束指导",
                "textSize": "18sp",
                "textColor": "#FFFFFFFF"
              }
            }
          ]
        }
        """.trimIndent()
        
        CxrApi.getInstance().updateCustomView(completionJson)
    }
}

class MultimodalInteractionManager {
    private val gestureDetector = GestureDetector()
    private val voiceCommandMap = mutableMapOf<String, (String) -> Unit>()
    
    fun initialize() {
        // 注册语音命令
        registerVoiceCommands()
        
        // 设置手势识别
        setupGestureRecognition()
        
        // 配置视觉反馈
        setupVisualFeedback()
    }
    
    private fun registerVoiceCommands() {
        voiceCommandMap["下一步"] = { _ -> navigateToNextStep() }
        voiceCommandMap["上一步"] = { _ -> navigateToPreviousStep() }
        voiceCommandMap["重复"] = { _ -> repeatCurrentStep() }
        voiceCommandMap["放大"] = { _ -> zoomIn() }
        voiceCommandMap["缩小"] = { _ -> zoomOut() }
        voiceCommandMap["帮助"] = { _ -> showHelp() }
        voiceCommandMap["退出"] = { _ -> exitGuidance() }
    }
    
    private fun setupGestureRecognition() {
        gestureDetector.setOnGestureListener(object : GestureListener {
            override fun onSingleTap() {
                // 单击：确认/继续
                handleSingleTap()
            }
            
            override fun onDoubleTap() {
                // 双击：返回/取消
                handleDoubleTap()
            }
            
            override fun onSwipeLeft() {
                // 左滑：上一步
                navigateToPreviousStep()
            }
            
            override fun onSwipeRight() {
                // 右滑：下一步
                navigateToNextStep()
            }
            
            override fun onSwipeUp() {
                // 上滑：显示工具列表
                showToolsList()
            }
            
            override fun onSwipeDown() {
                // 下滑：隐藏指导，显示原始视图
                toggleGuidanceVisibility()
            }
        })
    }
    
    fun processVoiceCommand(command: String) {
        val normalizedCommand = command.lowercase().trim()
        
        // 模糊匹配命令
        val bestMatch = voiceCommandMap.keys
            .filter { it.contains(normalizedCommand) || normalizedCommand.contains(it) }
            .maxByOrNull { it.length }
        
        bestMatch?.let { matchedCommand ->
            voiceCommandMap[matchedCommand]?.invoke(normalizedCommand)
            provideVoiceFeedback("已执行: $matchedCommand")
        } ?: run {
            provideVoiceFeedback("未识别命令: $command，请说'帮助'查看可用命令")
        }
    }
    
    private fun provideVoiceFeedback(message: String) {
        CxrApi.getInstance().sendTtsContent(message)
    }
    
    // 处理手势事件
    fun handleTouchEvent(event: MotionEvent) {
        gestureDetector.onTouchEvent(event)
    }
    
    companion object {
        // 常用交互手势映射表
        private val GESTURE_MAPPINGS = mapOf(
            "single_tap" to "确认/继续",
            "double_tap" to "返回/取消",
            "swipe_left" to "上一步",
            "swipe_right" to "下一步",
            "swipe_up" to "显示工具",
            "swipe_down" to "隐藏指导"
        )
        
        private val VOICE_COMMANDS = arrayOf(
            "下一步", "上一步", "重复", "放大", "缩小", "帮助", "退出",
            "显示工具", "拍照记录", "联系专家", "保存进度"
        )
    }
}

class DataSyncManager {
    private val cloudService = CloudRepairService()
    private val localDatabase = RepairDatabase.getInstance()
    
    fun syncRepairData(repairSession: RepairSession) {
        // 1. 保存到本地数据库
        localDatabase.saveRepairSession(repairSession)
        
        // 2. 同步到云端（如果网络可用）
        if (isNetworkAvailable()) {
            GlobalScope.launch(Dispatchers.IO) {
                try {
                    cloudService.uploadRepairSession(repairSession)
                    Log.d("DataSyncManager", "Repair session synced to cloud successfully")
                    
                    // 3. 同步媒体文件（照片/视频）
                    syncMediaFiles(repairSession)
                    
                    // 4. 更新同步状态
                    repairSession.syncStatus = "synced"
                    localDatabase.updateSyncStatus(repairSession.id, "synced")
                } catch (e: Exception) {
                    Log.e("DataSyncManager", "Cloud sync failed: ${e.message}")
                    repairSession.syncStatus = "failed"
                    localDatabase.updateSyncStatus(repairSession.id, "failed")
                }
            }
        } else {
            repairSession.syncStatus = "pending"
            localDatabase.updateSyncStatus(repairSession.id, "pending")
        }
    }
    
    private suspend fun syncMediaFiles(repairSession: RepairSession) {
        repairSession.mediaFiles.forEach { mediaFile ->
            if (!mediaFile.synced) {
                try {
                    val uploadResult = cloudService.uploadMediaFile(mediaFile.filePath)
                    if (uploadResult.success) {
                        mediaFile.cloudUrl = uploadResult.url
                        mediaFile.synced = true
                        localDatabase.updateMediaFileSyncStatus(mediaFile.id, true, uploadResult.url)
                    }
                } catch (e: Exception) {
                    Log.e("DataSyncManager", "Media sync failed for ${mediaFile.id}: ${e.message}")
                }
            }
        }
    }
    
    fun captureAndSavePhoto(context: Context, description: String): String? {
        // 1. 通过Rokid SDK拍照
        var photoPath: String? = null
        
        CxrApi.getInstance().takeGlassPhoto(1280, 720, 85, object : PhotoPathCallback {
            override fun onPhotoPath(status: ValueUtil.CxrStatus?, path: String?) {
                if (status == ValueUtil.CxrStatus.RESPONSE_SUCCEED && path != null) {
                    photoPath = path
                    Log.d("DataSyncManager", "Photo captured at: $path")
                    
                    // 2. 保存到维修会话
                    val mediaFile = MediaFile(
                        id = UUID.randomUUID().toString(),
                        filePath = path,
                        type = "image/jpeg",
                        timestamp = System.currentTimeMillis(),
                        description = description,
                        synced = false
                    )
                    
                    // 3. 关联到当前维修会话
                    getCurrentRepairSession()?.mediaFiles?.add(mediaFile)
                    localDatabase.saveMediaFile(mediaFile)
                    
                    // 4. 自动同步（如果网络可用）
                    if (isNetworkAvailable()) {
                        syncMediaFiles(getCurrentRepairSession()!!)
                    }
                }
            }
        })
        
        return photoPath
    }
    
    fun requestRemoteAssistance(expertId: String, repairSessionId: String) {
        // 1. 准备当前状态数据
        val sessionData = localDatabase.getRepairSession(repairSessionId)
        val mediaFiles = localDatabase.getMediaFilesForSession(repairSessionId)
        
        // 2. 创建远程协助请求
        val assistanceRequest = RemoteAssistanceRequest(
            requestId = UUID.randomUUID().toString(),
            repairSessionId = repairSessionId,
            expertId = expertId,
            applianceType = sessionData?.applianceType ?: "unknown",
            faultDescription = sessionData?.faultDescription ?: "未描述",
            currentStep = sessionData?.currentStep ?: 0,
            mediaFiles = mediaFiles.filter { it.synced }.map { it.cloudUrl ?: it.filePath },
            timestamp = System.currentTimeMillis()
        )
        
        // 3. 通过Rokid SDK建立视频通话
        startVideoCallWithExpert(expertId, assistanceRequest)
    }
    
    private fun startVideoCallWithExpert(expertId: String, request: RemoteAssistanceRequest) {
        // 配置视频通话参数
        val videoParams = VideoCallParams(
            resolution = "720p",
            fps = 30,
            audioCodec = "opus",
            videoCodec = "h264",
            maxBitrate = 2000 // kbps
        )
        
        // 通过CXR-M SDK启动视频场景
        CxrApi.getInstance().controlScene(
            ValueUtil.CxrSceneType.VIDEO_RECORD,
            true,
            Gson().toJson(videoParams)
        )
        
        // 通知专家端
        GlobalScope.launch(Dispatchers.IO) {
            cloudService.notifyExpertOfAssistanceRequest(request, expertId)
        }
        
        // 在眼镜端显示提示
        showArOverlayForRemoteAssistance()
    }
}

class PerformanceOptimizer {
    private val memoryCache = LruCache<String, Bitmap>(MAX_CACHE_SIZE)
    private var frameProcessingThread: HandlerThread? = null
    private var frameProcessingHandler: Handler? = null
    
    companion object {
        const val MAX_CACHE_SIZE = 10 * 1024 * 1024 // 10MB
        const val TARGET_FPS = 15 // 目标帧率
        const val MAX_FRAME_QUEUE_SIZE = 3 // 最大帧队列大小
    }
    
    fun initialize() {
        // 创建专用线程处理帧
        frameProcessingThread = HandlerThread("FrameProcessingThread").apply {
            start()
            frameProcessingHandler = Handler(looper)
        }
        
        // 设置内存警告监听器
        setupMemoryWarningListener()
        
        // 预加载常用资源
        preloadCommonResources()
    }
    
    private fun setupMemoryWarningListener() {
        // 监听系统内存警告
        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
        val memoryClass = activityManager.memoryClass
        
        // 如果可用内存低于阈值，清理缓存
        val runtime = Runtime.getRuntime()
        if (runtime.freeMemory() < memoryClass * 1024 * 1024 * 0.3) {
            clearCaches()
        }
    }
    
    fun processFrameOptimized(frame: Bitmap, callback: (processedFrame: Bitmap?) -> Unit) {
        // 1. 检查帧队列是否已满
        if (frameProcessingHandler?.hasMessages(0) ?: false) {
            // 队列已满，丢弃当前帧
            Log.w("PerformanceOptimizer", "Frame queue full, dropping frame")
            return
        }
        
        // 2. 限制处理频率
        val currentTime = System.currentTimeMillis()
        if (currentTime - lastProcessedTime < 1000 / TARGET_FPS) {
            // 未达到目标帧率，跳过处理
            return
        }
        lastProcessedTime = currentTime
        
        // 3. 在后台线程处理帧
        frameProcessingHandler?.post {
            var processedFrame: Bitmap? = null
            try {
                // 4. 降低分辨率处理（如果需要）
                val processingFrame = if (frame.width > 640) {
                    Bitmap.createScaledBitmap(frame, 640, frame.height * 640 / frame.width, true)
                } else {
                    frame
                }
                
                // 5. 执行轻量级处理
                processedFrame = processWithOptimizations(processingFrame)
                
                // 6. 回到主线程更新UI
                context.mainHandler.post {
                    callback(processedFrame)
                }
            } catch (e: OutOfMemoryError) {
                Log.e("PerformanceOptimizer", "OOM during frame processing", e)
                clearCaches()
                callback(null)
            } finally {
                processingFrame?.recycle()
            }
        }
    }
    
    private fun processWithOptimizations(frame: Bitmap): Bitmap {
        // 1. 使用原生代码进行图像处理
        val processed = NativeImageProcessor.processFrame(frame)
        
        // 2. 如果处理成功，缓存结果
        if (processed != null && !processed.isRecycled) {
            val cacheKey = "frame_${System.currentTimeMillis()}"
            memoryCache.put(cacheKey, processed)
            return processed
        }
        
        return frame
    }
    
    fun clearCaches() {
        memoryCache.evictAll()
        System.gc()
        
        // 通知Rokid SDK清理资源
        CxrApi.getInstance().notifyMemoryLow()
    }
    
    // 预加载常用AR资源
    private fun preloadCommonResources() {
        val commonIcons = listOf("warning_icon", "tool_icon", "next_arrow", "prev_arrow")
        
        val icons = commonIcons.map { iconName ->
            IconInfo(
                name = iconName,
                data = loadImageAsBase64("$iconName.png")
            )
        }
        
        CxrApi.getInstance().sendCustomViewIcons(icons)
    }
}

class ExceptionHandler {
    private val errorRecoveryStrategies = mutableMapOf<String, suspend () -> Unit>()
    private val errorLogger = CrashlyticsLogger()
    
    fun initialize() {
        registerRecoveryStrategies()
        setupGlobalExceptionHandler()
    }
    
    private fun registerRecoveryStrategies() {
        // 蓝牙连接断开恢复策略
        errorRecoveryStrategies["bluetooth_disconnected"] = {
            delay(2000) // 等待2秒
            reconnectToGlasses()
        }
        
        // Wi-Fi连接失败恢复策略
        errorRecoveryStrategies["wifi_failed"] = {
            switchToBluetoothOnlyMode()
            CxrApi.getInstance().sendTtsContent("Wi-Fi连接失败，已切换到蓝牙模式，部分功能可能受限")
        }
        
        // AI服务超时恢复策略
        errorRecoveryStrategies["ai_timeout"] = {
            useCachedDiagnosis()
            CxrApi.getInstance().sendTtsContent("网络响应较慢，正在使用本地缓存数据")
        }
        
        // 相机初始化失败恢复策略
        errorRecoveryStrategies["camera_init_failed"] = {
            requestCameraPermissions()
            delay(1000)
            retryCameraInit()
        }
    }
    
    suspend fun handleException(throwable: Throwable, context: String) {
        // 1. 记录异常
        errorLogger.logException(throwable, context)
        
        // 2. 分类处理
        when (throwable) {
            is IOException -> handleIoException(throwable, context)
            is SecurityException -> handleSecurityException(throwable, context)
            is NullPointerException -> handleNullException(throwable, context)
            is TimeoutException -> handleTimeoutException(throwable, context)
            else -> handleGenericException(throwable, context)
        }
        
        // 3. 尝试恢复
        val recoveryStrategy = getRecoveryStrategyForContext(context)
        recoveryStrategy?.invoke()
    }
    
    private fun handleIoException(e: IOException, context: String) {
        when {
            e.message?.contains("bluetooth") == true -> {
                notifyUser("蓝牙连接异常，请检查设备是否开启")
                logToDeviceManager("BLUETOOTH_IO_ERROR", e.message)
            }
            e.message?.contains("wifi") == true -> {
                notifyUser("Wi-Fi连接异常，请检查网络状态")
                logToDeviceManager("WIFI_IO_ERROR", e.message)
            }
            else -> {
                notifyUser("数据传输错误，请重试操作")
            }
        }
    }
    
    private suspend fun getRecoveryStrategyForContext(context: String): (suspend () -> Unit)? {
        return when {
            context.contains("bluetooth") -> errorRecoveryStrategies["bluetooth_disconnected"]
            context.contains("wifi") -> errorRecoveryStrategies["wifi_failed"]
            context.contains("ai") || context.contains("diagnosis") -> errorRecoveryStrategies["ai_timeout"]
            context.contains("camera") || context.contains("photo") -> errorRecoveryStrategies["camera_init_failed"]
            else -> null
        }
    }
    
    private fun notifyUser(message: String) {
        // 1. 语音通知
        CxrApi.getInstance().sendTtsContent(message)
        
        // 2. AR界面提示
        showArErrorOverlay(message)
        
        // 3. 记录到日志
        Log.e("ExceptionHandler", message)
    }
    
    private fun showArErrorOverlay(errorMessage: String) {
        val errorJson = """
        {
          "type": "LinearLayout",
          "props": {
            "layout_width": "match_parent",
            "layout_height": "match_parent",
            "orientation": "vertical",
            "gravity": "center",
            "backgroundColor": "#CCFF0000",
            "padding": "30dp"
          },
          "children": [
            {
              "type": "ImageView",
              "props": {
                "layout_width": "64dp",
                "layout_height": "64dp",
                "name": "error_icon",
                "layout_gravity": "center_horizontal",
                "marginBottom": "20dp"
              }
            },
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "错误",
                "textSize": "24sp",
                "textColor": "#FFFFFFFF",
                "textStyle": "bold",
                "marginBottom": "10dp"
              }
            },
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "$errorMessage",
                "textSize": "18sp",
                "textColor": "#FFFFFFFF",
                "gravity": "center",
                "marginBottom": "20dp"
              }
            },
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "🔄 按任意键重试",
                "textSize": "16sp",
                "textColor": "#FFFFFFFF"
              }
            }
          ]
        }
        """.trimIndent()
        
        CxrApi.getInstance().openCustomView(errorJson)
    }
    
    // 全局异常捕获
    private fun setupGlobalExceptionHandler() {
        val defaultHandler = Thread.getDefaultUncaughtExceptionHandler()
        
        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
            GlobalScope.launch {
                handleGlobalException(throwable, "thread_${thread.name}")
            }
            
            // 调用默认处理程序
            defaultHandler?.uncaughtException(thread, throwable)
        }
    }
    
    suspend fun handleGlobalException(throwable: Throwable, context: String) {
        // 1. 记录严重异常
        errorLogger.logFatalException(throwable, context)
        
        // 2. 保存当前状态
        saveCurrentStateBeforeCrash()
        
        // 3. 尝试优雅降级
        enterSafeMode()
        
        // 4. 通知用户
        notifyUser("系统发生严重错误，正在尝试恢复。请稍后重试或重启应用。")
        
        // 5. 上传错误报告
        uploadCrashReport(throwable, context)
    }
    
    private suspend fun enterSafeMode() {
        // 1. 关闭非核心功能
        CxrApi.getInstance().closeCustomView()
        stopCameraStream()
        
        // 2. 释放资源
        releaseHeavyResources()
        
        // 3. 重置连接
        resetConnections()
        
        // 4. 显示安全模式界面
        showSafeModeOverlay()
    }
    
    private fun showSafeModeOverlay() {
        val safeModeJson = """
        {
          "type": "LinearLayout",
          "props": {
            "layout_width": "match_parent",
            "layout_height": "match_parent",
            "orientation": "vertical",
            "gravity": "center",
            "backgroundColor": "#CC888888",
            "padding": "30dp"
          },
          "children": [
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "安全模式",
                "textSize": "28sp",
                "textColor": "#FFFF9900",
                "textStyle": "bold",
                "marginBottom": "15dp"
              }
            },
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "系统检测到异常，已进入安全模式",
                "textSize": "20sp",
                "textColor": "#FFFFFFFF",
                "marginBottom": "10dp",
                "gravity": "center"
              }
            },
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "可用功能：基础诊断、联系支持",
                "textSize": "18sp",
                "textColor": "#FF99CC00",
                "marginBottom": "25dp",
                "gravity": "center"
              }
            },
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "✅ 按任意键继续",
                "textSize": "18sp",
                "textColor": "#FFFFFFFF"
              }
            }
          ]
        }
        """.trimIndent()
        
        CxrApi.getInstance().openCustomView(safeModeJson)
    }
}

class DiagnosticAssistantTestSuite {
    
    @Test
    fun testDeviceConnectionFlow() {
        // 1. 模拟蓝牙设备发现
        val mockDevice = createMockBluetoothDevice("Rokid_Glasses_Pro")
        
        // 2. 初始化连接
        val connectionResult = runBlocking {
            withTimeout(5000) {
                connectionManager.connectToDevice(mockDevice)
            }
        }
        
        // 3. 验证连接状态
        assertTrue(connectionResult.success)
        assertTrue(connectionManager.isBluetoothConnected)
        
        // 4. 模拟Wi-Fi连接
        val wifiResult = connectionManager.initWifiConnection()
        assertTrue(wifiResult.success || wifiResult.status == "wifi_disabled") // 允许Wi-Fi未启用
        
        // 5. 验证设备信息获取
        val deviceInfo = connectionManager.getDeviceInfo()
        assertNotNull(deviceInfo)
        assertEquals("Rokid_Glasses_Pro", deviceInfo.model)
    }
    
    @Test
    fun testApplianceRecognitionAccuracy() {
        // 1. 加载测试数据集
        val testImages = loadTestImagesFromAssets()
        
        // 2. 运行识别
        val results = testImages.map { image ->
            val recognitionResult = visualRecognizer.processFrame(image.bitmap)
            Triple(image.expectedType, recognitionResult.applianceType, recognitionResult.confidence)
        }
        
        // 3. 计算准确率
        val correctCount = results.count { (expected, actual, _) -> 
            expected == actual && confidence > 0.7 
        }
        
        val accuracy = correctCount.toDouble() / results.size
        assertTrue("识别准确率不足: $accuracy", accuracy >= 0.85)
        
        // 4. 检查故障检测
        val faultDetectionResults = results.map { (_, applianceType, _) ->
            val faultImage = loadFaultImageForAppliance(applianceType)
            val faultResult = faultDetector.detectFaults(faultImage)
            faultResult.faultRegions.isNotEmpty()
        }
        
        val faultDetectionRate = faultDetectionResults.count { it } / faultDetectionResults.size.toDouble()
        assertTrue("故障检测率不足: $faultDetectionRate", faultDetectionRate >= 0.8)
    }
    
    @Test
    fun testVoiceInteractionFlow() {
        // 1. 模拟用户语音输入
        val testScenarios = listOf(
            Triple("洗衣机不排水", "washing_machine", "drain_issue"),
            Triple("冰箱不制冷", "refrigerator", "cooling_issue"),
            Triple("空调漏水", "air_conditioner", "water_leak")
        )
        
        // 2. 测试诊断流程
        testScenarios.forEach { (utterance, expectedAppliance, expectedFault) ->
            val response = diagnosisEngine.handleVoiceInput(utterance, "unknown")
            
            // 验证设备识别
            assertNotNull(response.diagnosedAppliance)
            assertEquals(expectedAppliance, response.diagnosedAppliance)
            
            // 验证故障类型
            assertNotNull(response.diagnosedFault)
            assertTrue(response.diagnosedFault.contains(expectedFault))
            
            // 验证解决方案生成
            assertNotNull(response.solution)
            assertFalse(response.solution.isEmpty())
        }
    }
    
    @Test
    fun testArGuidanceRendering() {
        // 1. 创建测试维修步骤
        val testSteps = listOf(
            RepairStep("断电", "关闭电源开关", null, "⚠️ 安全第一", listOf("绝缘手套"), 2),
            RepairStep("拆卸", "移除外壳螺丝", "screw_removal.png", null, listOf("十字螺丝刀"), 5)
        )
        
        // 2. 生成AR JSON
        val arGenerator = ArRepairGuidanceSystem()
        val jsonOutput = arGenerator.createArOverlayJson(testSteps[0])
        
        // 3. 验证JSON结构
        val jsonObject = JSONObject(jsonOutput)
        assertEquals("LinearLayout", jsonObject.getString("type"))
        
        // 4. 验证关键元素存在
        val children = jsonObject.getJSONArray("children")
        assertTrue(children.length() > 3) // 至少包含标题、描述、导航等
        
        // 5. 模拟发送到眼镜
        val sendResult = simulateSendToGlasses(jsonOutput)
        assertTrue(sendResult.success)
    }
    
    @Test
    fun testErrorRecoveryScenarios() {
        // 1. 模拟蓝牙断开
        exceptionHandler.handleException(IOException("Bluetooth socket closed"), "bluetooth_connection")
        
        // 2. 验证恢复尝试
        assertTrue(connectionManager.isAttemptingReconnect)
        
        // 3. 模拟AI服务超时
        exceptionHandler.handleException(TimeoutException("AI service timeout"), "diagnosis_ai")
        
        // 4. 验证降级策略
        assertTrue(diagnosisEngine.isUsingCachedData)
        
        // 5. 模拟内存不足
        exceptionHandler.handleException(OutOfMemoryError("Memory exhausted"), "image_processing")
        
        // 6. 验证资源清理
        assertTrue(performanceOptimizer.isCacheCleared)
    }
}