SFSpeechRecognizer — qué es, API e integración en iOS

Qué es SFSpeechRecognizer: descripción general

SFSpeechRecognizer es una clase de Speech.framework que representa un reconocedor de voz para un idioma específico. Se inicializa con un Locale (ru_RU, en_US, zh_CN). SFSpeechRecognizer gestiona una solicitud de reconocimiento (SFSpeechRecognitionRequest) y devuelve un resultado (SFSpeechRecognitionResult) con transcripciones y metadatos. Soporta dos tipos de solicitudes: SFSpeechAudioBufferRecognitionRequest (flujo de audio en vivo) y SFSpeechURLRecognitionRequest (archivo de audio). Ambos devuelven SFTranscription — un array de hipótesis alternativas de reconocimiento.

SFSpeechRecognitionResult contiene: bestTranscription (mejor hipótesis, SFTranscription), transcriptions (todas las alternativas), isFinal (final/intermedio). SFTranscription contiene: formattedString (texto), segments (array de SFTranscriptionSegment con marcas de tiempo, confianza, substringRange, alternativeSubstrings). La confianza para cada segmento (0..1) — permite filtrar fragmentos no fiables. Los segments son una característica clave de Speech.framework: proporcionan un marcado palabra por palabra con puntuaciones de confianza.

Arquitectura de SFSpeechRecognizer: AVFoundation (captura de audio) → Audio Buffer → SFSpeechAudioBufferRecognitionRequest → SFSpeechRecognizer (motor ASR) → SFSpeechRecognitionResult → SFSpeechRecognitionTask (control: cancel, finish, pause). El motor ASR de Apple utiliza una arquitectura híbrida: Conformer (encoder) + RNNT (decoder) para on-device, Transducer para cloud. Los modelos están optimizados para Apple Neural Engine (ANE). En A17 Pro, el ASR on-device funciona con RTF 0.3–0.6 (más rápido que el tiempo real).

Requisitos de audio: SFSpeechRecognizer acepta LPCM (16 kHz, 16 bit, mono) u Opus (iOS 17+). AVFoundation puede capturar buffers de cualquier formato, la solicitud convierte automáticamente. Longitud mínima: 0.5 segundos (detección de silencio). Máxima: 1 minuto (cloud) / 2 minutos (on-device) por solicitud. Para transcripciones largas, divida el audio en fragmentos de 30–60 segundos con superposición de 2–5 segundos.

Configuración y permisos de SFSpeechRecognizer

Permisos del usuario: SFSpeechRecognizer requiere dos permisos explícitos. NSMicrophoneUsageDescription (Privacy — Microphone Usage Description) — para acceso al micrófono. NSSpeechRecognitionUsageDescription (Privacy — Speech Recognition Usage Description) — para acceso al reconocimiento de voz. Ambos son cadenas que explican el motivo al usuario. SFSpeechRecognizer.requestAuthorization — muestra el diálogo de permisos. Estados: notDetermined, denied, restricted, authorized. Sin el estado authorized, llamar al recognizer devuelve el error 216 (Speech framework error).

Verificación de disponibilidad: SFSpeechRecognizer.isAvailable — comprueba si ASR está disponible para el idioma actual. En iOS 16-, isAvailable = false sin internet. En iOS 17+, isAvailable = true para idiomas on-device incluso sin conexión. SFSpeechRecognizer.supportedLocales — método estático para obtener la lista de idiomas compatibles con el dispositivo. Se recomienda verificar isAvailable antes de cada inicio (el usuario puede desactivar Siri/Dictado en ajustes). La disponibilidad depende de la región: chino — solo en China, árabe — en EAU.

// Configuración de SFSpeechRecognizer
import Speech

SFSpeechRecognizer.requestAuthorization { status in
    guard status == .authorized else { return }
}

let recognizer = SFSpeechRecognizer(locale: Locale(identifier: "ru_RU"))!
guard recognizer.isAvailable else {
    print("ASR no disponible. Active Siri y Dictado en Ajustes")
    return
}

let request = SFSpeechAudioBufferRecognitionRequest()
request.requiresOnDeviceRecognition = true

Manejo de errores: SFSpeechRecognizer se llama con un completion handler que puede devolver un Error. Errores principales: 203 — sin internet (cloud, iOS 16-); 216 — no autorizado (sin permiso); 301 — error de audio (problema con micrófono/formato); 401 — servicio no disponible (servicio sobrecargado); 601 — idioma no disponible (idioma no compatible en el dispositivo). Para on-device iOS 17+, errores principales: 301 (audio), 601 (idioma). Siempre maneje el completion handler — los errores pueden ocurrir en cualquier momento durante la grabación.

Reconocimiento de voz en vivo desde el micrófono

