import Speech

let speechRecognizer = SFSpeechRecognizer(locale: Locale(identifier: "zh-CN")) // 使用中文
if speechRecognizer?.isAvailable == true {
    print("语音识别器可用！")
} else {
    print("语音识别器当前不可用。")
}

if speechRecognizer?.supportsOnDeviceRecognition == true {
    print("支持离线语音识别")
} else {
    print("仅支持在线识别需网络连接")
}

let request = SFSpeechURLRecognitionRequest(url: /*音频文件URL*/)
speechRecognizer?.recognitionTask(with: request) { result, error in
    if let result = result {
        print("识别结果: \(result.bestTranscription.formattedString)")
    } else if let error = error {
        print("识别任务失败: \(error)")
    }
}

import Speech

let speechRecognizer = SFSpeechRecognizer()
let audioURL = URL(fileURLWithPath: "/path/to/audio-file.m4a")
let request = SFSpeechURLRecognitionRequest(url: audioURL)

// 启动音频文件识别任务
speechRecognizer?.recognitionTask(with: request) { result, error in
    if let result = result {
        print("识别结果: \(result.bestTranscription.formattedString)") // 最佳匹配结果
    } else if let error = error {
        print("识别失败: \(error)")
    }
}

request.shouldReportPartialResults = false // 不返回中间结果，等待最终输出

import AVFoundation
import Speech

let audioEngine = AVAudioEngine()
let speechRecognizer = SFSpeechRecognizer()
let recognitionRequest = SFSpeechAudioBufferRecognitionRequest()

let inputNode = audioEngine.inputNode

// 配置实时音频捕获
let recordingFormat = inputNode.outputFormat(forBus: 0)
inputNode.installTap(onBus: 0, bufferSize: 1024, format: recordingFormat) { buffer, _ in
    recognitionRequest.append(buffer) // 将实时音频流数据附加到请求中
}

do {
    audioEngine.prepare()
    try audioEngine.start()

    speechRecognizer?.recognitionTask(with: recognitionRequest) { result, error in
        if let result = result {
            print("实时识别文本: \(result.bestTranscription.formattedString)") // 打印实时识别结果
        } else if let error = error {
            print("实时识别失败: \(error)")
        }
    }
} catch {
    print("音频引擎启动失败: \(error)")
}

speechRecognizer?.recognitionTask(with: request) { result, error in
    if let result = result {
        print("最佳结果: \(result.bestTranscription.formattedString)")
    }
}

let candidates = result.transcriptions
for transcription in candidates {
    print("候选结果: \(transcription.formattedString)")
}

recognitionTask.cancel() // 取消任务
audioEngine.stop()
recognitionTask = nil

class SpeechRecognizerDelegate: NSObject, SFSpeechRecognizerDelegate {
    func speechRecognizer(_ speechRecognizer: SFSpeechRecognizer, availabilityDidChange available: Bool) {
        if available {
            print("语音识别可用了！")
        } else {
            print("语音识别器暂时不可用")
        }
    }
}

let delegate = SpeechRecognizerDelegate()
speechRecognizer?.delegate = delegate

import Speech

SFSpeechRecognizer.requestAuthorization { status in
    switch status {
    case .authorized:
        print("用户已授权语音识别权限")
    case .denied:
        print("用户拒绝语音识别权限")
    case .restricted:
        print("设备对语音识别有限制")
    case .notDetermined:
        print("语音识别权限未决定")
    @unknown default:
        fatalError("未知的语音识别状态")
    }
}

// 使用默认设备语言
let speechRecognizer = SFSpeechRecognizer()

// 指定使用中文（zh-CN）为语言的识别器
let locale = Locale(identifier: "zh-CN") // 英文为 "en-US"
let speechRecognizerLocale = SFSpeechRecognizer(locale: locale)

// 检查语音识别器是否可用
if speechRecognizer?.isAvailable == true {
    print("语音识别器可以使用")
} else {
    print("语音识别器当前不可用")
}

import Speech

let speechRecognizer = SFSpeechRecognizer() // 初始化识别器
let audioURL = URL(fileURLWithPath: "/path/to/audio-file.m4a") // 音频文件路径

// 创建识别请求
let request = SFSpeechURLRecognitionRequest(url: audioURL)

// 创建识别任务
speechRecognizer?.recognitionTask(with: request) { result, error in
    if let error = error {
        print("语音识别错误: \(error)")
    } else if let result = result {
        // 打印最佳匹配的转录结果
        print("识别结果最佳匹配: \(result.bestTranscription.formattedString)")
    }
}

import AVFoundation
import Speech

// 初始化必要组件
let audioEngine = AVAudioEngine()
let speechRecognizer = SFSpeechRecognizer(locale: Locale(identifier: "en-US"))
var recognitionTask: SFSpeechRecognitionTask?
let recognitionRequest = SFSpeechAudioBufferRecognitionRequest()

// 检查语音识别器是否可用
guard speechRecognizer?.isAvailable == true else {
    print("语音识别器当前不可用")
    return
}

