智眸守护-基于Rokid CXR-M SDK的慢性病AI全周期管理助手

// settings.gradle.kts
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        maven { url = uri("https://maven.rokid.com/repository/maven-public/") }
        google()
        mavenCentral()
    }
}

// build.gradle.kts
android {
    defaultConfig {
        minSdk = 28
        // 其他配置...
    }
}

dependencies {
    implementation("com.rokid.cxr:client-m:1.0.1-20250812.080117-2")
    // 其他依赖...
}

class ChronicDiseaseManager {
    private val bluetoothHelper: BluetoothHelper
    private var isBluetoothConnected = false
    private var isWifiConnected = false
    
    init {
        bluetoothHelper = BluetoothHelper(
            context = appContext, 
            initStatus = { status ->
                when(status) {
                    BluetoothHelper.INIT_STATUS.INIT_END -> startDeviceDiscovery()
                }
            },
            deviceFound = { scanForGlassesDevices() }
        )
    }
    
    fun initializeConnection() {
        // 首先检查权限
        bluetoothHelper.checkPermissions()
        
        // 注册连接状态监听
        CxrApi.getInstance().setBluetoothStatusCallback(object : BluetoothStatusCallback {
            override fun onConnected() {
                isBluetoothConnected = true
                Log.d("ChronicManager", "Glasses connected via Bluetooth")
                initWifiConnection() // 初始化Wi-Fi连接
            }
            
            override fun onDisconnected() {
                isBluetoothConnected = false
                attemptReconnect() // 尝试重连
            }
            
            override fun onConnectionInfo(socketUuid: String?, macAddress: String?, rokidAccount: String?, glassesType: Int) {
                // 保存设备信息用于后续重连
                persistDeviceConnectionInfo(socketUuid, macAddress)
            }
            
            override fun onFailed(errorCode: ValueUtil.CxrBluetoothErrorCode?) {
                Log.e("ChronicManager", "Bluetooth connection failed: ${errorCode?.name}")
                scheduleReconnectAttempt() // 调度重连尝试
            }
        })
    }
    
    private fun initWifiConnection() {
        if (isBluetoothConnected) {
            val status = CxrApi.getInstance().initWifiP2P(object : WifiP2PStatusCallback {
                override fun onConnected() {
                    isWifiConnected = true
                    Log.d("ChronicManager", "Wi-Fi P2P connected, ready for data sync")
                    startHealthDataMonitoring() // 开始健康数据监测
                }
                
                override fun onDisconnected() {
                    isWifiConnected = false
                    Log.w("ChronicManager", "Wi-Fi P2P disconnected, falling back to Bluetooth")
                }
                
                override fun onFailed(errorCode: ValueUtil.CxrWifiErrorCode?) {
                    Log.e("ChronicManager", "Wi-Fi connection failed: ${errorCode?.name}")
                    // 降级策略：仅使用蓝牙通道
                }
            })
            
            if (status == ValueUtil.CxrStatus.REQUEST_FAILED) {
                Log.w("ChronicManager", "Wi-Fi init failed, continuing with Bluetooth only")
            }
        }
    }
}

class MedicationManager {
    private val medicationSchedule = mutableListOf<Medication>()
    
    // 配置用药提醒
    fun setupMedicationReminders() {
        // 从本地数据库加载用药计划
        loadMedicationSchedule()
        
        // 配置提词器场景用于用药提醒
        val configStatus = CxrApi.getInstance().configWordTipsText(
            textSize = 18f,  // 字体大小
            lineSpace = 1.5f, // 行间距
            mode = "normal",  // 普通模式
            startPointX = 100, // 起始X坐标
            startPointY = 300, // 起始Y坐标
            width = 800,      // 宽度
            height = 400      // 高度
        )
        
        if (configStatus == ValueUtil.CxrStatus.REQUEST_SUCCEED) {
            startMedicationMonitor()
        }
    }
    
    private fun startMedicationMonitor() {
        val handler = Handler(Looper.getMainLooper())
        val runnable = object : Runnable {
            override fun run() {
                checkAndNotifyMedications()
                handler.postDelayed(this, 60000) // 每分钟检查一次
            }
        }
        handler.post(runnable)
    }
    
