会议字幕识别涉及三个串联的阶段：组件初始化（onPrepared）、音频输入（writeAudio）、结果返回（onResult）。任何一个阶段失败，整个链路就中断。组件准备失败则无法接收音频；音频输入失败则无源数据可识别；结果返回失败则用户看不到字幕。本工程实现了这三个阶段的本地验证机制，但第三阶段（AI识别结果）依赖外部服务，工程本身无法保证识别准确率。因此本文的目标是建立实施口径：三个阶段应如何分开验证、每个阶段的失败标准是什么、配置变更（语言、样式）与识别准确性的独立性边界在哪里。

一、把"字幕识别"拆成四个独立验收结论

现场验收时不应笼统说"字幕功能可用"，而要拆分成四个彼此独立的结论，分别对应三个不同的链路阶段和一个配置验证：

验收结论	当前工程能否支持	现场可观察证据	下一责任方
组件已准备	可以	onPrepared回调触发，系统日志显示组件就绪，权限检查通过	应用开发
PCM数据已输入	可以	页面显示已写入的音频字节数，无丢失/错误，数据格式有效	应用对接
字幕已识别	部分	文本结果显示，但准确性依赖AI服务商的模型质量	AI服务商
语言样式已应用	可以	字幕以指定语言、指定字号、指定颜色显示，位置和透明度正确	应用开发

这四个结论对应：组件层的初始化可靠性、输入层的数据完整性、识别层的AI模型能力、显示层的样式配置。当现场出现"没有字幕"“字幕错得厉害”"字幕显示很小"时，应快速判断是组件问题、数据问题、AI问题还是配置问题。

二、项目功能详解：三阶段字幕识别的完整实现

2.1 组件初始化与权限检查：onPrepared阶段

字幕识别第一步是初始化组件。工程在应用启动时立即尝试创建和初始化字幕组件，同时检查系统权限和资源可用性：

interface AudioPermission {
  recordAudio: boolean;    // 是否有录音权限
  accessMicrophone: boolean;  // 是否有麦克风访问权限
}

interface ComponentState {
  initialized: boolean;
  readyForAudio: boolean;
  lastError?: string;
  permissionStatus: AudioPermission;
}

class AICaptionComponent {
  
  private componentState: ComponentState = {
    initialized: false,
    readyForAudio: false,
    permissionStatus: { recordAudio: false, accessMicrophone: false }
  };
  
  private initializationLog: InitializationRecord[] = [];
  
  // 应用启动时执行初始化
  public async initialize(): Promise<boolean> {
    this.log('INIT_START', '字幕组件初始化开始');
    
    try {
      // 第一步：检查权限
      const permissionStatus = await this.checkPermissions();
      this.componentState.permissionStatus = permissionStatus;
      
      if (!permissionStatus.recordAudio || !permissionStatus.accessMicrophone) {
        this.log('PERMISSION_DENIED', 
          `权限检查失败: recordAudio=${permissionStatus.recordAudio}, accessMicrophone=${permissionStatus.accessMicrophone}`);
        this.componentState.lastError = '缺少必要权限（录音或麦克风访问）';
        return false;
      }
      
      // 第二步：检查系统资源
      const resourceStatus = await this.checkSystemResources();
      if (!resourceStatus.microphoneAvailable || !resourceStatus.memoryAvailable) {
        this.log('RESOURCE_UNAVAILABLE',
          `系统资源不足: 麦克风=${resourceStatus.microphoneAvailable}, 内存=${resourceStatus.memoryAvailable}`);
        this.componentState.lastError = '系统资源不可用（麦克风被占用或内存不足）';
        return false;
      }
      
      // 第三步：初始化音频采集组件
      await this.initializeAudioCapture();
      this.log('AUDIO_CAPTURE_READY', '音频采集已准备');
      
      // 第四步：初始化识别组件
      await this.initializeRecognitionComponent();
      this.log('RECOGNITION_COMPONENT_READY', '识别组件已准备');
      
      // 第五步：注册回调
      this.registerCallbacks();
      this.log('CALLBACKS_REGISTERED', '事件回调已注册');
      
      // 标记组件已就绪
      this.componentState.initialized = true;
      this.componentState.readyForAudio = true;
      this.log('INIT_SUCCESS', '字幕组件初始化完成，已准备接收音频');
      
      return true;
      
    } catch (error) {
      this.componentState.initialized = false;
      this.componentState.readyForAudio = false;
      this.componentState.lastError = error.message;
      this.log('INIT_FAILED', `初始化失败: ${error.message}`);
      return false;
    }
  }
  
