「睛」准识人：基于Rokid AI眼镜的智能名片识别与管理系统开发实战

class DeviceConnectionManager(context: Context) {
    private val bluetoothHelper = BluetoothHelper(context as AppCompatActivity, 
        { status -> handleInitStatus(status) },
        { deviceFound() }
    )
    
    private fun initConnection() {
        // 1. 检查并申请必要权限
        bluetoothHelper.checkPermissions()
        
        // 2. 初始化蓝牙连接
        bluetoothHelper.permissionResult.observeForever { granted ->
            if (granted) {
                bluetoothHelper.startScan()
            }
        }
    }
    
    private fun connectToDevice(device: BluetoothDevice) {
        // 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. 建立WiFi连接（用于图像传输）
                        CxrApi.getInstance().initWifiP2P(object : WifiP2PStatusCallback {
                            override fun onConnected() {
                                Log.d("Connection", "WiFi P2P connected successfully")
                                startBusinessCardRecognition()
                            }
                            
                            override fun onFailed(errorCode: ValueUtil.CxrWifiErrorCode?) {
                                Log.e("Connection", "WiFi P2P connection failed: $errorCode")
                            }
                        })
                    }
                }
            }
            
            override fun onConnected() {
                Log.d("Connection", "Bluetooth connected successfully")
            }
            
            override fun onFailed(errorCode: ValueUtil.CxrBluetoothErrorCode?) {
                Log.e("Connection", "Bluetooth connection failed: $errorCode")
            }
        })
    }
}

class BusinessCardCapture {
    private val photoResultCallback = object : PhotoResultCallback {
        override fun onPhotoResult(status: ValueUtil.CxrStatus?, photo: ByteArray?) {
            when (status) {
                ValueUtil.CxrStatus.RESPONSE_SUCCEED -> {
                    photo?.let { imageData ->
                        Log.d("Capture", "Photo captured successfully, size: ${imageData.size} bytes")
                        processBusinessCardImage(imageData)
                    }
                }
                ValueUtil.CxrStatus.RESPONSE_TIMEOUT -> {
                    Log.e("Capture", "Photo capture timeout")
                    retryCapture()
                }
                else -> {
                    Log.e("Capture", "Photo capture failed with status: $status")
                }
            }
        }
    }
    
    fun captureBusinessCard() {
        // 设置拍照参数：1280x720分辨率，80%质量
        val width = 1280
        val height = 720
        val quality = 80
        
        // 在AI场景中打开相机
        val openStatus = CxrApi.getInstance().openGlassCamera(width, height, quality)
        if (openStatus == ValueUtil.CxrStatus.REQUEST_SUCCEED) {
            Log.d("Capture", "Camera opened successfully")
            
            // 延迟500ms确保相机准备就绪
            Handler(Looper.getMainLooper()).postDelayed({
                // 拍摄名片照片
                val captureStatus = CxrApi.getInstance().takeGlassPhoto(
                    width, height, quality, photoResultCallback
                )
                if (captureStatus != ValueUtil.CxrStatus.REQUEST_SUCCEED) {
                    Log.e("Capture", "Failed to take photo: $captureStatus")
                }
            }, 500)
        } else {
            Log.e("Capture", "Failed to open camera: $openStatus")
        }
    }
    
    private fun processBusinessCardImage(imageData: ByteArray) {
        // 将WebP格式转换为Bitmap
        val bitmap = BitmapFactory.decodeByteArray(imageData, 0, imageData.size)
        
        // 启动图像处理流程
        viewModel.processBusinessCard(bitmap)
    }
}

class BusinessCardAIAssistant {
    private val aiEventListener = object : AiEventListener {
        override fun onAiKeyDown() {
            // 用户长按功能键，触发名片识别
            Log.d("AIAssistant", "Key long pressed, starting business card recognition")
            startBusinessCardRecognitionFlow()
        }
        
        override fun onAiExit() {
            Log.d("AIAssistant", "AI scene exited")
            // 清理资源
            cleanupResources()
        }
    }
    