// 配置音频引擎，捕获麦克风数据
let inputNode = audioEngine.inputNode
let recordingFormat = inputNode.outputFormat(forBus: 0)

inputNode.installTap(onBus: 0, bufferSize: 1024, format: recordingFormat) { buffer, _ in
    recognitionRequest.append(buffer) // 将音频输入数据传递到实时语音请求
}

// 启动音频引擎
do {
    audioEngine.prepare()
    try audioEngine.start()

    // 启动语音识别任务
    recognitionTask = speechRecognizer?.recognitionTask(with: recognitionRequest) { result, error in
        if let result = result {
            print("实时识别文本: \(result.bestTranscription.formattedString)")
        } else if let error = error {
            print("实时语音识别任务错误: \(error)")
        }
    }
} catch {
    print("音频引擎启动失败: \(error)")
}

audioEngine.stop()
recognitionRequest.endAudio()
audioEngine.inputNode.removeTap(onBus: 0) // 移除音频捕获 Tap
recognitionTask?.finish()
recognitionTask = nil

if let result = result {
    print("最佳识别结果: \(result.bestTranscription.formattedString)")
}

for transcription in result.transcriptions {
    print("可能的识别结果: \(transcription.formattedString)")
}

if let result = result {
    for segment in result.bestTranscription.segments {
        print("识别段文本: \(segment.substring)")
        print("置信度: \(segment.confidence)")
    }
}

<key>NSSpeechRecognitionUsageDescription</key>
<string>App requires speech recognition for processing your voice input.</string>

<key>NSMicrophoneUsageDescription</key>
<string>App requires microphone access to capture your voice.</string>

import Speech

SFSpeechRecognizer.requestAuthorization { authStatus in
    switch authStatus {
    case .authorized:
        print("Speech recognition authorized.")
    case .denied:
        print("Speech recognition authorization denied.")
    case .restricted:
        print("Speech recognition restricted on this device.")
    case .notDetermined:
        print("Speech recognition authorization not yet determined.")
    @unknown default:
        fatalError("Unknown authorization status.")
    }
}

func recognizeSpeechFromFile(url: URL) {
    // 初始化语音识别器
    let speechRecognizer = SFSpeechRecognizer(locale: Locale(identifier: "en-US"))
    
    guard let recognizer = speechRecognizer, recognizer.isAvailable else {
        print("Speech recognizer is unavailable.")
        return
    }
    
    // 创建音频文件识别请求
    let request = SFSpeechURLRecognitionRequest(url: url)
    
    // 启动识别任务
    recognizer.recognitionTask(with: request) { result, error in
        if let error = error {
            print("Error during recognition: \(error.localizedDescription)")
        } else if let result = result {
            print("Recognized text: \(result.bestTranscription.formattedString)")
        }
    }
}

import AVFoundation
import Speech

class SpeechRecognizer {
    private let audioEngine = AVAudioEngine()
    private var speechRecognizer: SFSpeechRecognizer? = SFSpeechRecognizer(locale: Locale(identifier: "en-US"))
    private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest?
    private var recognitionTask: SFSpeechRecognitionTask?
    
    func startRecognition() {
        guard let recognizer = speechRecognizer, recognizer.isAvailable else {
            print("Speech recognizer is unavailable.")
            return
        }
        
        // 设置音频会话
        let audioSession = AVAudioSession.sharedInstance()
        do {
            try audioSession.setCategory(.record, mode: .measurement, options: .duckOthers)
            try audioSession.setActive(true, options: .notifyOthersOnDeactivation)
        } catch {
            print("Failed to configure audio session: \(error.localizedDescription)")
            return
        }
        
        // 配置实时语音请求
        recognitionRequest = SFSpeechAudioBufferRecognitionRequest()
        guard let request = recognitionRequest else { return }
        request.shouldReportPartialResults = true // 实时返回部分结果
        
        // 使用音频引擎捕获输入
        let inputNode = audioEngine.inputNode
        let recordingFormat = inputNode.outputFormat(forBus: 0)
        inputNode.installTap(onBus: 0, bufferSize: 1024, format: recordingFormat) { buffer, _ in
            self.recognitionRequest?.append(buffer)
        }
        
        // 开始音频引擎
        audioEngine.prepare()
        do {
            try audioEngine.start()
            print("AudioEngine started. Say something!")
        } catch {
            print("AudioEngine failed to start: \(error.localizedDescription)")
        }
        
        // 启动语音识别任务
        recognitionTask = recognizer.recognitionTask(with: request) { result, error in
            if let result = result {
                print("Recognized text: \(result.bestTranscription.formattedString)")
            }
            
            if error != nil || result?.isFinal == true {
                self.audioEngine.stop()
                inputNode.removeTap(onBus: 0)
                self.recognitionRequest = nil
                self.recognitionTask = nil
                print("Recognition task ended.")
            }
        }
    }
    
    func stopRecognition() {
        audioEngine.stop()
        recognitionRequest?.endAudio()
        print("AudioEngine stopped.")
    }
}