  // 检查必要权限
  private async checkPermissions(): Promise<AudioPermission> {
    const recordAudio = await this.requestPermission('android.permission.RECORD_AUDIO');
    const accessMicrophone = await this.requestPermission('android.permission.MODIFY_AUDIO_SETTINGS');
    
    return { recordAudio, accessMicrophone };
  }
  
  // 检查系统资源
  private async checkSystemResources(): Promise<any> {
    const microphone = await this.checkMicrophoneAvailability();
    const memory = await this.checkAvailableMemory();
    
    return {
      microphoneAvailable: microphone,
      memoryAvailable: memory > 50 * 1024 * 1024  // 至少50MB
    };
  }
  
  // 注册所有事件回调
  private registerCallbacks(): void {
    // 当组件准备就绪时调用
    this.onPrepared = () => {
      this.log('CALLBACK_ON_PREPARED', '组件已触发onPrepared事件');
    };
    
    // 当识别开始时调用
    this.onStart = () => {
      this.log('CALLBACK_ON_START', '识别已开始');
    };
    
    // 当识别完成时调用
    this.onResult = (result: CaptionResult) => {
      this.log('CALLBACK_ON_RESULT', `识别完成: ${result.text}`);
    };
    
    // 当识别出错时调用
    this.onError = (error: Error) => {
      this.log('CALLBACK_ON_ERROR', `识别出错: ${error.message}`);
    };
  }
  
  private log(action: string, message: string): void {
    this.initializationLog.push({
      timestamp: new Date().toISOString(),
      action,
      message
    });
    console.log(`[${action}] ${message}`);
  }
  
  // 获取初始化日志（用于现场诊断）
  public getInitializationLog(): InitializationRecord[] {
    return this.initializationLog;
  }
  
  // 获取组件当前状态
  public getComponentState(): ComponentState {
    return { ...this.componentState };
  }
}

这段代码能支撑的验收结论：

• 应用启动时能检查权限和资源
• 初始化成功时onPrepared回调会触发
• 初始化失败时有明确的错误日志
• 所有初始化步骤都被记录，便于诊断

它不能支撑的结论：

• 系统权限由应用自动获得（需要用户授权）
• 麦克风会自动恢复可用状态（可能需要重启设备）
• 识别准确率在初始化时就能保证

2.2 PCM音频数据的输入与验证：writeAudio阶段

组件初始化成功后，下一步是向组件写入PCM音频数据。工程实现了音频缓冲区、数据有效性检查、以及丢包检测：

interface AudioBuffer {
  data: Uint8Array;
  sampleRate: number;     // 采样率，如16000 Hz
  channels: number;        // 声道数，如1（单声道）
  bitsPerSample: number;  // 每个采样的比特数，如16
  timestamp: number;       // 写入时的时间戳
}

interface AudioWriteResult {
  success: boolean;
  bytesWritten: number;
  totalBytesWritten: number;
  droppedPackets: number;
  message: string;
}

class AICaptionAudioInput {
  
  private audioBuffer: AudioBuffer[] = [];
  private totalBytesWritten: number = 0;
  private droppedPackets: number = 0;
  private audioWriteLog: AudioWriteRecord[] = [];
  
  // 核心操作：写入PCM音频数据
  public writeAudio(audioData: Uint8Array, sampleRate: number = 16000): AudioWriteResult {
    
    // 第一步：验证组件是否已准备
    if (!this.isComponentReady()) {
      const result = {
        success: false,
        bytesWritten: 0,
        totalBytesWritten: this.totalBytesWritten,
        droppedPackets: this.droppedPackets,
        message: '组件未准备就绪，无法写入数据'
      };
      this.logAudioWrite(result, audioData.length);
      return result;
    }
    
    // 第二步：验证音频数据的有效性
    const validation = this.validateAudioData(audioData, sampleRate);
    if (!validation.isValid) {
      const result = {
        success: false,
        bytesWritten: 0,
        totalBytesWritten: this.totalBytesWritten,
        droppedPackets: this.droppedPackets,
        message: `音频数据验证失败: ${validation.error}`
      };
      this.logAudioWrite(result, audioData.length);
      return result;
    }
    
    // 第三步：检查缓冲区是否已满
    const currentBufferSize = this.audioBuffer.reduce((sum, buf) => sum + buf.data.length, 0);
    const MAX_BUFFER_SIZE = 1024 * 1024;  // 1MB缓冲区
    
    if (currentBufferSize + audioData.length > MAX_BUFFER_SIZE) {
      this.droppedPackets++;
      const result = {
        success: false,
        bytesWritten: 0,
        totalBytesWritten: this.totalBytesWritten,
        droppedPackets: this.droppedPackets,
        message: `缓冲区已满，丢弃本包。已丢弃${this.droppedPackets}个包`
      };
      this.logAudioWrite(result, audioData.length);
      return result;
    }
    
    // 第四步：将数据写入缓冲区
    const buffer: AudioBuffer = {
      data: audioData,
      sampleRate,
      channels: 1,
      bitsPerSample: 16,
      timestamp: Date.now()
    };
    
    this.audioBuffer.push(buffer);
    this.totalBytesWritten += audioData.length;
    
    // 第五步：尝试处理缓冲区中的数据
    this.processAudioBuffer();
    
    const result = {
      success: true,
      bytesWritten: audioData.length,
      totalBytesWritten: this.totalBytesWritten,
      droppedPackets: this.droppedPackets,
      message: `已写入${audioData.length}字节，总计${this.totalBytesWritten}字节`
    };
    
    this.logAudioWrite(result, audioData.length);
    return result;
  }
  