    fun initAIAssistant() {
        // 设置AI事件监听器
        CxrApi.getInstance().setAiEventListener(aiEventListener)
        
        // 配置自定义AI助手场景
        val customSceneConfig = """
            {
                "scene_name": "BusinessCardRecognizer",
                "trigger_words": ["名片", "识别名片", "扫描名片"],
                "description": "通过语音或按键识别商务名片",
                "supported_actions": ["capture", "extract", "save", "share"]
            }
        """.trimIndent()
        
        // 配置AI助手
        configureCustomAIAssistant(customSceneConfig)
    }
    
    private fun startBusinessCardRecognitionFlow() {
        // 1. 通知眼镜端即将开始AI流程
        CxrApi.getInstance().sendAsrContent("正在准备识别名片，请将名片置于视野中央")
        
        // 2. 等待1秒，给用户准备时间
        Handler(Looper.getMainLooper()).postDelayed({
            // 3. 触发拍照
            BusinessCardCapture().captureBusinessCard()
        }, 1000)
    }
    
    private fun handleRecognitionResult(result: BusinessCardData) {
        // 构建TTS反馈内容
        val feedback = "已识别到${result.name}的名片，职位是${result.title}，来自${result.company}"
        
        // 发送TTS内容到眼镜
        CxrApi.getInstance().sendTtsContent(feedback)
        
        // 在手机端显示详细信息
        showBusinessCardDetails(result)
        
        // 准备保存选项
        prepareSaveOptions(result)
    }
    
    private fun prepareSaveOptions(result: BusinessCardData) {
        // 构建选项列表
        val options = "请选择操作：1.保存到通讯录 2.分享 3.稍后处理"
        CxrApi.getInstance().sendTtsContent(options)
        
        // 设置ASR监听，等待用户选择
        setupOptionListener(result)
    }
}

def preprocess_business_card(image):
    """
    名片图像预处理流程
    
    参数:
        image: 原始图像 (OpenCV格式)
        
    返回:
        processed_image: 预处理后的图像
        perspective_matrix: 透视变换矩阵 (用于后续坐标映射)
    """
    # 1. 自适应图像增强
    enhanced = adaptive_enhance(image)
    
    # 2. 边缘检测
    edges = detect_edges(enhanced)
    
    # 3. 轮廓查找 - 寻找最大矩形轮廓
    contours = find_contours(edges)
    card_contour = find_largest_rectangle(contours)
    
    # 4. 透视变换 - 将名片校正为正面视角
    if card_contour is not None:
        warped, matrix = perspective_transform(image, card_contour)
    else:
        # 未检测到名片轮廓，使用备用处理
        warped = fallback_preprocessing(image)
        matrix = None
    
    # 5. 二值化处理 - 针对不同背景的名片
    binary = adaptive_thresholding(warped)
    
    # 6. 噪点去除
    denoised = remove_noise(binary)
    
    return denoised, matrix

class BusinessCardParser:
    def __init__(self):
        # 初始化PaddleOCR
        self.ocr = PaddleOCR(use_angle_cls=True, lang="ch")
        
        # 加载名片信息提取模型
        self.info_extractor = load_info_extraction_model()
        
        # 初始化规则引擎
        self.rule_engine = BusinessCardRuleEngine()
    
    def extract_information(self, processed_image):
        """
        从预处理后的名片图像中提取结构化信息
        
        参数:
            processed_image: 预处理后的名片图像
            
        返回:
            structured_data: 结构化的名片信息
        """
        # 1. OCR文本识别
        ocr_results = self.ocr.ocr(processed_image, cls=True)
        
        # 2. 文本清洗与分组
        cleaned_text = self._clean_and_group_text(ocr_results)
        
        # 3. 关键信息提取
        extracted_info = self.info_extractor.predict(cleaned_text)
        
        # 4. 规则引擎验证与补充
        final_info = self.rule_engine.validate_and_enhance(extracted_info, cleaned_text)
        
        # 5. 构建结构化数据
        structured_data = self._build_structured_data(final_info)
        
        return structured_data
    
    def _clean_and_group_text(self, ocr_results):
        """文本清洗与空间分组"""
        # 实现文本清洗逻辑
        # ...
        return grouped_text_blocks
    
    def _build_structured_data(self, extracted_info):
        """构建结构化数据"""
        return {
            "name": extracted_info.get("name", ""),
            "title": extracted_info.get("title", ""),
            "company": extracted_info.get("company", ""),
            "phone": extracted_info.get("phone", ""),
            "email": extracted_info.get("email", ""),
            "address": extracted_info.get("address", ""),
            "website": extracted_info.get("website", ""),
            "social_media": extracted_info.get("social_media", {}),
            "confidence_scores": extracted_info.get("confidence", {})
        }

