SenseVoice移动端SDK集成：Android/iOS开发快速上手教程

2026-02-05 04:20:00作者：曹令琨Iris

引言：语音交互的移动开发痛点与解决方案

在移动应用开发中，实现高效、准确的语音识别功能一直是开发者面临的挑战。传统方案往往存在以下痛点：

多语言支持不足，尤其对中文、粤语等东亚语言识别精度有限
模型体积庞大，影响App安装包大小和运行性能
集成流程复杂，需要处理音频采集、模型加载、推理优化等多环节
离线识别效果差，依赖云端服务导致延迟高、流量消耗大

SenseVoice作为多语言语音理解模型（Multilingual Voice Understanding Model），通过sherpa-onnx部署方案为移动端开发提供了一站式解决方案。本教程将从环境配置到代码实现，全面讲解如何在Android和iOS平台集成SenseVoice SDK，实现高性能的离线语音识别功能。

读完本教程，你将能够：

掌握SenseVoice移动端SDK的环境搭建与配置
实现Android平台基于Kotlin的语音识别功能
开发iOS平台基于Swift的语音交互模块
优化移动端语音识别性能与用户体验
处理多语言识别、情感分析等高级功能

技术概览：SenseVoice移动端解决方案架构

核心功能与优势

SenseVoice移动端解决方案通过ONNX模型格式实现跨平台部署，具备以下核心优势：

特性	详细说明
多语言支持	原生支持中文（普通话）、粤语、英语、日语、韩语五种语言，无需额外模型
轻量级部署	采用ONNX Runtime推理引擎，模型经过量化优化，最小体积仅需80MB
全平台覆盖	支持Android (arm64-v8a/armv7/x86)和iOS (arm64)架构
低延迟推理	10秒音频处理仅需70ms，比Whisper-Large快15倍
离线运行	完全本地推理，无需网络连接，保护用户隐私
多任务支持	单一模型集成语音识别(ASR)、情感识别(SER)、事件检测(AED)能力

系统架构

flowchart TD
    A[移动端应用] --> B[音频采集模块]
    B --> C[VAD语音活动检测]
    C --> D[音频预处理]
    D --> E[SenseVoice ONNX模型]
    E --> F[多任务输出]
    F --> G[语音识别结果]
    F --> H[情感分析结果]
    F --> I[事件检测结果]
    G --> J[UI展示/业务逻辑]
    H --> J
    I --> J

移动端架构分为四个核心层次：

音频处理层：负责音频采集、VAD分割和格式转换
推理引擎层：基于ONNX Runtime实现模型加载与推理
模型能力层：SenseVoice模型输出识别文本、情感标签和事件类型
应用接口层：提供简洁API供业务逻辑调用

环境准备：开发环境与依赖配置

开发环境要求

平台	系统版本	开发工具	必要依赖
Android	Android 7.0 (API 24)+	Android Studio 2022.3+	NDK 21+, Gradle 7.0+
iOS	iOS 12.0+	Xcode 14.0+	Swift 5.5+, ONNX Runtime 1.14+

模型与SDK获取

SenseVoice移动端部署依赖以下资源：

模型文件：从官方仓库获取已转换的ONNX模型

# 通过Git获取模型文件
git clone https://gitcode.com/gh_mirrors/se/SenseVoice.git
cd SenseVoice
# 模型位于model/onnx目录下，包含以下文件：
# - model.onnx: 主模型文件
# - config.json: 模型配置
# - tokens.txt: 词汇表

sherpa-onnx库：已集成SenseVoice的移动端SDK
- Android: 通过Maven中央仓库获取
- iOS: 通过CocoaPods或手动集成框架

Android平台集成实战（Kotlin）

1. 项目配置

build.gradle配置

android {
    defaultConfig {
        // 添加NDK支持
        ndk {
            abiFilters 'arm64-v8a', 'armeabi-v7a'
        }
        // Java 8支持
        compileOptions {
            sourceCompatibility JavaVersion.VERSION_1_8
            targetCompatibility JavaVersion.VERSION_1_8
        }
    }
    
    // 配置ONNX模型资源
    sourceSets {
        main {
            assets {
                srcDirs = ['src/main/assets', '../SenseVoice/model/onnx']
            }
        }
    }
}