  // 验证音频数据的有效性
  private validateAudioData(
    audioData: Uint8Array,
    sampleRate: number
  ): { isValid: boolean; error?: string } {
    
    // 检查数据不为空
    if (!audioData || audioData.length === 0) {
      return { isValid: false, error: '音频数据为空' };
    }
    
    // 检查数据长度是偶数（PCM 16bit = 2字节）
    if (audioData.length % 2 !== 0) {
      return { isValid: false, error: '音频数据长度不是偶数，不符合PCM 16bit格式' };
    }
    
    // 检查采样率
    const validSampleRates = [8000, 16000, 32000, 48000];
    if (!validSampleRates.includes(sampleRate)) {
      return { isValid: false, error: `采样率${sampleRate}不支持，应为${validSampleRates.join('/')}` };
    }
    
    // 检查数据内容（检查是否全为0或全为最大值，通常表示静音或异常）
    const max = Math.max(...audioData);
    const min = Math.min(...audioData);
    if (max === 0 && min === 0) {
      // 允许短暂的静音，但长时间的静音可能表示麦克风问题
      return { isValid: true };  // 暂时允许，交由应用逻辑处理
    }
    
    return { isValid: true };
  }
  
  // 处理音频缓冲区
  private processAudioBuffer(): void {
    if (this.audioBuffer.length === 0) {
      return;
    }
    
    // 从缓冲区中取出数据，发送给识别引擎
    // 这里仅展示提取逻辑，实际的识别调用交由上层处理
    const batch = this.audioBuffer.splice(0, Math.min(10, this.audioBuffer.length));
    
    for (const buffer of batch) {
      // 实际发送给AI服务
      this.sendToRecognitionEngine(buffer);
    }
  }
  
  private sendToRecognitionEngine(buffer: AudioBuffer): void {
    // 这是一个桩函数，真实项目中应调用AI服务的API
    console.log(`[发送到识别引擎] ${buffer.data.length}字节，采样率${buffer.sampleRate}Hz`);
  }
  
  private logAudioWrite(result: AudioWriteResult, dataSize: number): void {
    this.audioWriteLog.push({
      timestamp: new Date().toISOString(),
      success: result.success,
      bytesWritten: result.bytesWritten,
      totalBytes: result.totalBytesWritten,
      droppedPackets: result.droppedPackets,
      message: result.message
    });
  }
  
  // 获取音频写入日志（用于现场诊断）
  public getAudioWriteLog(): AudioWriteRecord[] {
    return this.audioWriteLog;
  }
  
  // 获取当前的音频缓冲区大小
  public getBufferSize(): { current: number; max: number } {
    const current = this.audioBuffer.reduce((sum, buf) => sum + buf.data.length, 0);
    return { current, max: 1024 * 1024 };
  }
  
  private isComponentReady(): boolean {
    // 检查组件是否已初始化并准备好
    return true;  // 简化实现
  }
}

这段代码能支撑的验收结论：

• 音频数据能被成功写入缓冲区
• 数据格式（PCM 16bit）被验证
• 缓冲区满时能检测到并记录丢包
• 每一次写入操作都被记录

它不能支撑的结论：

• 音频数据能被AI服务正确处理
• 识别延迟会在某个特定范围内
• 静音检测能自动停止录音

2.3 识别结果返回与准确性边界：onResult阶段

识别完成后，AI服务返回识别结果。工程实现了结果解析、准确性统计、以及结果显示：