fun handleUserCorrection(field: String, correctedValue: String, cardId: String) {
    // 1. 更新本地数据库
    database.updateBusinessCardField(cardId, field, correctedValue)
    
    // 2. 记录修正样本
    feedbackRepository.recordCorrection(field, correctedValue)
    
    // 3. 重新训练模型（后台异步）
    if (feedbackRepository.shouldRetrainModel()) {
        viewModelScope.launch {
            retrainModelInBackground()
        }
    }
    
    // 4. 提供确认反馈
    val confirmation = "已将${getFieldDisplayName(field)}更新为$correctedValue"
    CxrApi.getInstance().sendTtsContent(confirmation)
    
    // 5. 询问是否需要保存其他信息
    CxrApi.getInstance().sendTtsContent("需要修正其他信息吗？可以说'姓名'、'电话'或'公司'")
}

{
  "type": "LinearLayout",
  "props": {
    "layout_width": "match_parent",
    "layout_height": "match_parent",
    "orientation": "vertical",
    "gravity": "center_horizontal",
    "paddingTop": "80dp",
    "backgroundColor": "#CC000000"
  },
  "children": [
    {
      "type": "TextView",
      "props": {
        "id": "title_text",
        "layout_width": "wrap_content",
        "layout_height": "wrap_content",
        "text": "名片识别助手",
        "textSize": "20sp",
        "textColor": "#FF00FF00",
        "textStyle": "bold",
        "marginBottom": "20dp"
      }
    },
    {
      "type": "TextView",
      "props": {
        "id": "status_text",
        "layout_width": "wrap_content",
        "layout_height": "wrap_content",
        "text": "请将名片置于视野中央",
        "textSize": "16sp",
        "textColor": "#FFFFFFFF",
        "marginBottom": "30dp"
      }
    },
    {
      "type": "RelativeLayout",
      "props": {
        "layout_width": "200dp",
        "layout_height": "200dp",
        "backgroundColor": "#44FFFFFF",
        "layout_marginBottom": "30dp"
      },
      "children": [
        {
          "type": "TextView",
          "props": {
            "id": "detection_status",
            "layout_width": "wrap_content",
            "layout_height": "wrap_content",
            "text": "· · ·",
            "textSize": "24sp",
            "textColor": "#FF00FF00",
            "layout_centerInParent": "true"
          }
        }
      ]
    },
    {
      "type": "TextView",
      "props": {
        "id": "instruction_text",
        "layout_width": "wrap_content",
        "layout_height": "wrap_content",
        "text": "长按功能键开始识别",
        "textSize": "14sp",
        "textColor": "#FFAAAAAA"
      }
    }
  ]
}

class PerformanceOptimizer {
    // 图像处理线程池
    private val imageProcessingExecutor = ThreadPoolExecutor(
        2, 4, 60, TimeUnit.SECONDS,
        LinkedBlockingQueue<Runnable>(),
        ThreadFactory { Thread(it, "ImageProcessingThread") }
    )
    
    // 内存缓存
    private val memoryCache = LruCache<String, Bitmap>(10 * 1024 * 1024) // 10MB
    