dependencies {
    // 添加sherpa-onnx依赖
    implementation 'com.k2fsa.sherpa-onnx:sherpa-onnx-android:1.3.0'
    // 音频处理库
    implementation 'androidx.media3:media3-exoplayer:1.1.0'
    implementation 'androidx.media3:media3-decoder:1.1.0'
}

AndroidManifest.xml权限配置

<!-- 音频录制权限 -->
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<!-- 存储访问权限 -->
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<!-- 网络权限(可选，用于模型下载) -->
<uses-permission android:name="android.permission.INTERNET" />

<application>
    <!-- 启用硬件加速 -->
    <activity android:hardwareAccelerated="true" ...>
        ...
    </activity>
</application>

2. 核心代码实现

SenseVoice初始化管理类

class SenseVoiceManager(context: Context) {
    private var recognizer: SherpaOnnxRecognizer? = null
    private val modelPath = "model.onnx"
    private val tokensPath = "tokens.txt"
    private val configPath = "config.json"
    
    init {
        initRecognizer(context)
    }
    
    private fun initRecognizer(context: Context) {
        // 配置模型参数
        val config = SherpaOnnxRecognizerConfig(
            featConfig = FeatureExtractorConfig(
                sampleRate = 16000,
                featureDim = 80
            ),
            modelConfig = ModelConfig(
                modelPath = getAssetFilePath(context, modelPath),
                tokensPath = getAssetFilePath(context, tokensPath),
                configPath = getAssetFilePath(context, configPath),
                numThreads = 2, // 根据设备调整线程数
                useVad = true, // 启用语音活动检测
                debug = false
            ),
            decoderConfig = DecoderConfig(
                maxActivePaths = 4,
                lang = "auto" // 自动检测语言
            )
        )
        
        // 初始化识别器
        recognizer = SherpaOnnxRecognizer.create(config)
    }
    
    // 将assets文件复制到应用数据目录
    private fun getAssetFilePath(context: Context, assetName: String): String {
        val file = File(context.filesDir, assetName)
        if (!file.exists()) {
            context.assets.open(assetName).use { inputStream ->
                FileOutputStream(file).use { outputStream ->
                    inputStream.copyTo(outputStream)
                }
            }
        }
        return file.absolutePath
    }
    
    // 音频数据处理
    fun acceptWaveform(samples: FloatArray, sampleRate: Int) {
        recognizer?.acceptWaveform(sampleRate, samples)
    }
    
    // 获取识别结果
    fun getResult(): String {
        val result = recognizer?.getResult()
        return result?.text ?: ""
    }
    
    // 重置识别状态
    fun reset() {
        recognizer?.reset()
    }
    
    // 释放资源
    fun release() {
        recognizer?.release()
    }
}

音频采集与处理

class AudioRecorder(context: Context) {
    private val audioRecord: AudioRecord
    private val bufferSize: Int
    private val sampleRate = 16000 // SenseVoice要求16kHz采样率
    private val channelConfig = AudioFormat.CHANNEL_IN_MONO
    private val audioFormat = AudioFormat.ENCODING_PCM_16BIT
    private var isRecording = false
    private val senseVoiceManager: SenseVoiceManager
    