interface CaptionResult {
  text: string;
  confidence: number;       // 识别置信度，0-1
  startTime: number;        // 识别结果对应的音频开始时间（毫秒）
  endTime: number;          // 结束时间
  isFinal: boolean;         // 是否是最终结果
  language: string;         // 识别的语言
}

interface AccuracyMetrics {
  totalWords: number;
  correctWords: number;
  accuracy: number;         // 准确率，0-100
  confidenceAverage: number;
  lowConfidenceItems: CaptionResult[];  // 置信度 < 0.7的项
}

class AICaptionResult {
  
  private recognitionResults: CaptionResult[] = [];
  private accuracyMetrics: AccuracyMetrics = {
    totalWords: 0,
    correctWords: 0,
    accuracy: 0,
    confidenceAverage: 0,
    lowConfidenceItems: []
  };
  private resultLog: ResultRecord[] = [];
  
  // 接收识别结果
  public onResult(result: CaptionResult): void {
    
    // 第一步：验证结果格式
    if (!this.validateResultFormat(result)) {
      this.logResult('INVALID_RESULT', `结果格式错误: ${JSON.stringify(result)}`);
      return;
    }
    
    // 第二步：记录结果
    this.recognitionResults.push(result);
    this.logResult('RESULT_RECEIVED', `识别: "${result.text}" (置信度: ${result.confidence.toFixed(2)})`);
    
    // 第三步：更新准确性统计
    this.updateAccuracyMetrics(result);
    
    // 第四步：检查置信度
    if (result.confidence < 0.7) {
      this.accuracyMetrics.lowConfidenceItems.push(result);
      this.logResult('LOW_CONFIDENCE', 
        `低置信度结果: "${result.text}" (${result.confidence.toFixed(2)})`);
    }
    
    // 第五步：是否需要提醒用户审查
    if (result.confidence < 0.5) {
      this.logResult('NEEDS_REVIEW', 
        `警告: 置信度过低 ${result.confidence.toFixed(2)}, 建议用户手动审查`);
    }
    
    // 第六步：显示字幕（交由UI层处理）
    this.displayCaption(result);
  }
  
  // 验证结果格式
  private validateResultFormat(result: CaptionResult): boolean {
    if (!result || typeof result !== 'object') {
      return false;
    }
    if (typeof result.text !== 'string' || result.text.length === 0) {
      return false;
    }
    if (typeof result.confidence !== 'number' || result.confidence < 0 || result.confidence > 1) {
      return false;
    }
    if (typeof result.startTime !== 'number' || typeof result.endTime !== 'number') {
      return false;
    }
    return true;
  }
  
  // 更新准确性统计
  private updateAccuracyMetrics(result: CaptionResult): void {
    const wordCount = result.text.split(/\s+/).length;
    this.accuracyMetrics.totalWords += wordCount;
    
    // 简化的准确性评估：置信度 >= 0.85 认为正确
    // 真实项目应与标准转写稿对比
    if (result.confidence >= 0.85) {
      this.accuracyMetrics.correctWords += wordCount;
    }
    
    // 更新平均置信度
    const allConfidences = this.recognitionResults.map(r => r.confidence);
    this.accuracyMetrics.confidenceAverage = 
      allConfidences.reduce((a, b) => a + b, 0) / allConfidences.length;
    
    // 计算准确率
    this.accuracyMetrics.accuracy = this.accuracyMetrics.totalWords > 0
      ? (this.accuracyMetrics.correctWords / this.accuracyMetrics.totalWords) * 100
      : 0;
  }
  
  // 显示字幕
  private displayCaption(result: CaptionResult): void {
    // 这是一个桩函数，真实UI层应处理显示逻辑
    console.log(`[显示字幕] ${result.text}`);
  }
  
  private logResult(action: string, message: string): void {
    this.resultLog.push({
      timestamp: new Date().toISOString(),
      action,
      message
    });
  }
  
  // 获取准确性指标
  public getAccuracyMetrics(): AccuracyMetrics {
    return { ...this.accuracyMetrics };
  }
  
  // 获取识别结果日志
  public getResultLog(): ResultRecord[] {
    return this.resultLog;
  }
  
  // 获取所有识别结果
  public getAllResults(): CaptionResult[] {
    return [...this.recognitionResults];
  }
  
  // 计算完整的识别准确率（需要标准转写稿）
  public calculateAccuracyVsGoldenTranscription(goldenText: string): number {
    const recognizedText = this.recognitionResults
      .map(r => r.text)
      .join(' ');
    
    // 使用编辑距离（Levenshtein Distance）计算相似度
    const similarity = this.calculateStringSimilarity(recognizedText, goldenText);
    return similarity * 100;
  }
  
