SpeechRecognizer

class SpeechRecognizer : Closeable

// 1. Create a SpeechRecognizer with desired options.
val options: SpeechRecognizerOptions =
    speechRecognizerOptions {
        locale = Locale.US
        preferredMode = SpeechRecognizerOptions.Mode.MODE_ADVANCED
    }
val speechRecognizer: SpeechRecognizer = SpeechRecognition.getClient(options)

// 2. Check if the recognition model is available or needs downloading.
launch {
    val status: Int = speechRecognizer.checkStatus()
    if (status == FeatureStatus.DOWNLOADABLE) {
        // 3. If needed, download the model.
        speechRecognizer.download().collect { downloadStatus ->
            when (downloadStatus) {
                is DownloadStatus.DownloadCompleted -> {
                    // Model is ready, start recognition.
                    startMyRecognition(speechRecognizer)
                }
                is DownloadStatus.DownloadFailed -> {
                    // Handle download failure.
                }
                is DownloadStatus.DownloadProgress -> {
                    // Handle download progress.
                }
                else -> {}
            }
        }
    } else if (status == FeatureStatus.AVAILABLE) {
        // Model is ready, start recognition.
        startMyRecognition(speechRecognizer)
    } else {
        // Handle other statuses like DOWNLOADING or UNAVAILABLE.
    }
}

// 4. Define your recognition logic.
suspend fun startMyRecognition(recognizer: SpeechRecognizer) {
    // Create a request and collect the responses.
    val request = speechRecognizerRequest {
        audioSource = AudioSource.fromMic()
    }
    recognizer.startRecognition(request).collect { response ->
        // Process the responses.
        when (response) {
            is SpeechRecognizerResponse.PartialTextResponse -> { /* ... */}
            is SpeechRecognizerResponse.FinalTextResponse -> { /* ... */}
            else -> {}
        }
    }
}

// 5. Stop recognition when needed.
launch {
    speechRecognizer.stopRecognition()
    speechRecognizer.close()
}

suspend fun recognizeFromFile(recognizer: SpeechRecognizer, audioData: ByteArray) {
    val (readFd, writeFd) = ParcelFileDescriptor.createPipe()

    // Launch a coroutine to write to the pipe in a background thread (Dispatchers.IO)
    val writeJob = CoroutineScope(Dispatchers.IO).launch {
        ParcelFileDescriptor.AutoCloseOutputStream(writeFd).use { outputStream ->
            // Example for STREAMING mode: pace the writes to simulate real-time.
            // (3200 bytes is 100ms of 16kHz 16-bit mono PCM: 16000 samples/sec * 2 bytes/sample * 0.1 sec)
            val chunkSize = 3200
            var offset = 0
            while (offset < audioData.size && isActive) {
                val len = minOf(chunkSize, audioData.size - offset)
                outputStream.write(audioData, offset, len)
                offset += len
                delay(100) // Pace the stream
            }
        }
    }

    val audioSource = AudioSource.fromPfd(readFd, AudioSource.Mode.STREAMING)
    val request = speechRecognizerRequest {
        this.audioSource = audioSource
    }

    try {
        recognizer.startRecognition(request).collect { response ->
            when (response) {
                is SpeechRecognizerResponse.PartialTextResponse -> {
                    println("Partial: ${response.text}")
                }
                is SpeechRecognizerResponse.FinalTextResponse -> {
                    println("Final: ${response.text}")
                }
                else -> {}
            }
        }
    } finally {
        // Ensure the write job is cancelled and the audioSource is closed
        writeJob.cancel()
        audioSource.close()
    }
}

// 1. Create a SpeechRecognizer.
val options = speechRecognizerOptions {
    locale = Locale.US
    preferredMode = SpeechRecognizerOptions.Mode.MODE_BASIC
}
val speechRecognizer = SpeechRecognition.getClient(options)

// 2. Recognize from a File in ONE_SHOT mode.
suspend fun recognizeFromFile(recognizer: SpeechRecognizer, audioFile: File) {
    val audioSource = AudioSource.fromFile(audioFile)
    val request = speechRecognizerRequest {
        this.audioSource = audioSource
    }

    try {
        recognizer.startRecognition(request).collect { response ->
            when (response) {
                is SpeechRecognizerResponse.FinalTextResponse -> {
                    println("Final: ${response.text}")
                }
                else -> {}
            }
        }
    } finally {
        audioSource.close()
    }
}

// 3. Close the recognizer when no longer needed.
speechRecognizer.close()