    init {
        // 计算缓冲区大小
        bufferSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig, audioFormat) * 2
        // 初始化AudioRecord
        audioRecord = AudioRecord(
            MediaRecorder.AudioSource.MIC,
            sampleRate,
            channelConfig,
            audioFormat,
            bufferSize
        )
        // 初始化SenseVoice管理器
        senseVoiceManager = SenseVoiceManager(context)
    }
    
    // 开始录音
    fun startRecording() {
        if (audioRecord.state != AudioRecord.STATE_INITIALIZED) {
            throw IllegalStateException("AudioRecord初始化失败")
        }
        
        // 检查录音权限
        if (ContextCompat.checkSelfPermission(
                context,
                Manifest.permission.RECORD_AUDIO
            ) != PackageManager.PERMISSION_GRANTED
        ) {
            throw SecurityException("未获取录音权限")
        }
        
        isRecording = true
        audioRecord.startRecording()
        
        // 启动录音线程
        Thread {
            val buffer = ShortArray(bufferSize)
            while (isRecording) {
                val readSize = audioRecord.read(buffer, 0, bufferSize)
                if (readSize > 0) {
                    // 转换为Float数组(16bit PCM转float)
                    val floatBuffer = FloatArray(readSize)
                    for (i in 0 until readSize) {
                        floatBuffer[i] = buffer[i] / 32768.0f
                    }
                    // 喂给SenseVoice处理
                    senseVoiceManager.acceptWaveform(floatBuffer, sampleRate)
                    
                    // 获取并处理结果
                    val result = senseVoiceManager.getResult()
                    if (result.isNotEmpty()) {
                        // 通过回调返回结果
                        onResultAvailable(result)
                    }
                }
            }
        }.start()
    }
    
    // 停止录音
    fun stopRecording() {
        isRecording = false
        if (audioRecord.state == AudioRecord.STATE_RECORDING) {
            audioRecord.stop()
        }
    }
    
    // 释放资源
    fun release() {
        stopRecording()
        audioRecord.release()
        senseVoiceManager.release()
    }
    
    // 结果回调
    private var onResultAvailable: (String) -> Unit = {}
    
    fun setOnResultAvailableListener(listener: (String) -> Unit) {
        onResultAvailable = listener
    }
}

界面集成与使用

class MainActivity : AppCompatActivity() {
    private lateinit var audioRecorder: AudioRecorder
    private lateinit var resultTextView: TextView
    private var isRecording = false
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        resultTextView = findViewById(R.id.resultTextView)
        val recordButton = findViewById<Button>(R.id.recordButton)
        
        // 初始化音频 recorder
        audioRecorder = AudioRecorder(this)
        
        // 设置结果回调
        audioRecorder.setOnResultAvailableListener { result ->
            runOnUiThread {
                resultTextView.text = result
            }
        }
        
        // 录音按钮点击事件
        recordButton.setOnClickListener {
            if (isRecording) {
                // 停止录音
                audioRecorder.stopRecording()
                recordButton.text = "开始录音"
                resultTextView.append("\n[录音结束]")
            } else {
                // 检查权限
                if (checkPermission()) {
                    // 开始录音
                    audioRecorder.startRecording()
                    recordButton.text = "停止录音"
                    resultTextView.text = "[正在录音...]"
                } else {
                    // 请求权限
                    requestPermission()
                }
            }
            isRecording = !isRecording
        }
    }
    
    // 权限检查
    private fun checkPermission(): Boolean {
        return ContextCompat.checkSelfPermission(
            this,
            Manifest.permission.RECORD_AUDIO
        ) == PackageManager.PERMISSION_GRANTED
    }
    
    // 请求权限
    private fun requestPermission() {
        ActivityCompat.requestPermissions(
            this,
            arrayOf(Manifest.permission.RECORD_AUDIO),
            REQUEST_RECORD_AUDIO_PERMISSION
        )
    }
    
    override fun onDestroy() {
        super.onDestroy()
        audioRecorder.release()
    }
    
    companion object {
        private const val REQUEST_RECORD_AUDIO_PERMISSION = 200
    }
}

3. 高级功能实现

多语言识别切换

// 修改SenseVoiceManager的初始化配置
fun setLanguage(language: String) {
    val decoderConfig = DecoderConfig(
        maxActivePaths = 4,
        lang = language // 指定语言："zh", "en", "yue", "ja", "ko"
    )
    
    // 重新初始化识别器
    val newConfig = recognizer?.config?.copy(decoderConfig = decoderConfig)
    newConfig?.let {
        recognizer?.release()
        recognizer = SherpaOnnxRecognizer.create(it)
    }
}