    // 懒加载模型
    private var ocrModel: OcrModel? = null
    
    fun processBusinessCardAsync(imageData: ByteArray, callback: (BusinessCardData?) -> Unit) {
        imageProcessingExecutor.execute {
            try {
                // 1. 重用Bitmap避免频繁分配
                val bitmap = decodeByteArrayWithReuse(imageData)
                
                // 2. 缩放图像至合适尺寸
                val scaledBitmap = scaleBitmap(bitmap, 1024)
                
                // 3. 惰性加载OCR模型
                if (ocrModel == null) {
                    ocrModel = loadOcrModelInBackground()
                }
                
                // 4. 分阶段处理，允许用户交互
                val preprocessed = preprocessImage(scaledBitmap)
                publishProgress(30) // 30%进度
                
                val ocrResults = ocrModel?.recognize(preprocessed)
                publishProgress(60) // 60%进度
                
                val extractedData = extractBusinessInfo(ocrResults)
                publishProgress(90) // 90%进度
                
                // 5. 缓存结果
                cacheResult(extractedData)
                
                // 6. 返回主线程更新UI
                Handler(Looper.getMainLooper()).post {
                    callback(extractedData)
                    publishProgress(100) // 100%完成
                }
            } catch (e: Exception) {
                Log.e("Performance", "Processing failed", e)
                Handler(Looper.getMainLooper()).post {
                    callback(null)
                    showProcessingError(e)
                }
            } finally {
                // 7. 及时回收资源
                System.gc()
            }
        }
    }
    
    private fun publishProgress(percent: Int) {
        // 通过TTS或AR界面更新进度
        if (percent % 30 == 0) {
            val message = when (percent) {
                30 -> "正在分析名片布局"
                60 -> "正在识别文字内容"
                90 -> "正在提取关键信息"
                100 -> "识别完成"
                else -> ""
            }
            if (message.isNotEmpty()) {
                CxrApi.getInstance().sendTtsContent(message)
            }
        }
    }
}

class PrivacyProtectionManager {
    fun encryptBusinessCardData(data: BusinessCardData): EncryptedData {
        // 使用Android KeyStore生成密钥
        val secretKey = generateOrRetrieveKey("business_card_key")
        
        // 序列化数据
        val serializedData = serializeBusinessCard(data)
        
        // AES加密
        val cipher = Cipher.getInstance("AES/GCM/NoPadding")
        cipher.init(Cipher.ENCRYPT_MODE, secretKey)
        
        // 添加认证标签
        val iv = cipher.iv
        val encryptedBytes = cipher.doFinal(serializedData.toByteArray())
        
        return EncryptedData(iv, encryptedBytes, System.currentTimeMillis())
    }
    
    fun decryptBusinessCardData(encryptedData: EncryptedData): BusinessCardData? {
        return try {
            val secretKey = retrieveKey("business_card_key")
            val cipher = Cipher.getInstance("AES/GCM/NoPadding")
            val gcmParamSpec = GCMParameterSpec(128, encryptedData.iv)
            cipher.init(Cipher.DECRYPT_MODE, secretKey, gcmParamSpec)
            
            val decryptedBytes = cipher.doFinal(encryptedData.data)
            deserializeBusinessCard(String(decryptedBytes))
        } catch (e: Exception) {
            Log.e("Privacy", "Decryption failed", e)
            null
        }
    }
    
    private fun shouldUploadToCloud(cardData: BusinessCardData): Boolean {
        // 检查用户隐私设置
        val preferences = context.getSharedPreferences("privacy_settings", Context.MODE_PRIVATE)
        val allowCloudSync = preferences.getBoolean("allow_cloud_sync", true)
        
        // 检查敏感字段
        val containsSensitiveInfo = cardData.email?.contains("@company.com") == true ||
                                   cardData.phone?.startsWith("内部") == true
        
        return allowCloudSync && !containsSensitiveInfo
    }
}