Pipeline ASR en vivo: AVAudioEngine (captura de micrófono) → installTap (buffer de audio) → request.append(buffer) → SFSpeechRecognizer → recognitionTask → delegate/resultHandler. AVAudioEngine proporciona baja latencia (5–10 ms del mic al buffer). SFSpeechRecognitionDelegate: didHypothesizeTranscription (cada 200–500 ms — texto parcial), didFinishRecognition (resultado final). Task.isFinishing — se puede cancelar cuando el reconocimiento está completo. Para reconocimiento continuo (dictado infinito), cree una nueva tarea después de isFinal.

SFSpeechRecognitionTaskDelegate: métodos opcionales. speechRecognitionDidDetectSpeech (inicio de voz) — para indicación en UI. didHypothesizeTranscription (texto intermedio) — para mostrar mientras se habla. didFinishRecognition (resultado final) — para fijar el texto. didFinishSuccessfully (éxito/error) — para finalización. didProcessAudio (buffer de audio procesado) — para medidor RMS. Se recomienda implementar didHypothesizeTranscription — el usuario ve el texto de inmediato sin demora. La transcripción final es para guardar.

// Reconocimiento de voz en vivo
let audioEngine = AVAudioEngine()
let request = SFSpeechAudioBufferRecognitionRequest()
request.shouldReportPartialResults = true

recognitionTask = recognizer.recognitionTask(with: request) { result, error in
    if let result = result {
        textView.text = result.bestTranscription.formattedString
    }
    if error != nil || result?.isFinal == true {
        audioEngine.stop()
        request.endAudio()
    }
}

let inputNode = audioEngine.inputNode
let recordingFormat = inputNode.outputFormat(forBus: 0)
inputNode.installTap(onBus: 0, bufferSize: 1024,
                     format: recordingFormat) { buffer, _ in
    request.append(buffer)
}
audioEngine.prepare()
try audioEngine.start()

Reconocimiento continuo: para el modo de “escucha siempre” (entrada de voz, asistente), es necesario reiniciar la tarea después de isFinal. Cree un bucle: finishTask → request = SFSpeechAudioBufferRecognitionRequest() → recognitionTask = recognizer.recognitionTask(with: request). Para evitar pausas, superponga el final de una tarea con el inicio de la siguiente (inicie una nueva solicitud 1–2 segundos antes de que termine la anterior). AVFoundation AVAudioSession — configure .playAndRecord para reproducción y grabación simultáneas. En iOS 17+, el ASR continuo con on-device consume 2–5% de batería por hora (A15+).

Reconocimiento de archivos de audio y grabaciones

SFSpeechURLRecognitionRequest — una solicitud para reconocer un archivo de audio por URL. Soporta formatos: .wav (16 kHz, 16 bit, mono), .m4a (AAC), .mp4, .mov. Longitud máxima: ~1 minuto para cloud, ~2 minutos para on-device. Para archivos más largos, divida en fragmentos (AVAssetExportSession + trim). SFSpeechURLRecognitionRequest no soporta streaming (sin resultados parciales) — solo el resultado final. Para resultados parciales con un archivo, convierta a una solicitud de Audio Buffer.

Obtención de transcripción de archivo de audio: SFSpeechRecognizer.recognitionTask(with: request) resultHandler. Extraiga bestTranscription.formattedString. Para marcas de tiempo a nivel de palabra — segments de bestTranscription.segments (segment.duration, segment.timestamp, segment.substring). Confianza por segmento — confianza ASR para cada palabra (úsela para filtrar). Hipótesis alternativas — alternativas de transcriptionFormatter para palabras con baja confianza. Para archivos con varios hablantes, SFSpeechRecognitionRequest puede devolver múltiples solicitudes (una por hablante, iOS 17+).

// Transcripción de archivo de audio
let audioURL = Bundle.main.url(forResource: "recording", withExtension: "m4a")!
let request = SFSpeechURLRecognitionRequest(url: audioURL)
request.requiresOnDeviceRecognition = true

recognizer.recognitionTask(with: request) { result, error in
    guard let result = result, error == nil else {
        print("Error: \(error?.localizedDescription ?? "unknown")")
        return
    }

    let transcription = result.bestTranscription
    let text = transcription.formattedString
    let words = transcription.segments.map { segment in
        Word(text: segment.substring,
              start: segment.timestamp,
              duration: segment.duration,
              confidence: segment.confidence)
    }
}

División de archivos de audio largos: para archivos > 1 minuto, divida en fragmentos de 30–60 segundos con superposición de 2–3 segundos (empalme). AVAssetExportSession + CMTimeRange — exportar fragmentos. Alternativa: UISelectionView (el usuario selecciona un segmento). Empalme de transcripciones: concatenar textos, empalmar por superposición (las últimas 2–3 palabras del fragmento anterior se comparan con las primeras 2–3 del siguiente — eliminar duplicados). Vosk y Whisper soportan audio largo de forma nativa, SFSpeechRecognizer no. Para transcripciones largas, recomiendo Whisper (Core ML) — sin límite de longitud.

On-device vs Cloud: comparación de modos