// 界面调用示例
fun switchToEnglish(view: View) {
    senseVoiceManager.setLanguage("en")
    showToast("已切换至英语识别模式")
}

fun switchToCantonese(view: View) {
    senseVoiceManager.setLanguage("yue")
    showToast("已切换至粤语识别模式")
}

情感识别结果获取

// 修改getResult方法获取情感信息
fun getFullResult(): RecognizeResult {
    return recognizer?.getResult() ?: RecognizeResult()
}

// 数据类定义
data class RecognizeResult(
    val text: String = "",
    val emotion: String = "", // 情感标签：HAPPY, SAD, ANGRY, NEUTRAL等
    val event: String = ""    // 事件类型：Speech, Laughter, Applause等
)

// 使用示例
audioRecorder.setOnResultAvailableListener { result ->
    runOnUiThread {
        resultTextView.text = result.text
        
        // 显示情感信息
        val emotionText = when(result.emotion) {
            "HAPPY" -> "😊 开心"
            "SAD" -> "😢 悲伤"
            "ANGRY" -> "😠 愤怒"
            "NEUTRAL" -> "😐 中性"
            else -> "未知情感"
        }
        emotionTextView.text = "情感分析: $emotionText"
        
        // 显示事件检测结果
        eventTextView.text = "事件检测: ${result.event}"
    }
}

iOS平台集成实战（Swift）

1. 项目配置

CocoaPods配置

创建或修改Podfile：

platform :ios, '12.0'

target 'SenseVoiceDemo' do
  use_frameworks!
  
  # 添加sherpa-onnx依赖
  pod 'sherpa-onnx', '~> 1.3.0'
  
  # 音频处理依赖
  pod 'AudioKit', '~> 5.5'
end

安装依赖：

pod install

项目设置

在Xcode中打开项目，选择目标应用，进入"Build Settings"
设置"Valid Architectures"为"arm64"
添加模型文件到项目：
- 将model.onnx、config.json和tokens.txt拖入项目
- 确保勾选"Copy items if needed"和目标应用

添加权限：在Info.plist中添加以下键值对：

<key>NSMicrophoneUsageDescription</key>
<string>需要麦克风权限以进行语音识别</string>

2. 核心代码实现

SenseVoice管理器

import Foundation
import sherpa_onnx

class SenseVoiceManager {
    private var recognizer: SherpaOnnxRecognizer?
    private let modelPath: String
    private let tokensPath: String
    private let configPath: String
    
    init() {
        // 获取模型路径
        guard let modelUrl = Bundle.main.url(forResource: "model", withExtension: "onnx"),
              let tokensUrl = Bundle.main.url(forResource: "tokens", withExtension: "txt"),
              let configUrl = Bundle.main.url(forResource: "config", withExtension: "json") else {
            fatalError("模型文件不存在")
        }
        
        modelPath = modelUrl.path
        tokensPath = tokensUrl.path
        configPath = configUrl.path
        
        // 初始化识别器
        setupRecognizer()
    }
    
    private func setupRecognizer() {
        // 配置特征提取器
        let featConfig = SherpaOnnxFeatureExtractorConfig(
            sampleRate: 16000,
            featureDim: 80
        )
        
        // 配置模型
        let modelConfig = SherpaOnnxModelConfig(
            model: modelPath,
            tokens: tokensPath,
            config: configPath,
            numThreads: 2,
            useVad: true,
            debug: false
        )
        
        // 配置解码器
        let decoderConfig = SherpaOnnxDecoderConfig(
            maxActivePaths: 4,
            lang: "auto" // 自动检测语言
        )
        
        // 创建识别器配置
        let recognizerConfig = SherpaOnnxRecognizerConfig(
            featConfig: featConfig,
            modelConfig: modelConfig,
            decoderConfig: decoderConfig
        )
        
        // 初始化识别器
        recognizer = SherpaOnnxRecognizer(config: recognizerConfig)
    }
    
    // 处理音频数据
    func acceptWaveform(samples: [Float], sampleRate: Int) {
        recognizer?.acceptWaveform(sampleRate: Int32(sampleRate), samples: samples)
    }
    
