鸿蒙语言学习工具 发音评分与情景对话【玩转华为云】

• 本地优先的发音评测与转写：教育场景模型、噪声抑制、回声消除、自动增益，保障稳定与隐私。
• 三维评分模型：从accuracy/fluency/prosody综合评估发音质量，定位问题音素/重音/连读。
• 情景对话引擎：基于转写与规则/大模型驱动的多轮对话管理与即时反馈。
• 低延迟音频链路：采集→预处理→识别/评测→播放，全链路<100ms级响应。
• 多设备协同：手机/平板/智慧屏角色分工，学习数据无缝同步。

[UI 触发练习/对话]
      |
[AudioCapturer] PCM 采集（16kHz/16bit/Mono）
      |
[预处理] 降噪(CLASSROOM)/AEC/AGC
      |
┌───────────────┬─────────────────────┐
│ 发音评测引擎  │  实时转写引擎      │
│ accuracy/     │  教育/学科词汇模型  │
│ fluency/prosody│  标点与断句        │
└───────────────┴─────────────────────┘
      |
[评分/建议/对话策略] → [TTS 播报]
      |
[分布式软总线] → 同步至平板/智慧屏
      |
[数据持久化] 成绩/对话卡片/标签

• @ohos.multimedia.audio（音频采集/播放）
• @ohos.multimedia.media（TTS/媒体）
• @ohos.speech（语音评测/转写，按实际版本导入）
• @ohos.distributedData（分布式数据，可选）

{
  "module": {
    "requestPermissions": [
      { "name": "ohos.permission.MICROPHONE" },
      { "name": "ohos.permission.INTERNET" },
      { "name": "ohos.permission.READ_MEDIA" }
    ]
  }
}

1. 数据模型
   common/model/PronunciationScore.ets

export class PronunciationScore {
  accuracy: number = 0;      // 0-100
  fluency: number = 0;       // 0-100
  prosody: number = 0;       // 0-100
  overallScore: number = 0;  // 0-100
  suggestions: string[] = [];
}

import audio from '@ohos.multimedia.audio';

export class AudioConfig {
  sampleRate: number = 16000;
  channelCount: number = 1;
  bitDepth: number = 16;
  durationMs: number = 3000; // 录音时长
  captureMode: audio.CaptureMode = audio.CaptureMode.LOW_LATENCY;
}

1. 发音评分服务（壳 + 可替换评测实现）
   services/PronunciationService.ets

import audio from '@ohos.multimedia.audio';
import { BusinessError } from '@ohos.base';
import { PronunciationScore } from '../common/model/PronunciationScore';
import { AudioConfig } from '../common/model/AudioConfig';

// 可替换为系统发音评测引擎的真实调用
async function callSystemEvaluator(pcmData: ArrayBuffer, refText: string): Promise<PronunciationScore> {
  // TODO: 接入 Speech Kit 发音评测
  // const engine = speech.createEvaluator({ language: 'en-US', mode: 'EDUCATION' });
  // const result = await engine.evaluate(pcmData, { referenceText: refText, criteria: ['accuracy','fluency','prosody'] });
  // return { overallScore: result.overallScore, accuracy: result.accuracy, fluency: result.fluency, prosody: result.prosody, suggestions: [] };

  // 简化模拟：基于能量/过零率/静音比生成评分
  const score = simulateScoreFromPcm(pcmData);
  return score;
}

function simulateScoreFromPcm(pcm: ArrayBuffer): PronunciationScore {
  const samples = new Int16Array(pcm);
  let energy = 0, zcr = 0, voiced = 0;
  const len = samples.length;
  const windowSize = 160; // 10ms @16kHz
  for (let i = 0; i < len - windowSize; i += windowSize) {
    let sum = 0, prev = 0, voicedWin = 0;
    for (let j = 0; j < windowSize; j++) {
      const s = Math.abs(samples[i + j]);
      sum += s * s;
      if ((samples[i + j] >= 0) !== (prev >= 0)) zcr++;
      if (s > 300) voicedWin++; // 简单门限
      prev = samples[i + j];
    }
    energy += sum / windowSize;
    zcr /= windowSize;
    if (voicedWin / windowSize > 0.2) voiced++;
  }
  const avgEnergy = energy / (len / windowSize);
  const voicedRatio = voiced / (len / windowSize);

  // 归一化到 0-100（经验映射）
  const accuracy = Math.min(100, Math.max(0, 60 + (avgEnergy / 3000) * 40 + (voicedRatio - 0.2) * 100));
  const fluency = Math.min(100, Math.max(0, 70 + (1 - Math.abs(zcr - 0.1)) * 30));
  const prosody = Math.min(100, Math.max(0, 65 + voicedRatio * 35));
  const overall = Math.round((accuracy + fluency + prosody) / 3);

  const tips: string[] = [];
  if (accuracy < 80) tips.push('注意元音饱满与尾音清晰');
  if (fluency < 85) tips.push('放慢语速，减少停顿');
  if (prosody < 80) tips.push('注意重音与语调起伏');

  return { accuracy, fluency, prosody, overallScore: overall, suggestions: tips };
}

export class PronunciationService {
  private config: AudioConfig = new AudioConfig();
  private capturer: audio.AudioCapturer | null = null;
  private pcmBuffers: ArrayBuffer[] = [];