    private fun checkAndNotifyMedications() {
        val now = Calendar.getInstance()
        val currentHour = now.get(Calendar.HOUR_OF_DAY)
        val currentMinute = now.get(Calendar.MINUTE)
        
        medicationSchedule.filter { med ->
            med.hour == currentHour && med.minute == currentMinute && 
            med.isActive && !med.isTakenToday
        }.forEach { med ->
            showMedicationReminder(med)
        }
    }
    
    private fun showMedicationReminder(medication: Medication) {
        // 构建提醒内容
        val reminderText = """
            |【用药提醒】
            |药品: ${medication.name}
            |剂量: ${medication.dosage}
            |用法: ${medication.instructions}
            |""".trimMargin()
        
        // 通过提词器场景显示
        val status = CxrApi.getInstance().sendStream(
            ValueUtil.CxrStreamType.WORD_TIPS,
            reminderText.toByteArray(),
            "medication_reminder_${System.currentTimeMillis()}.txt",
            object : SendStatusCallback {
                override fun onSendSucceed() {
                    Log.d("MedicationManager", "Reminder sent successfully")
                    startMedicationResponseTimer(medication)
                }
                
                override fun onSendFailed(errorCode: ValueUtil.CxrSendErrorCode?) {
                    Log.e("MedicationManager", "Failed to send reminder: ${errorCode?.name}")
                    // 降级到手机通知
                    showPhoneNotification(medication)
                }
            }
        )
        
        // 同时在手机端显示通知
        showPhoneNotification(medication)
    }
    
    private fun startMedicationResponseTimer(medication: Medication) {
        // 启动10分钟倒计时，用户未确认则标记为未服用
        Handler(Looper.getMainLooper()).postDelayed({
            if (!medication.isConfirmed) {
                recordMissedMedication(medication)
                sendAlertToCaregiver(medication)
            }
        }, 600000) // 10分钟
    }
}

class HealthMonitor {
    private var lastBloodPressure: BloodPressureData? = null
    private var lastBloodGlucose: GlucoseData? = null
    
    // 启动健康数据监听
    fun startMonitoring() {
        // 监听眼镜端按键事件（用于手动记录）
        CxrApi.getInstance().setAiEventListener(object : AiEventListener {
            override fun onAiKeyDown() {
                showHealthMeasurementMenu()
            }
            
            override fun onAiKeyUp() {}
            override fun onAiExit() {}
        })
        
        // 监听电池状态（低电量提醒）
        CxrApi.getInstance().setBatteryLevelUpdateListener { level, charging ->
            if (level < 20 && !charging) {
                notifyLowBattery()
            }
        }
    }
    
    // 显示测量菜单
    private fun showHealthMeasurementMenu() {
        val menuContent = """
        {
          "type": "LinearLayout",
          "props": {
            "layout_width": "match_parent",
            "layout_height": "match_parent",
            "orientation": "vertical",
            "gravity": "center",
            "backgroundColor": "#FF1A1A1A"
          },
          "children": [
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "请选择测量项目",
                "textSize": "20sp",
                "textColor": "#FF00FF00",
                "marginBottom": "30dp"
              }
            },
            {
              "type": "LinearLayout",
              "props": {
                "layout_width": "match_parent",
                "layout_height": "wrap_content",
                "orientation": "horizontal",
                "gravity": "center"
              },
              "children": [
                {
                  "type": "TextView",
                  "props": {
                    "id": "btn_bp",
                    "layout_width": "150dp",
                    "layout_height": "80dp",
                    "text": "血压",
                    "textSize": "18sp",
                    "textColor": "#FFFFFFFF",
                    "backgroundColor": "#FF3366CC",
                    "gravity": "center",
                    "marginEnd": "20dp"
                  }
                },
                {
                  "type": "TextView",
                  "props": {
                    "id": "btn_glucose",
                    "layout_width": "150dp",
                    "layout_height": "80dp",
                    "text": "血糖",
                    "textSize": "18sp",
                    "textColor": "#FFFFFFFF",
                    "backgroundColor": "#FFCC3366",
                    "gravity": "center"
                  }
                }
              ]
            }
          ]
        }
        """.trimIndent()
        
        CxrApi.getInstance().openCustomView(menuContent)
        
        // 设置自定义视图监听
        CxrApi.getInstance().setCustomViewListener(object : CustomViewListener {
            override fun onOpened() {}
            override fun onClosed() {}
            override fun onUpdated() {}
            override fun onOpenFailed(p0: Int) {}
            override fun onIconsSent() {}
        })
    }
    