Modo On-device (iOS 17+): request.requiresOnDeviceRecognition = true. ASR se ejecuta localmente en Apple Neural Engine (ANE). Ventajas: sin necesidad de internet, privacidad (el audio nunca sale del dispositivo), costo cero (gratuito), baja latencia (RTF 0.3–0.6). Desventajas: menor precisión (WER 12–14% vs 7–12%), límite de 2 minutos por solicitud, conjunto de idiomas limitado (no todos los 60 idiomas disponibles on-device). El modelo on-device ocupa ~50–100 MB en el dispositivo y se descarga en la primera solicitud.

Cloud (iOS 16-): request.requiresOnDeviceRecognition = false (o parámetro ausente). ASR en servidores de Apple — más preciso (WER 7% EN, 12% RU), más idiomas, hasta 1 minuto por solicitud. Requiere internet (WiFi o cellular). Apple no cobra a los desarrolladores por cloud ASR (gratuito). Límites: 1 solicitud por minuto por aplicación (no especificado), pero Apple puede limitar a escala de producción. Cloud ASR proporciona calidad de mejor esfuerzo sin SLA. Para aplicaciones empresariales, use Google Cloud ASR o Whisper (Core ML).

Reconocimiento Combinado (iOS 17+): request.requiresOnDeviceRecognition = false con internet (cloud), = true sin conexión (fallback). Apple selecciona automáticamente el modo. Para aplicaciones críticas en precisión: verifique NetworkMonitor (NWPathMonitor) — use cloud con internet, on-device sin. Para aplicaciones críticas en privacidad: siempre on-device. Para transcripción: cloud (más preciso). Para entrada de voz: on-device (más rápido). Se recomienda Combinado: 80% cloud, 20% on-device fallback.

Uso de SFSpeechRecognizer en aplicaciones iOS

Entrada de voz en teclado personalizado — SFSpeechRecognizer integrado en extensiones de teclado (iOS 10+). El usuario pulsa el botón del micrófono, ASR transcribe la voz a texto y lo inserta en el campo de texto. Requisitos: resultados parciales (ver el texto en tiempo real), on-device (el teclado debe funcionar sin internet). SFSpeechRecognizer + AVSpeechSynthesizer — entrada de voz + salida de voz. Para teclados personalizados en iOS 17+, use on-device. Limitaciones de la extensión de teclado: AVAudioEngine está disponible pero con restricciones de tiempo (ejecución en segundo plano limitada).

Transcripción de reuniones y conferencias — aplicaciones para grabar y transcribir audio (Otter.ai, Rev, Apple Voice Memos). SFSpeechURLRecognitionRequest procesa archivos .m4a. Para grabaciones largas (30–60 minutos) — Whisper Core ML (sin límite de longitud). Los segments de SFSpeechRecognizer con marcas de tiempo — para sincronizar texto con audio (resaltado de texto durante la reproducción). Confianza por segmento — para mostrar fragmentos no fiables (resaltado en amarillo). Para diarización de hablantes (quién habló) — Apple no proporciona API, use pyannote-audio + Whisper en el servidor.

Comandos de voz en aplicaciones iOS — SFSpeechRecognizer + framework VGS (Voice Grammar Services) para ejecutar comandos: “abrir configuración”, “enviar mensaje”, “encender la luz”. Reconocimiento basado en gramática: SFSpeechRecognitionRequest contextualStrings = array de comandos. Esto mejora la precisión del reconocimiento de comandos hasta 95% (vs 85% de formato libre). SFSpeechRecognitionTask.cancel — para interrumpir después de ejecutar el comando. VGS + SFSpeechRecognizer + Shortcuts — comandos de voz personalizados sin escribir UI. Para accesibilidad: Voice Control (integrado) + SFSpeechRecognizer (comandos personalizados).

// Comandos de voz con cadenas contextuales
let request = SFSpeechAudioBufferRecognitionRequest()
request.requiresOnDeviceRecognition = true
request.shouldReportPartialResults = true
request.contextualStrings = ["open contacts", "send message",
                             "show notifications", "encender linterna"]

recognitionTask = recognizer.recognitionTask(with: request) { result, _ in
    guard let text = result?.bestTranscription.formattedString.lowercased() else { return }
    voiceCommands.first { text.contains($0) }.map { command in
        DispatchQueue.main.async { self.executeCommand(command) }
        recognitionTask?.cancel()
    }
}

Dictado en aplicaciones médicas y legales — SFSpeechRecognizer para crear documentos estructurados por voz. Adaptación de dominio: contextualStrings con términos médicos/legales (500+ frases). SFSpeechRecognitionRequest.customLmProbability — impacto de contextualStrings (0.1–1.0). Para dictado médico, use on-device (privacidad de datos del paciente). Whisper ajustado con datos médicos — alternativa con WER 5% en lugar de 12% del SFSpeechRecognizer base. Cumplimiento HIPAA: modo on-device (los datos nunca salen del dispositivo). Para transcripción de citas — SFSpeechURLRecognitionRequest + segments con marcas de tiempo de hablante.