    // 获取识别结果
    func getResult() -> String {
        recognizer?.result().text ?? ""
    }
    
    // 重置识别状态
    func reset() {
        recognizer?.reset()
    }
    
    // 设置识别语言
    func setLanguage(_ lang: String) {
        guard let recognizer = recognizer else { return }
        
        var config = recognizer.config
        config.decoderConfig.lang = lang
        self.recognizer = SherpaOnnxRecognizer(config: config)
    }
}

音频采集与处理

import AVFoundation
import AudioKit

class AudioRecorder: NSObject, ObservableObject {
    @Published var resultText = ""
    private let senseVoiceManager = SenseVoiceManager()
    private var audioEngine: AVAudioEngine!
    private var inputNode: AVAudioInputNode!
    private let sampleRate: Double = 16000 // SenseVoice要求16kHz采样率
    private var isRecording = false
    
    override init() {
        super.init()
        setupAudioEngine()
    }
    
    private func setupAudioEngine() {
        audioEngine = AVAudioEngine()
        inputNode = audioEngine.inputNode
        
        // 配置音频格式
        let inputFormat = inputNode.inputFormat(forBus: 0)
        let outputFormat = AVAudioFormat(
            commonFormat: .pcmFormatFloat32,
            sampleRate: sampleRate,
            channels: 1,
            interleaved: false
        )!
        
        // 安装音频转换器
        let converter = AVAudioConverter(from: inputFormat, to: outputFormat)!
        
        // 安装音频处理块
        inputNode.installTap(onBus: 0, bufferSize: 1024, format: inputFormat) { [weak self] buffer, when in
            guard let self = self, self.isRecording else { return }
            
            // 转换音频格式
            let convertedBuffer = AVAudioPCMBuffer(
                pcmFormat: outputFormat,
                frameCapacity: AVAudioFrameCount(outputFormat.sampleRate * 0.1)
            )!
            
            var error: NSError?
            let inputBlock: AVAudioConverterInputBlock = { inNumPackets, outStatus in
                outStatus.pointee = AVAudioConverterInputStatus.haveData
                return buffer
            }
            
            converter.convert(to: convertedBuffer, error: &error, withInputFrom: inputBlock)
            
            if let error = error {
                print("音频转换错误: \(error.localizedDescription)")
                return
            }
            
            // 提取音频样本
            guard let floatBuffer = convertedBuffer.floatChannelData?[0] else { return }
            let frameCount = Int(convertedBuffer.frameLength)
            
            // 转换为Float数组
            var samples = [Float](repeating: 0, count: frameCount)
            for i in 0..<frameCount {
                samples[i] = floatBuffer[i]
            }
            
            // 喂给SenseVoice处理
            self.senseVoiceManager.acceptWaveform(samples: samples, sampleRate: Int(self.sampleRate))
            
            // 获取识别结果
            let result = self.senseVoiceManager.getResult()
            if !result.isEmpty {
                DispatchQueue.main.async {
                    self.resultText = result
                }
            }
        }
    }
    
    // 开始录音
    func startRecording() throws {
        // 检查权限
        let status = AVCaptureDevice.authorizationStatus(for: .audio)
        if status != .authorized {
            throw NSError(domain: "AudioPermission", code: 1, userInfo: [NSLocalizedDescriptionKey: "麦克风权限未授权"])
        }
        
        // 配置音频会话
        let audioSession = AVAudioSession.sharedInstance()
        try audioSession.setCategory(.record, mode: .measurement, options: .duckOthers)
        try audioSession.setActive(true)
        
        // 准备并启动音频引擎
        audioEngine.prepare()
        try audioEngine.start()
        
        isRecording = true
    }
    
    // 停止录音
    func stopRecording() {
        isRecording = false
        
        // 停止音频引擎
        audioEngine.stop()
        
        // 停用音频会话
        do {
            try AVAudioSession.sharedInstance().setActive(false)
        } catch {
            print("停止音频会话错误: \(error.localizedDescription)")
        }
    }
    