    // 记录血压数据
    fun recordBloodPressure(systolic: Int, diastolic: Int) {
        val bpData = BloodPressureData(
            timestamp = System.currentTimeMillis(),
            systolic = systolic,
            diastolic = diastolic
        )
        
        lastBloodPressure = bpData
        saveToDatabase(bpData)
        
        // 云端同步
        if (isWifiConnected) {
            syncHealthDataToCloud()
        }
        
        // 分析异常
        checkBloodPressureAlert(bpData)
    }
}

class AIHealthAssistant {
    private val speechRecognizer = SpeechRecognizer()
    private val ttsEngine = TextToSpeechEngine()
    
    fun initializeAIAssistant() {
        // 配置AI助手场景
        CxrApi.getInstance().setAiEventListener(object : AiEventListener {
            override fun onAiKeyDown() {
                startListening()
            }
            
            override fun onAiKeyUp() {}
            override fun onAiExit() {
                stopListening()
            }
        })
    }
    
    private fun startListening() {
        speechRecognizer.startRecording { audioData ->
            // 处理语音数据
            processVoiceInput(audioData)
        }
    }
    
    private fun processVoiceInput(audioData: ByteArray) {
        // 调用ASR服务
        val asrResult = speechRecognizer.recognize(audioData)
        
        if (asrResult.isEmpty()) {
            CxrApi.getInstance().notifyAsrNone()
            return
        }
        
        // 发送ASR结果到眼镜
        CxrApi.getInstance().sendAsrContent(asrResult)
        
        // 处理用户指令
        handleUserCommand(asrResult)
    }
    
    private fun handleUserCommand(command: String) {
        when {
            command.contains("血压") -> {
                val response = generateBloodPressureResponse()
                sendAIResponse(response)
            }
            command.contains("血糖") || command.contains("糖") -> {
                val response = generateGlucoseResponse()
                sendAIResponse(response)
            }
            command.contains("用药") || command.contains("药") -> {
                val response = generateMedicationResponse()
                sendAIResponse(response)
            }
            command.contains("症状") || command.contains("不舒服") -> {
                handleSymptomReporting(command)
            }
            else -> {
                val genericResponse = "您好，我是您的慢性病管理助手。您可以询问血压、血糖、用药情况，或者报告症状。"
                sendAIResponse(genericResponse)
            }
        }
    }
    
    private fun sendAIResponse(response: String) {
        // 发送TTS内容
        CxrApi.getInstance().sendTtsContent(response)
        
        // 等待TTS播放完成
        Handler(Looper.getMainLooper()).postDelayed({
            CxrApi.getInstance().notifyTtsAudioFinished()
        }, calculateTTSPlayTime(response))
    }
    