  private calculateStringSimilarity(str1: string, str2: string): number {
    // 简化的相似度计算（真实项目应使用更复杂的算法）
    const longer = str1.length > str2.length ? str1 : str2;
    const shorter = str1.length > str2.length ? str2 : str1;
    
    if (longer.length === 0) {
      return 1.0;
    }
    
    const editDistance = this.calculateEditDistance(longer, shorter);
    return (longer.length - editDistance) / longer.length;
  }
  
  private calculateEditDistance(s1: string, s2: string): number {
    // Levenshtein距离算法
    const costs = [];
    for (let k = 0; k <= s1.length; k++) {
      let lastValue = k;
      for (let j = 0; j <= s2.length; j++) {
        if (k === 0) {
          costs[j] = j;
        } else if (j > 0) {
          let newValue = costs[j - 1];
          if (s1.charAt(k - 1) !== s2.charAt(j - 1)) {
            newValue = Math.min(Math.min(newValue, lastValue), costs[j]) + 1;
          }
          costs[j - 1] = lastValue;
          lastValue = newValue;
        }
      }
      if (k > 0) {
        costs[s2.length] = lastValue;
      }
    }
    return costs[s2.length];
  }
}

这段代码能支撑的验收结论：

• 识别结果能被正确解析和记录
• 置信度能被统计和显示
• 低置信度的结果能被标记为需要审查
• 相对准确率能根据置信度计算

它不能支撑的结论：

• 识别准确率一定会达到90%以上（取决于AI模型）
• 置信度 > 0.85的结果一定是正确的（仅是一个启发式判断）
• 与标准转写稿的对比能自动完成（需要人工提供转写稿）

2.4 现场验收的三层检查流程

实施顾问在现场应按以下步骤逐层验证字幕识别链路：

验收层	检查项	操作	预期结果	失败处理
L1：初始化	权限	打开应用，查看DevTools或系统日志	onPrepared事件触发，无权限错误	检查系统权限，手动授予录音权限
L1：初始化	资源	长按待机键查看系统资源	麦克风空闲，内存 > 50MB	关闭其他应用，释放系统资源
L2：音频输入	数据格式	连接麦克风，录音10秒	页面显示"已写入XXXX字节"	检查PCM格式是否正确
L2：音频输入	无丢包	查看日志或状态页面	“已丢弃0个包”	检查缓冲区大小设置
L3：识别结果	显示	待应用完成识别	字幕文本出现在屏幕	检查UI是否正确呈现
L3：准确率	对标准	与10分钟的标准转写稿对比	准确率 > 85%	评估是否接受或需要优化

---

三、企业实施风险预案与分阶段交付

3.1 AI字幕识别的六大风险识别与应急方案

风险项	等级	预防措施	检测方法	应急方案	恢复步骤	责任人
组件初始化失败	严重	① 应用启动时即初始化 ② 初始化前检查系统资源 ③ 失败自动重试（最多3次）	打开应用，查日志是否有onPrepared；检查权限	① 自动重试初始化 ② 降级到纯文字输入模式 ③ 重启应用	组件已准备，onPrepared触发	应用开发
音频输入中断	高	① 持续监测音频流 ② 中断时立即告知用户 ③ 实现音频缓冲和重连机制	录音中拔掉耳机，观察是否检测到；查日志	① 提示用户检查麦克风 ② 暂停识别，等待恢复 ③ 显示已识别的部分	音频恢复，识别继续	应用开发
识别准确率低	高	① 选择准确度高的AI服务 ② 针对行业进行模型优化 ③ 提供用户反馈机制 ④ 定期对标测试	与真实转写稿对比，准确率是否 > 90%；统计用户修正频率	① 提示用户手动修正 ② 允许用户重新开始识别 ③ 使用备用AI服务	准确率已恢复到可接受水平	AI服务商
网络连接失败	高	① 本地缓冲音频数据 ② 网络检查机制 ③ 自动重试逻辑 ④ 离线模式提示	断网环境下录音，观察是否有错误提示；检查网络状态	① 自动重试连接（指数退避） ② 缓冲数据等待网络恢复 ③ 提示用户离线模式	网络恢复，缓冲数据上传	应用开发
配置变更导致显示混乱	中	① 配置变更前做验证 ② 字号/颜色范围检查 ③ 配置版本控制	修改语言/字号/颜色配置，观察字幕是否正确显示；检查日志	① 回滚到上一个配置 ② 手动调整样式参数 ③ 清缓存重启	显示样式正确	应用开发
多语言支持不完整	中	① 明确支持的语言列表 ② 用户选择时验证 ③ 不支持时有降级方案 ④ 测试主要语言	测试所有支持的语言，对比文档；选择不支持的语言，观察提示	① 显示支持语言列表 ② 自动使用默认语言 ③ 提示用户选择其他语言	切换到支持的语言	应用开发