  async startRecording(durationMs: number = this.config.durationMs): Promise<void> {
    if (this.capturer) return;
    const audioManager = audio.getAudioManager();
    const info = {
      source: audio.SourceType.MIC,
      samplerate: this.config.sampleRate,
      channels: this.config.channelCount,
      bitWidth: this.config.bitDepth,
      captureMode: this.config.captureMode
    };
    this.pcmBuffers = [];
    this.capturer = await audioManager.createAudioCapturer(info, (stream: audio.AudioStream) => {
      const reader = stream.createReader();
      const readLoop = () => {
        reader.read().then((data: audio.AudioBuffer) => {
          if (data) {
            this.pcmBuffers.push(data.buffer.slice(0));
            readLoop();
          }
        }).catch((err: BusinessError) => {
          console.error('读取音频流失败', err);
        });
      };
      readLoop();
    });
    await this.capturer.start();
    setTimeout(() => this.stopRecording(), durationMs);
  }

  async stopRecording(): Promise<ArrayBuffer> {
    if (!this.capturer) return new ArrayBuffer(0);
    await this.capturer.stop();
    await this.capturer.release();
    this.capturer = null;
    const totalLen = this.pcmBuffers.reduce((sum, b) => sum + b.byteLength, 0);
    const merged = new Uint8Array(totalLen);
    let offset = 0;
    for (const b of this.pcmBuffers) {
      merged.set(new Uint8Array(b), offset);
      offset += b.byteLength;
    }
    return merged.buffer;
  }

  async evaluate(refText: string, pcmData: ArrayBuffer): Promise<PronunciationScore> {
    return await callSystemEvaluator(pcmData, refText);
  }
}

1. 发音练习页面
   pages/PronunciationPage.ets

import { PronunciationService } from '../services/PronunciationService';
import { PronunciationScore } from '../common/model/PronunciationScore';
import audio from '@ohos.multimedia.audio';
import { BusinessError } from '@ohos.base';

@Entry
@Component
struct PronunciationPage {
  @State targetText: string = 'Hello';
  @State isRecording: boolean = false;
  @State score: PronunciationScore = new PronunciationScore();
  @State showResult: boolean = false;

  private recorder: PronunciationService = new PronunciationService();

  build() {
    Column({ space: 20 }) {
      Text(`目标： ${this.targetText}`)
        .fontSize(20)
        .fontWeight(FontWeight.Bold);

      Button(this.isRecording ? '停止录音' : '开始录音')
        .width('60%')
        .height(50)
        .backgroundColor(this.isRecording ? '#FF6B6B' : '#4ECDC4')
        .onClick(() => this.toggleRecord())

      if (this.showResult) {
        Column({ space: 8 }) {
          Text(`综合评分： ${this.score.overallScore}/100`)
            .fontSize(18)
            .fontWeight(FontWeight.Medium)
          Text(`准确度： ${this.score.accuracy}/100  流利度： ${this.score.fluency}/100  韵律： ${this.score.prosody}/100`)
            .fontSize(14)
            .fontColor('#555')
          ForEach(this.score.suggestions, (tip: string) => {
            Text(`• ${tip}`)
              .fontSize(12)
              .fontColor('#333')
              .margin({ top: 2 })
          })
        }
      }
    }
    .width('100%')
    .padding(20)
  }

  private async toggleRecord() {
    if (!this.isRecording) {
      this.showResult = false;
      this.score = new PronunciationScore();
      try {
        await this.recorder.startRecording(3000);
        this.isRecording = true;
      } catch (e) {
        console.error('录音失败', e as BusinessError);
      }
    } else {
      this.isRecording = false;
      try {
        const pcm = await this.recorder.stopRecording();
        if (pcm.byteLength > 0) {
          this.score = await this.recorder.evaluate(this.targetText, pcm);
          this.showResult = true;
        }
      } catch (e) {
        console.error('评测失败', e as BusinessError);
      }
    }
  }
}

1. 对话数据与服务
   common/model/DialogueTurn.ets

export interface DialogueTurn {
  role: 'user' | 'assistant';
  text: string;
  timestamp: number;
}

import { DialogueTurn } from '../common/model/DialogueTurn';
import { BusinessError } from '@ohos.base';

// 可替换为系统实时转写引擎
async function callSystemTranscriber(audioData: ArrayBuffer, lang: string): Promise<string> {
  // TODO: 接入 Speech Kit 实时转写
  // const transcriber = speech.createLiveTranscriber({ language: lang, educationMode: true, punctuation: true });
  // return new Promise((resolve) => { transcriber.on('textResult', resolve); transcriber.start(); /* feed data */ });
  return "This is a mock transcript.";
}

// 可替换为云端 LLM/本地规则引擎
async function callLLM(prompt: string): Promise<string> {
  // TODO: 接入 AI API（如华为云 NLP、文心一言等）
  return "Sure, I can help you with that.";
}

export class DialogueService {
  private history: DialogueTurn[] = [];

  async transcribe(audioData: ArrayBuffer, lang: string): Promise<string> {
    return await callSystemTranscriber(audioData, lang);
  }

  async generateReply(context: string): Promise<string> {
    return await callLLM(context);
  }

  addTurn(role: 'user' | 'assistant', text: string) {
    this.history.push({ role, text, timestamp: Date.now() });
  }

  getHistory(): DialogueTurn[] {
    return this.history;
  }
}