    private fun handleSymptomReporting(command: String) {
        // 启动症状报告流程
        val symptomMenu = """
        {
          "type": "LinearLayout",
          "props": {
            "layout_width": "match_parent",
            "layout_height": "match_parent",
            "orientation": "vertical",
            "paddingTop": "100dp",
            "backgroundColor": "#FF1A1A1A"
          },
          "children": [
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "请描述您的症状",
                "textSize": "20sp",
                "textColor": "#FF00FF00",
                "marginBottom": "20dp"
              }
            },
            {
              "type": "TextView",
              "props": {
                "id": "btn_headache",
                "layout_width": "match_parent",
                "layout_height": "60dp",
                "text": "头痛",
                "textSize": "16sp",
                "gravity": "center",
                "backgroundColor": "#FF3366CC",
                "marginBottom": "10dp"
              }
            },
            {
              "type": "TextView",
              "props": {
                "id": "btn_dizzy",
                "layout_width": "match_parent",
                "layout_height": "60dp",
                "text": "头晕",
                "textSize": "16sp",
                "gravity": "center",
                "backgroundColor": "#FFCC3366",
                "marginBottom": "10dp"
              }
            },
            {
              "type": "TextView",
              "props": {
                "id": "btn_chest",
                "layout_width": "match_parent",
                "layout_height": "60dp",
                "text": "胸闷/胸痛",
                "textSize": "16sp",
                "gravity": "center",
                "backgroundColor": "#FF66CC33",
                "marginBottom": "10dp"
              }
            },
            {
              "type": "TextView",
              "props": {
                "id": "btn_other",
                "layout_width": "match_parent",
                "layout_height": "60dp",
                "text": "其他症状",
                "textSize": "16sp",
                "gravity": "center",
                "backgroundColor": "#FF999999"
              }
            }
          ]
        }
        """.trimIndent()
        
        CxrApi.getInstance().openCustomView(symptomMenu)
    }
}

class EmergencyResponseSystem {
    private val emergencyContacts = mutableListOf<EmergencyContact>()
    private var lastEmergencyTime = 0L
    
    fun initializeEmergencySystem() {
        // 从本地存储加载紧急联系人
        loadEmergencyContacts()
        
        // 注册AI事件监听
        CxrApi.getInstance().setAiEventListener(object : AiEventListener {
            override fun onAiKeyDown() {
                // 检查是否为紧急情况（连续按压3次）
                checkForEmergencyTrigger()
            }
            
            override fun onAiKeyUp() {}
            override fun onAiExit() {}
        })
    }
    
    private fun checkForEmergencyTrigger() {
        val currentTime = System.currentTimeMillis()
        
        if (currentTime - lastEmergencyTime < 2000) {
            // 2秒内再次触发，视为紧急情况
            triggerEmergencyResponse()
        }
        
        lastEmergencyTime = currentTime
    }
    
    private fun triggerEmergencyResponse() {
        // 获取当前位置
        val location = getCurrentLocation()
        
        // 获取最近的健康数据
        val recentHealthData = getRecentHealthData()
        
        // 构建紧急消息
        val emergencyMessage = """
        【紧急求助】慢性病患者需要帮助！
        位置: ${location?.address ?: "未知位置"}
        坐标: ${location?.latitude}, ${location?.longitude}
        最近血压: ${recentHealthData.bloodPressure ?: "无数据"}
        最近血糖: ${recentHealthData.bloodGlucose ?: "无数据"}
        症状: ${recentHealthData.lastSymptom ?: "未报告"}
        患者信息: ${getUserProfile().medicalCondition}
        """.trimIndent()
        
        // 通过眼镜显示紧急界面
        showEmergencyInterface()
        
        // 通知紧急联系人
        notifyEmergencyContacts(emergencyMessage, location)
        
        // 拨打急救电话
        callEmergencyServices(location)
    }
    
    private fun showEmergencyInterface() {
        val emergencyContent = """
        {
          "type": "RelativeLayout",
          "props": {
            "layout_width": "match_parent",
            "layout_height": "match_parent",
            "backgroundColor": "#FFCC0000"
          },
          "children": [
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "EMERGENCY",
                "textSize": "32sp",
                "textColor": "#FFFFFFFF",
                "layout_centerInParent": "true"
              }
            },
            {
              "type": "TextView",
              "props": {
                "layout_width": "wrap_content",
                "layout_height": "wrap_content",
                "text": "HELP IS ON THE WAY",
                "textSize": "18sp",
                "textColor": "#FFFFFFFF",
                "layout_below": "emergency_text",
                "layout_centerHorizontal": "true",
                "marginTop": "20dp"
              }
            }
          ]
        }
        """.trimIndent()
        
        CxrApi.getInstance().openCustomView(emergencyContent)
    }
}