3.2 分阶段交付计划与交接标准

第一期：组件初始化与PCM输入验证（2周）

交付范围：组件准备、音频采集、输入管道、本地验证

交接检查项	验收标准	验证方法
组件就绪	onPrepared触发，日志可见，无权限错误	打开应用，检查DevTools或系统日志
音频采集	录音 30秒，成功采集PCM数据，无丢失	查看页面显示的"已写入XXXX字节"
输入管道	数据完整性 > 99%，无丢包，格式有效	检查日志中的"已丢弃0个包"
错误处理	麦克风权限缺失时有提示，资源不足时能降级	禁用权限、释放资源后测试
设备兼容	≥2种设备型号正常工作	在不同Android版本设备上测试

回滚条件：

• 组件初始化失败
• 音频数据丢失 > 1%
• 权限处理不当导致应用崩溃

交接方：应用开发 → 应用对接

---

第二期：识别链路与结果验证（2周）

交付范围：AI服务集成、识别结果解析、准确性验证

交接检查项	验收标准	验证方法
识别集成	调用AI服务返回结果（模拟或真实），无超时	录音后等待识别完成，观察是否有结果
结果解析	文本、时间戳、置信度都能正确解析	对比识别结果和预期值
准确性	与标准转写稿对比，准确率 > 90%	采集标准样本，计算对标准的相似度
延迟控制	识别延迟 < 音频时长的1.5倍	记录音频开始和结果返回的时间差
置信度	置信度能区分高质量和低质量识别	观察低置信度的结果是否确实有错误

回滚条件：

• 准确率 < 85%
• 识别延迟 > 音频时长的2倍
• 结果解析错误
• AI服务不可用

交接方：应用对接 → AI服务商 → 测试团队

---

第三期：多语言与配置体验（2周）

交付范围：多语言支持、字幕显示、用户配置

交接检查项	验收标准	验证方法
语言支持	测试≥3种语言，识别结果正确	用各语言录音，对比转写稿
显示样式	字号/颜色/位置可配置，显示正确	调整配置参数，观察显示
配置持久化	用户配置在应用关闭后仍保留	修改配置，关闭再打开，检查是否恢复
实时同步	字幕与音频时间同步，延迟 < 500ms	对比音频播放和字幕显示的时间
多人使用	多个用户同时使用，无冲突	多个账户同时打开应用

回滚条件：

• 语言识别错误
• 显示样式混乱
• 配置不持久化
• 字幕同步延迟 > 1秒

交接方：应用开发 + 应用对接 → 安全部门验证 → 最终上线

3.3 阶段交接点检查

交接检查点	第一期→第二期	第二期→三期
稳定性观察	+1周，无新增bug，无崩溃	+1周，多人使用无冲突
数据准备	组件就绪，音频采集正常	100条音频样本已测试，标准转写稿已准备
参与角色	现场工程师 ✓、应用对接 ✓	AI服务商 ✓、语言支持 ✓
问题处理	第一期bug已全部修复	第二/三期bug确定责任方并跟进

---

四、现场场景（3个真实场景）

场景1：应用启动时组件初始化失败，用户无法使用字幕功能

背景：

• 用户在会议室打开应用
• 期望使用AI字幕功能辅助会议记录
• 但打开后字幕区域为空，没有字幕显示

诊断流程：

class InitializationFailureDiagnostics {
  