    // 设置识别语言
    func setLanguage(_ lang: String) {
        senseVoiceManager.setLanguage(lang)
    }
}

SwiftUI界面集成

import SwiftUI

struct ContentView: View {
    @StateObject private var audioRecorder = AudioRecorder()
    @State private var isRecording = false
    @State private var selectedLanguage = "auto"
    
    let languages = [
        "auto": "自动检测",
        "zh": "中文",
        "en": "英语",
        "yue": "粤语",
        "ja": "日语",
        "ko": "韩语"
    ]
    
    var body: some View {
        VStack(spacing: 30) {
            Text("SenseVoice语音识别")
                .font(.title)
                .fontWeight(.bold)
            
            Text(audioRecorder.resultText)
                .frame(maxWidth: .infinity, minHeight: 100)
                .padding()
                .background(Color(.systemGray6))
                .cornerRadius(10)
                .padding(.horizontal)
            
            Picker("选择语言", selection: $selectedLanguage) {
                ForEach(languages.sorted(by: { $0.key < $1.key }), id: \.key) { key, value in
                    Text(value).tag(key)
                }
            }
            .pickerStyle(SegmentedPickerStyle())
            .padding(.horizontal)
            .onChange(of: selectedLanguage) { newValue in
                audioRecorder.setLanguage(newValue)
            }
            
            Button(action: {
                if isRecording {
                    audioRecorder.stopRecording()
                } else {
                    do {
                        try audioRecorder.startRecording()
                    } catch {
                        print("录音启动失败: \(error.localizedDescription)")
                    }
                }
                isRecording.toggle()
            }) {
                Image(systemName: isRecording ? "stop.circle.fill" : "mic.circle.fill")
                    .resizable()
                    .aspectRatio(contentMode: .fit)
                    .frame(width: 80, height: 80)
                    .foregroundColor(isRecording ? .red : .blue)
            }
            
            Text(isRecording ? "正在录音..." : "点击麦克风开始录音")
                .foregroundColor(.gray)
            
            Spacer()
        }
        .padding(.top, 50)
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

3. 高级功能实现

情感识别与事件检测

// 修改SenseVoiceManager获取完整结果
func getFullResult() -> (text: String, emotion: String, event: String) {
    guard let result = recognizer?.result() else {
        return ("", "", "")
    }
    
    // 解析情感和事件信息
    // 注意：实际实现需要根据模型输出格式解析
    let emotion = parseEmotion(from: result)
    let event = parseEvent(from: result)
    
    return (result.text, emotion, event)
}

private func parseEmotion(from result: SherpaOnnxRecognizerResult) -> String {
    // 这里简化处理，实际需要根据模型输出格式解析
    // SenseVoice的情感信息可能包含在result的其他字段中
    return "NEUTRAL" // 示例返回中性情感
}

private func parseEvent(from result: SherpaOnnxRecognizerResult) -> String {
    // 解析事件检测结果
    return "Speech" // 示例返回语音事件
}

// 更新AudioRecorder处理完整结果
func processResult() {
    let (text, emotion, event) = senseVoiceManager.getFullResult()
    
    DispatchQueue.main.async {
        self.resultText = text
        self.emotion = emotion
        self.event = event
    }
}

性能优化与最佳实践

移动端性能优化策略

模型优化

模型量化：使用INT8量化模型替代FP32，可减少50%模型大小和内存占用

// Android中配置量化模型
val modelConfig = ModelConfig(
    modelPath = modelPath,
    tokensPath = tokensPath,
    configPath = configPath,
    numThreads = 2,
    useVad = true,
    quantize = true // 启用量化
)

线程管理：根据设备CPU核心数动态调整线程数

// iOS中根据设备调整线程数
let processorCount = ProcessInfo.processInfo.processorCount
let numThreads = min(processorCount, 4) // 最多使用4线程

按需加载：仅在需要时初始化模型，使用完及时释放

// Android懒加载实现
private val senseVoiceManager by lazy {
    SenseVoiceManager(context)
}

// 使用后释放
override fun onStop() {
    super.onStop()
    if (isFinishing) {
        senseVoiceManager.release()
    }
}

音频处理优化

缓冲区管理：合理设置音频缓冲区大小，平衡延迟和性能

// iOS优化缓冲区大小
let bufferSize = AVAudioFrameCount(sampleRate * 0.1) // 100ms缓冲区

背景降噪：使用简单的降噪算法预处理音频

// Android实现简单降噪
fun denoiseAudio(samples: FloatArray): FloatArray {
    val threshold = 0.01f // 噪声阈值
    return samples.map { max(it, threshold) * (it / abs(it)) }.toFloatArray()
}

批量处理：累积一定音频数据后再进行处理，减少调用次数

// 累积500ms音频后处理
private val audioBuffer = FloatArray(8000) // 16kHz * 0.5s = 8000样本
private var bufferIndex = 0

fun addAudioSamples(samples: FloatArray) {
    for (sample in samples) {
        audioBuffer[bufferIndex] = sample
        bufferIndex++
        
        if (bufferIndex >= audioBuffer.size) {
            // 处理缓冲区数据
            senseVoiceManager.acceptWaveform(audioBuffer, sampleRate)
            bufferIndex = 0
        }
    }
}

用户体验优化

实时反馈：提供视觉和听觉反馈指示录音状态

// iOS录音动画
@State private var recordingLevel: CGFloat = 0.0

// 更新录音电平
func updateRecordingLevel(buffer: AVAudioPCMBuffer) {
    guard let channelData = buffer.floatChannelData?[0] else { return }
    
    var sum: Float = 0
    for i in 0..<Int(buffer.frameLength) {
        sum += pow(channelData[i], 2)
    }
    let rms = sqrt(sum / Float(buffer.frameLength))
    let level = min(1.0, rms * 10) // 归一化到0-1范围
    
    DispatchQueue.main.async {
        self.recordingLevel = level
    }
}

错误处理：友好提示权限问题和识别错误

// Android权限请求处理
override fun onRequestPermissionsResult(
    requestCode: Int,
    permissions: Array<String>,
    grantResults: IntArray
) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    if (requestCode == REQUEST_RECORD_AUDIO_PERMISSION) {
        if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            // 权限授予，开始录音
            startRecording()
        } else {
            // 权限拒绝，显示提示
            Toast.makeText(this, "无法录音：需要麦克风权限", Toast.LENGTH_LONG).show()
        }
    }
}