class HealthDataVisualizer {
    fun generateHealthReport(startDate: Long, endDate: Long): ByteArray {
        // 从数据库获取健康数据
        val bloodPressureData = database.getBloodPressureData(startDate, endDate)
        val glucoseData = database.getGlucoseData(startDate, endDate)
        val medicationAdherence = database.getMedicationAdherence(startDate, endDate)
        
        // 生成图表数据
        val chartData = buildChartData(bloodPressureData, glucoseData, medicationAdherence)
        
        // 生成PDF报告
        return generatePDFReport(chartData)
    }
    
    private fun buildChartData(bpData: List<BloodPressureData>, 
                              glucoseData: List<GlucoseData>,
                              adherence: MedicationAdherence): HealthChartData {
        // 构建血压趋势
        val bpTrend = bpData.map { data ->
            HealthTrendPoint(
                timestamp = data.timestamp,
                systolic = data.systolic,
                diastolic = data.diastolic
            )
        }
        
        // 构建血糖趋势
        val glucoseTrend = glucoseData.map { data ->
            HealthTrendPoint(
                timestamp = data.timestamp,
                value = data.value
            )
        }
        
        return HealthChartData(
            bpTrend = bpTrend,
            glucoseTrend = glucoseTrend,
            adherenceRate = adherence.rate,
            missedMedications = adherence.missedCount
        )
    }
    
    // 通过眼镜拍照功能获取医疗文档
    fun captureMedicalDocument(width: Int = 1280, height: Int = 720) {
        CxrApi.getInstance().takeGlassPhoto(
            width = width,
            height = height,
            quality = 85,
            callback = object : PhotoResultCallback {
                override fun onPhotoResult(status: ValueUtil.CxrStatus?, photo: ByteArray?) {
                    if (status == ValueUtil.CxrStatus.RESPONSE_SUCCEED && photo != null) {
                        processMedicalDocument(photo)
                    } else {
                        Log.e("HealthVisualizer", "Failed to capture document: $status")
                    }
                }
            }
        )
    }
}

class PowerOptimizer {
    private var lastFullSyncTime = 0L
    private val SYNC_INTERVAL = 2 * 60 * 60 * 1000 // 2小时
    
    fun optimizePowerUsage() {
        // 监听眼镜电量
        CxrApi.getInstance().setBatteryLevelUpdateListener { level, charging ->
            handleBatteryLevelChange(level, charging)
        }
        
        // 优化数据同步频率
        scheduleOptimizedSyncs()
    }
    
    private fun handleBatteryLevelChange(level: Int, charging: Boolean) {
        when {
            level < 15 && !charging -> {
                // 低电量模式：关闭非核心功能
                enableLowPowerMode()
            }
            level >= 80 && charging -> {
                // 高电量模式：执行完整数据同步
                performFullDataSync()
            }
        }
    }
    
    private fun enableLowPowerMode() {
        // 关闭Wi-Fi连接
        CxrApi.getInstance().deinitWifiP2P()
        
        // 降低数据采集频率
        healthMonitor.setSamplingRate(0.5f) // 50%频率
        
        // 禁用非关键提醒
        medicationManager.disableNonCriticalReminders()
        
        // 通知用户
        showLowPowerNotification()
    }
    
    private fun scheduleOptimizedSyncs() {
        val handler = Handler(Looper.getMainLooper())
        val runnable = object : Runnable {
            override fun run() {
                if (System.currentTimeMillis() - lastFullSyncTime > SYNC_INTERVAL) {
                    performOptimizedSync()
                }
                handler.postDelayed(this, 30 * 60 * 1000) // 30分钟检查一次
            }
        }
        handler.post(runnable)
    }
    
    private fun performOptimizedSync() {
        if (isWifiConnected && !isLowPowerMode) {
            // 高优先级数据：用药记录、异常症状
            syncCriticalData()
            
            // 低优先级数据：趋势分析、统计报表
            Handler(Looper.getMainLooper()).postDelayed({
                syncNonCriticalData()
            }, 5000) // 延迟5秒
            
            lastFullSyncTime = System.currentTimeMillis()
        }
    }
}