  public diagnoseInitializationFailure(): void {
    console.log(`🔍 诊断：组件初始化失败`);
    
    // 第1步：检查权限
    const permissionLog = getInitializationLog().filter(l => l.action.includes('PERMISSION'));
    if (permissionLog.some(l => l.message.includes('denied'))) {
      console.log(`❌ 权限问题: 系统未授予录音或麦克风权限`);
      console.log(`解决方案:`);
      console.log(`  1. 进入系统设置 > 应用权限`);
      console.log(`  2. 找到字幕应用`);
      console.log(`  3. 启用"录音"和"修改音频设置"权限`);
      console.log(`  4. 重启应用`);
      return;
    }
    
    // 第2步：检查系统资源
    const resourceLog = getInitializationLog().filter(l => l.action.includes('RESOURCE'));
    if (resourceLog.some(l => l.message.includes('unavailable'))) {
      console.log(`❌ 资源问题: 系统资源不足（麦克风被占用或内存不足）`);
      console.log(`解决方案:`);
      console.log(`  1. 检查是否有其他录音应用（通话、录音机等）正在运行`);
      console.log(`  2. 关闭这些应用`);
      console.log(`  3. 清理系统内存（关闭后台应用）`);
      console.log(`  4. 重启应用`);
      return;
    }
    
    // 第3步：检查音频采集
    const audioLog = getInitializationLog().filter(l => l.action.includes('AUDIO'));
    if (audioLog.some(l => l.message.includes('failed'))) {
      console.log(`❌ 音频采集问题: 无法初始化麦克风`);
      console.log(`解决方案:`);
      console.log(`  1. 检查设备麦克风是否连接`);
      console.log(`  2. 尝试使用其他应用（如录音机）测试麦克风`);
      console.log(`  3. 重启设备`);
      return;
    }
    
    // 第4步：通用初始化失败
    const initLog = getInitializationLog().find(l => l.action === 'INIT_FAILED');
    if (initLog) {
      console.log(`❌ 初始化失败: ${initLog.message}`);
      console.log(`解决方案: 重启应用或联系技术支持`);
    }
  }
}

现场处理步骤：

步骤	操作	预期结果
1	检查系统权限设置	录音权限已启用
2	关闭其他录音应用	麦克风变为空闲
3	重启字幕应用	组件初始化成功，onPrepared触发
4	查看DevTools或日志	无错误信息
5	尝试录音	字幕开始显示

---

场景2：音频识别准确率仅有60%，多个用户投诉"字幕错得厉害"

背景：

• AI字幕功能已上线，识别可以工作
• 但准确率仅60%，远低于预期的90%
• 用户开始投诉"还不如手工转写"

验证准确率的完整流程：

class AccuracyValidation {
  
  public validateAccuracy(): void {
    console.log(`📊 验证识别准确率`);
    
    // 第1步：采集测试样本
    const testAudio = recordTestAudio(600000);  // 录制10分钟的会议音频
    
    // 第2步：获取AI识别结果
    const aiResult = performRecognition(testAudio);
    const recognizedText = aiResult.text;
    
    // 第3步：获取标准转写（由专业转录员完成）
    const goldenTranscription = getGoldenTranscription();
    
    // 第4步：计算准确率
    const accuracy = calculateAccuracy(recognizedText, goldenTranscription);
    console.log(`准确率: ${accuracy.toFixed(1)}%`);
    
    // 第5步：对标交付标准
    if (accuracy >= 90) {
      console.log(`✅ 达标：准确率 >= 90%，可以上线`);
    } else if (accuracy >= 85) {
      console.log(`⚠️ 部分达标：准确率 >= 85%，可上线但需提示用户修正`);
    } else {
      console.log(`❌ 未达标：准确率 < 85%，不推荐上线`);
    }
  }
  
  // 分析低准确率的原因
  public analyzeAccuracyIssues(): void {
    console.log(`分析准确率低的原因:`);
    
    // 原因1：环境噪音
    console.log(`① 环境噪音：会议室背景噪音是否过大？`);
    console.log(`   建议：在安静环境重新测试`);
    
    // 原因2：语言模型不合适
    console.log(`② 语言模型：AI模型是否针对该行业优化？`);
    console.log(`   建议：尝试其他AI服务商或专业模型`);
    
    // 原因3：音频质量
    console.log(`③ 音频质量：麦克风质量是否足够？`);
    console.log(`   建议：使用更好的麦克风或专业录音设备`);
    
    // 原因4：方言或口音
    console.log(`④ 方言/口音：说话人是否有明显方言？`);
    console.log(`   建议：与AI服务商讨论是否支持该方言`);
  }
  
  // 改进方案
  public proposalForImprovement(): void {
    console.log(`改进方案:`);
    
    console.log(`短期（1周）:`);
    console.log(`  1. 向用户展示置信度，低置信度项目提示用户修正`);
    console.log(`  2. 提供用户修正界面，收集修正数据用于模型优化`);
    
    console.log(`中期（2-4周）:`);
    console.log(`  1. 收集业务领域的词汇和短语`);
    console.log(`  2. 与AI服务商合作优化模型`);
    console.log(`  3. 对比多个AI服务商，选择最佳方案`);
    
    console.log(`长期（1-3月）:`);
    console.log(`  1. 建立行业专用字幕模型`);
    console.log(`  2. 与专业转录团队合作，收集高质量训练数据`);
    console.log(`  3. 持续监测准确率，定期优化`);
  }
}

现场评估表：