语言切换：提供直观的语言选择界面

// iOS语言选择视图
Picker("语言", selection: $selectedLanguage) {
    Text("自动检测").tag("auto")
    Text("中文").tag("zh")
    Text("英语").tag("en")
    Text("粤语").tag("yue")
    Text("日语").tag("ja")
    Text("韩语").tag("ko")
}
.pickerStyle(MenuPickerStyle())
.onChange(of: selectedLanguage) {
    audioRecorder.setLanguage($0)
}

部署与测试

Android平台部署注意事项

APK体积优化

// 只保留必要架构
ndk {
    abiFilters 'arm64-v8a' // 现代Android设备主要架构
}

// 启用资源压缩
buildTypes {
    release {
        minifyEnabled true
        shrinkResources true
        proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
    }
}

模型文件处理
- 对于大型模型，考虑使用APK扩展文件(OBB)
- 实现模型按需下载，首次启动后获取最新模型
测试策略
- 在不同性能设备上测试：低端机关注内存占用和卡顿
- 测试各种环境：安静房间、嘈杂环境、远距离说话等场景
- 验证多语言切换的流畅性和识别准确性

iOS平台部署注意事项

App Store提交
- 说明麦克风使用目的，确保通过审核
- 优化启动时间，避免模型初始化阻塞UI
性能测试
- 使用Instruments工具分析CPU和内存使用
- 测试电池消耗，优化推理效率
架构支持
- 仅支持arm64架构，移除对i386和x86_64的支持
- 设置"Build Active Architecture Only"为Yes