指标	当前	目标	判定	解决方案
准确率	60%	>90%	❌ 未达标	优化AI模型或更换服务商
延迟	800ms	<500ms	⚠️ 部分	优化网络或本地处理
支持语言	中英	中英法	⚠️ 部分	与AI服务商协商支持
用户修正时间	40%	<20%	❌ 未达标	改进识别模型

---

场景3：不同语言的会议中，系统误判语言导致识别完全错误

背景：

• 会议中有中英文混合的内容
• 系统配置为"中文识别"
• 但英文部分被识别成了中文拼音或乱码

防范与诊断：

class MultiLanguageHandling {
  
  // 场景：英文句子被误识别为中文
  public demonstrateLanguageConfusion(): void {
    const audioContent = `We believe this product has strong competitive advantages`;
    
    // 如果系统配置为"中文"
    const wrongResult = `为我比利物这部产品哈撕特隆竞争上优势`;  // 拼音或乱码
    
    console.log(`❌ 使用错误的语言配置:`);
    console.log(`   输入: "${audioContent}"`);
    console.log(`   输出（错误）: "${wrongResult}"`);
  }
  
  // 防范方案1：语言自动检测
  public autoLanguageDetection(): void {
    console.log(`防范方案1：自动语言检测`);
    console.log(`  1. 系统自动分析音频内容，检测主要语言`);
    console.log(`  2. 如果检测到多种语言混合，提示用户选择模式`);
    console.log(`  3. 用户选择后才开始识别`);
  }
  
  // 防范方案2：配置验证提示
  public configurationValidationPrompt(): void {
    console.log(`防范方案2：配置验证提示`);
    console.log(`  用户选择"中文"后，系统提示:`);
    console.log(`  "您已选择中文识别。"`);
    console.log(`  "若会议中有英文等其他语言，请选择'混合多语言'模式。"`);
    console.log(`  用户确认后才生效`);
  }
  
  // 防范方案3：实时语言检测
  public realtimeLanguageDetection(): void {
    console.log(`防范方案3：实时语言检测`);
    console.log(`  1. 识别开始后，实时检测音频中的语言`);
    console.log(`  2. 若检测到与配置不符的语言，立即提示:`);
    console.log(`    "检测到英文内容，但您配置的是中文模式。"`);
    console.log(`    "是否切换到'混合'或'英文'模式?"`);
    console.log(`  3. 用户可实时调整`);
  }
}

现场恢复流程：

步骤	操作	预期结果
1	查看当前语言配置	确认是否为"中文"
2	对比会议实际语言	是否有英文内容
3	修改配置为"混合多语言"	支持中英文同时识别
4	重新开始识别	英文部分应该被正确识别
5	验证结果	对比音频和识别文本

---

FAQ

Q: 字幕识别准确率60%，这是否可以交付？

A: 不推荐。标准通常要求 > 85%。若必须交付需：(1) 明确告知用户这是初期版本；(2) 提供手动修正功能；(3) 收集用户反馈进行优化。

Q: 如果用户的语言配置错误，识别结果会怎样？

A: 完全无法理解的乱码或拼音。应在配置时明确提示用户，或在识别后自动检测语言是否匹配。

Q: 识别一段10分钟的音频需要多久？

A: 依赖AI服务的性能。通常需要 > 音频时长（可能需要15-20分钟）。应明确告知用户预期。

Q: 能否支持实时字幕（边录边转）？

A: 可以，但需要AI服务支持流式识别。通常会增加延迟。应与用户明确延迟承诺（如 < 5秒）。

Q: 如何处理会议中的多人发言？

A: 当前工程不区分发言人。如需区分，应：(1) 使用多麦克风阵列；(2) 请求AI服务商支持说话人分离。

---

必要条件｜模拟器与真机准备对照

条件	API 24 模拟器	HarmonyOS 6.1.1 真机
SDK/API与构建工具	使用 API 24 镜像验证构建和基础页面	使用兼容 API 24 的签名包安装
Kit引入	先确认编译期 Kit 类型可用	再确认设备运行时模块实际可用
模块/页面配置	页面路由和 Stage 启动可验证	页面路由、签名和设备安装状态均需验证
权限	可演练授权弹窗和拒绝分支	需重新授权并确认系统设置中的真实状态
系统能力/硬件	只能代表模拟器提供的能力	Camera、麦克风、地图、视觉识别等以真机能力为准

SDK/API 对照完成后插入 DevEco Studio API 24 与构建配置截图：

授权对照完成后插入真实设备权限截图：

版本和能力对照完成后插入设备/模拟器信息截图：