@iternio/react-native-auto-play 0.4.7 → 0.4.9

package/ios/hybrid/HybridAutoPlay.swift

@@ -21,7 +21,7 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     private static var listeners = [EventName: [StateListener]]()
     private static var renderStateListeners = [String: [RenderStateListener]]()
     private static var safeAreaInsetsListeners = [String: [SafeAreaListener]]()
-    private static var voiceInputManager: VoiceInputManager?
+
 
     override init() {
         HybridAutoPlay.listeners.removeAll()
@@ -83,6 +83,10 @@ class HybridAutoPlay: HybridAutoPlaySpec {
         return SceneStore.isRootModuleConnected()
     }
 
+    func isCarServiceRunning() throws -> Bool {
+        return SceneStore.isRootModuleConnected()
+    }
+
     func addSafeAreaInsetsListener(
         moduleName: String,
         callback: @escaping (SafeAreaInsets) -> Void
@@ -119,55 +123,10 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     func addListenerVoiceInput(
         callback: @escaping (Location?, String?) -> Void
     ) throws -> () -> Void {
-        // iOS does not use the OS-triggered voice input path — use startVoiceInput() instead.
+        // iOS does not use the OS-triggered voice input path — use HybridVoice instead.
         return {}
     }
 
-    func hasVoiceInputPermission() throws -> Bool {
-        return AVAudioSession.sharedInstance().recordPermission == .granted
-    }
-
-    func requestVoiceInputPermission() throws -> Promise<Bool> {
-        return Promise.async {
-            return await withCheckedContinuation { cont in
-                AVAudioSession.sharedInstance().requestRecordPermission { granted in
-                    cont.resume(returning: granted)
-                }
-            }
-        }
-    }
-
-    func startVoiceInput(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?) throws -> Promise<
-        ArrayBuffer
-    > {
-        return Promise.async {
-            let interfaceController = try? await RootModule.withInterfaceController { $0 }
-
-            let manager = VoiceInputManager()
-            HybridAutoPlay.voiceInputManager = manager
-
-            defer {
-                HybridAutoPlay.voiceInputManager = nil
-            }
-
-            let data = try await manager.start(
-                interfaceController: interfaceController,
-                silenceThresholdMs: silenceThresholdMs ?? 1_500,
-                maxDurationMs: maxDurationMs ?? 10_000,
-                listeningText: listeningText ?? "Listening..."
-            )
-
-            return try ArrayBuffer.copy(data: data)
-        }
-    }
-
-    func stopVoiceInput() throws {
-        Task { @MainActor in
-            let interfaceController = try? await RootModule.withInterfaceController { $0 }
-            HybridAutoPlay.voiceInputManager?.stop(interfaceController: interfaceController)
-        }
-    }
-
     // MARK: set/push/pop templates
     func setRootTemplate(templateId: String) throws -> Promise<Void> {
         return Promise.async {

package/ios/hybrid/HybridVoice.swift

@@ -0,0 +1,65 @@
+import AVFoundation
+import NitroModules
+import Speech
+
+class HybridVoice: HybridVoiceSpec {
+    private var voiceInputManager: VoiceInputManager?
+
+    func hasVoiceInputPermission() throws -> Bool {
+        let micGranted = AVAudioSession.sharedInstance().recordPermission == .granted
+        let speechGranted = SFSpeechRecognizer.authorizationStatus() == .authorized
+        return micGranted && speechGranted
+    }
+
+    func requestVoiceInputPermission() throws -> Promise<Bool> {
+        return Promise.async {
+            let micGranted = await withCheckedContinuation { cont in
+                AVAudioSession.sharedInstance().requestRecordPermission { granted in
+                    cont.resume(returning: granted)
+                }
+            }
+            guard micGranted else { return false }
+
+            return await withCheckedContinuation { cont in
+                SFSpeechRecognizer.requestAuthorization { status in
+                    cont.resume(returning: status == .authorized)
+                }
+            }
+        }
+    }
+
+    func startVoiceInput(
+        silenceThresholdMs: Double?,
+        maxDurationMs: Double?,
+        listeningText: String?,
+        preferSpeechToText: Bool?,
+        onChunk: ((_ chunk: VoiceInputChunk) -> Void)?,
+        language: String?
+    ) throws -> Promise<VoiceInputResult> {
+        return Promise.async {
+            let interfaceController = try? await RootModule.withInterfaceController { $0 }
+
+            let manager = VoiceInputManager()
+            self.voiceInputManager = manager
+
+            defer { self.voiceInputManager = nil }
+
+            return try await manager.start(
+                interfaceController: interfaceController,
+                silenceThresholdMs: silenceThresholdMs ?? 1_500,
+                maxDurationMs: maxDurationMs ?? 10_000,
+                listeningText: listeningText ?? "Listening...",
+                preferSpeechToText: preferSpeechToText ?? false,
+                onChunk: onChunk,
+                language: language
+            )
+        }
+    }
+
+    func stopVoiceInput() throws {
+        Task { @MainActor in
+            let interfaceController = try? await RootModule.withInterfaceController { $0 }
+            self.voiceInputManager?.stop(interfaceController: interfaceController)
+        }
+    }
+}

package/ios/utils/VoiceInputManager.swift

@@ -1,16 +1,47 @@
 import AVFoundation
 import CarPlay
+import NitroModules
+import Speech
 
-/// Captures audio from the car microphone and buffers raw 16 kHz / 16-bit / mono PCM.
-/// Recording stops automatically when silence is detected or the max duration is reached.
+/// Wraps CheckedContinuation so it can only be resumed once even when
+/// shared between a stop() call and an async recognition task callback.
+private final class ResultBox: @unchecked Sendable {
+    private var continuation: CheckedContinuation<VoiceInputResult, Error>?
+    private let lock = NSLock()
+
+    init(_ continuation: CheckedContinuation<VoiceInputResult, Error>) {
+        self.continuation = continuation
+    }
+
+    func resume(returning result: VoiceInputResult) {
+        lock.lock()
+        defer { lock.unlock() }
+        continuation?.resume(returning: result)
+        continuation = nil
+    }
+
+    func resume(throwing error: Error) {
+        lock.lock()
+        defer { lock.unlock() }
+        continuation?.resume(throwing: error)
+        continuation = nil
+    }
+}
+
+/// Captures audio from the car microphone and buffers raw 16 kHz / 16-bit / mono PCM,
+/// or transcribes it via SFSpeechRecognizer when preferSpeechToText is true.
 class VoiceInputManager {
     private var audioEngine: AVAudioEngine?
     private var voiceControlTemplate: CPVoiceControlTemplate?
-    private var continuation: CheckedContinuation<[Int16], Error>?
+    private var resultBox: ResultBox?
     private var samples: [Int16] = []
     private var isStopping = false
     private let stopLock = NSLock()
 
+    // STT
+    private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest?
+    private var isSTTMode = false
+
     // Timing
     private var recordingStart: Date?
     private var silenceStart: Date?
@@ -33,30 +64,35 @@ class VoiceInputManager {
         interfaceController: AutoPlayInterfaceController?,
         silenceThresholdMs: Double,
         maxDurationMs: Double,
-        listeningText: String
-    ) async throws -> Data {
-        let samples = try await withCheckedThrowingContinuation {
-            (cont: CheckedContinuation<[Int16], Error>) in
-            self.continuation = cont
+        listeningText: String,
+        preferSpeechToText: Bool,
+        onChunk: ((_ chunk: VoiceInputChunk) -> Void)?,
+        language: String?
+    ) async throws -> VoiceInputResult {
+        return try await withCheckedThrowingContinuation { cont in
+            let box = ResultBox(cont)
+            self.resultBox = box
             self.samples = []
             self.isStopping = false
+            self.isSTTMode = preferSpeechToText
 
             do {
                 try self.startCapture(
                     interfaceController: interfaceController,
                     silenceThresholdMs: silenceThresholdMs,
                     maxDurationMs: maxDurationMs,
-                    listeningText: listeningText
+                    listeningText: listeningText,
+                    preferSpeechToText: preferSpeechToText,
+                    onChunk: onChunk,
+                    box: box,
+                    language: language
                 )
             }
             catch {
-                self.stopCapture(interfaceController: interfaceController)
-                self.continuation = nil
-                cont.resume(throwing: error)
+                self.cleanup(interfaceController: interfaceController)
+                box.resume(throwing: error)
             }
         }
-
-        return samplesAsData(samples)
     }
 
     func stop(interfaceController: AutoPlayInterfaceController? = nil) {
@@ -66,14 +102,22 @@ class VoiceInputManager {
             return
         }
         isStopping = true
-        let capturedContinuation = continuation
+        let wasSTTMode = isSTTMode
+        let box = resultBox
         let capturedSamples = samples
-        continuation = nil
+        resultBox = nil
         samples = []
         stopLock.unlock()
 
-        stopCapture(interfaceController: interfaceController)
-        capturedContinuation?.resume(returning: capturedSamples)
+        if wasSTTMode {
+            // endAudio() causes the recognition task to fire its final result,
+            // which resumes the box. Engine teardown happens there too.
+            recognitionRequest?.endAudio()
+        }
+        else {
+            cleanup(interfaceController: interfaceController)
+            box?.resume(returning: makePCMResult(from: capturedSamples))
+        }
     }
 
     // MARK: - Private
@@ -82,13 +126,16 @@ class VoiceInputManager {
         interfaceController: AutoPlayInterfaceController?,
         silenceThresholdMs: Double,
         maxDurationMs: Double,
-        listeningText: String
+        listeningText: String,
+        preferSpeechToText: Bool,
+        onChunk: ((_ chunk: VoiceInputChunk) -> Void)?,
+        box: ResultBox,
+        language: String?
     ) throws {
         guard AVAudioSession.sharedInstance().recordPermission == .granted else {
             throw VoiceInputError.microphonePermissionDenied
         }
 
-        // Activate the session first so inputNode reports the correct hardware format
         let session = AVAudioSession.sharedInstance()
         try session.setCategory(.playAndRecord, mode: .measurement, options: [])
         try session.setActive(true)
@@ -97,12 +144,59 @@ class VoiceInputManager {
             presentVoiceTemplate(interfaceController: interfaceController, listeningText: listeningText)
         }
 
+        var activeRecognitionRequest: SFSpeechAudioBufferRecognitionRequest? = nil
+
+        if preferSpeechToText, SFSpeechRecognizer.authorizationStatus() == .authorized,
+            let recognizer = language != nil ? SFSpeechRecognizer(locale: Locale(identifier: language!)) : SFSpeechRecognizer(locale: Locale.current),
+            recognizer.isAvailable
+        {
+            let request = SFSpeechAudioBufferRecognitionRequest()
+            request.shouldReportPartialResults = true
+            recognitionRequest = request
+            activeRecognitionRequest = request
+
+            recognizer.recognitionTask(with: request) { [weak self] result, error in
+                guard let self else { return }
+
+                if error != nil {
+                    // STT failed — fall back to whatever PCM was accumulated
+                    self.stopLock.lock()
+                    let capturedSamples = self.samples
+                    self.samples = []
+                    self.stopLock.unlock()
+
+                    self.cleanup(interfaceController: interfaceController)
+                    box.resume(returning: self.makePCMResult(from: capturedSamples))
+                    return
+                }
+
+                guard let result else { return }
+
+                if result.isFinal {
+                    self.stopLock.lock()
+                    self.isStopping = true
+                    self.samples = []
+                    self.stopLock.unlock()
+
+                    self.cleanup(interfaceController: interfaceController)
+                    box.resume(
+                        returning: VoiceInputResult(
+                            transcription: result.bestTranscription.formattedString,
+                            audio: nil
+                        )
+                    )
+                }
+                else {
+                    onChunk?(VoiceInputChunk(partial: result.bestTranscription.formattedString, audio: nil))
+                }
+            }
+        }
+
         let engine = AVAudioEngine()
         let inputNode = engine.inputNode
         let nativeFormat = inputNode.outputFormat(forBus: 0)
 
-        let targetFormat = VoiceInputManager.targetFormat
-        guard let converter = AVAudioConverter(from: nativeFormat, to: targetFormat) else {
+        guard let converter = AVAudioConverter(from: nativeFormat, to: VoiceInputManager.targetFormat) else {
             throw VoiceInputError.converterUnavailable
         }
 
@@ -116,36 +210,43 @@ class VoiceInputManager {
         ) { [weak self] buffer, _ in
             guard let self, !self.isStopping else { return }
 
+            // Feed STT if active
+            activeRecognitionRequest?.append(buffer)
+
+            // Convert to 16kHz int16 for accumulation and PCM chunks
             let outputFrameCapacity = AVAudioFrameCount(
-                Double(buffer.frameLength)
-                    * VoiceInputManager.sampleRate
-                    / nativeFormat.sampleRate
+                Double(buffer.frameLength) * VoiceInputManager.sampleRate / nativeFormat.sampleRate
             )
-
             guard
                 let outputBuffer = AVAudioPCMBuffer(
-                    pcmFormat: targetFormat,
+                    pcmFormat: VoiceInputManager.targetFormat,
                     frameCapacity: outputFrameCapacity
                 )
             else { return }
 
             var conversionError: NSError?
-            let status = converter.convert(to: outputBuffer, error: &conversionError) {
-                _,
-                outStatus in
+            let status = converter.convert(to: outputBuffer, error: &conversionError) { _, outStatus in
                 outStatus.pointee = .haveData
                 return buffer
             }
-
             guard status != .error, let int16Data = outputBuffer.int16ChannelData else { return }
 
             let frameCount = Int(outputBuffer.frameLength)
             let newSamples = Array(UnsafeBufferPointer(start: int16Data[0], count: frameCount))
             self.samples.append(contentsOf: newSamples)
 
+            // PCM chunk callback
+            if activeRecognitionRequest == nil, let onChunk {
+                if let chunkBuffer = try? ArrayBuffer.copy(
+                    data: newSamples.withUnsafeBufferPointer { Data(buffer: $0) }
+                ) {
+                    onChunk(VoiceInputChunk(partial: nil, audio: chunkBuffer))
+                }
+            }
+
             let now = Date()
 
-            // Max duration check
+            // Max duration — applies in both modes
             if let start = self.recordingStart,
                 now.timeIntervalSince(start) * 1000 >= maxDurationMs
             {
@@ -160,7 +261,9 @@ class VoiceInputManager {
             {
                 let peak = newSamples.reduce(0) { max($0, abs(Int($1))) }
                 if peak < VoiceInputManager.silenceAmplitudeThreshold {
-                    if self.silenceStart == nil { self.silenceStart = now }
+                    if self.silenceStart == nil {
+                        self.silenceStart = now
+                    }
                     if let silenceBegin = self.silenceStart,
                         now.timeIntervalSince(silenceBegin) * 1000 >= silenceThresholdMs
                     {
@@ -183,10 +286,11 @@ class VoiceInputManager {
         }
     }
 
-    private func stopCapture(interfaceController: AutoPlayInterfaceController?) {
+    private func cleanup(interfaceController: AutoPlayInterfaceController?) {
         audioEngine?.inputNode.removeTap(onBus: 0)
         audioEngine?.stop()
         audioEngine = nil
+        recognitionRequest = nil
         recordingStart = nil
         silenceStart = nil
         try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
@@ -195,6 +299,12 @@ class VoiceInputManager {
         }
     }
 
+    private func makePCMResult(from samples: [Int16]) -> VoiceInputResult {
+        let data = samples.withUnsafeBufferPointer { Data(buffer: $0) }
+        let buffer = try? ArrayBuffer.copy(data: data)
+        return VoiceInputResult(transcription: nil, audio: buffer)
+    }
+
     private func presentVoiceTemplate(interfaceController: AutoPlayInterfaceController, listeningText: String) {
         let listeningState = CPVoiceControlState(
             identifier: "listening",
@@ -218,12 +328,6 @@ class VoiceInputManager {
         }
         voiceControlTemplate = nil
     }
-
-    private func samplesAsData(_ samples: [Int16]) -> Data {
-        samples.withUnsafeBufferPointer { ptr in
-            Data(buffer: ptr)
-        }
-    }
 }
 
 enum VoiceInputError: Error {

package/lib/HybridAutoPlay.d.ts

@@ -0,0 +1,2 @@
+import type { AutoPlay } from './specs/AutoPlay.nitro';
+export declare const HybridAutoPlay: AutoPlay;

package/lib/HybridAutoPlay.js

@@ -0,0 +1,2 @@
+import { NitroModules } from 'react-native-nitro-modules';
+export const HybridAutoPlay = NitroModules.createHybridObject('AutoPlay');

package/lib/components/OnAppearedChildRenderer.d.ts

@@ -0,0 +1,10 @@
+type Props = {
+    children: React.ReactNode;
+    moduleName: string;
+};
+/**
+ * renders the passed children when the specified scene/screen appeared
+ * this makes sure child hooks are executed only when the map template is ready
+ */
+export default function OnAppearedChildRenderer({ children, moduleName }: Props): import("react").ReactNode;
+export {};

package/lib/components/OnAppearedChildRenderer.js

@@ -0,0 +1,26 @@
+import { useEffect, useState } from 'react';
+import { HybridAutoPlay } from '../hybrid/HybridAutoPlay';
+/**
+ * renders the passed children when the specified scene/screen appeared
+ * this makes sure child hooks are executed only when the map template is ready
+ */
+export default function OnAppearedChildRenderer({ children, moduleName }) {
+    const [didAppear, setDidAppear] = useState(false);
+    useEffect(() => {
+        let remove = HybridAutoPlay.addListenerRenderState(moduleName, (renderState) => {
+            if (renderState === 'didAppear') {
+                remove?.();
+                remove = null;
+                setDidAppear(true);
+            }
+        });
+        return () => {
+            remove?.();
+            remove = null;
+        };
+    }, [moduleName]);
+    if (didAppear) {
+        return children;
+    }
+    return null;
+}

package/lib/hooks/useIsAutoPlayFocused.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A hook to determine if the CarPlay/Android Auto screen is currently focused (visible).
+ *
+ * @param moduleName The name of the module to listen to.
+ * @returns `true` if the screen is focused, `false` otherwise.
+ */
+export declare function useIsAutoPlayFocused(moduleName: string): boolean;

package/lib/hooks/useIsAutoPlayFocused.js

@@ -0,0 +1,20 @@
+import { useEffect, useState } from 'react';
+import { HybridAutoPlay } from '..';
+/**
+ * A hook to determine if the CarPlay/Android Auto screen is currently focused (visible).
+ *
+ * @param moduleName The name of the module to listen to.
+ * @returns `true` if the screen is focused, `false` otherwise.
+ */
+export function useIsAutoPlayFocused(moduleName) {
+    const [isFocused, setIsFocused] = useState(false);
+    useEffect(() => {
+        const remove = HybridAutoPlay.addListenerRenderState(moduleName, (state) => {
+            setIsFocused(state === 'didAppear');
+        });
+        return () => {
+            remove();
+        };
+    }, [moduleName]);
+    return isFocused;
+}

package/lib/hybrid/HybridVoice.d.ts

@@ -0,0 +1,52 @@
+import type { VoiceInputOptions, VoiceInputResult } from '../types/Voice';
+type StartVoiceInput = {
+    (options: VoiceInputOptions & Required<Pick<VoiceInputOptions, 'onChunk'>>): Promise<VoiceInputResult>;
+    (options?: Omit<VoiceInputOptions, 'onChunk'>): Promise<VoiceInputResult>;
+};
+export declare const HybridVoice: {
+    /**
+     * Returns true if all permissions required for voice input are granted.
+     * On iOS: checks both microphone and speech recognition authorization.
+     * On Android: checks RECORD_AUDIO permission.
+     */
+    hasVoiceInputPermission: () => boolean;
+    /**
+     * Request all permissions required for voice input.
+     * On iOS: requests microphone permission then speech recognition authorization.
+     * On Android: requests RECORD_AUDIO via car context when connected, otherwise
+     * via the React Native application context.
+     * Returns true only if all required permissions were granted.
+     */
+    requestVoiceInputPermission: () => Promise<boolean>;
+    /**
+     * Start an in-app voice session.
+     *
+     * When preferSpeechToText is true:
+     *   iOS — streams audio buffers into SFSpeechRecognizer during recording;
+     *          onChunk fires with partial transcription results; resolves with
+     *          { transcription } or falls back to { audio } if unavailable.
+     *   Android — checks SpeechRecognizer availability upfront; if available it
+     *              owns the mic and streams partial results via onChunk; if not
+     *              available falls back to PCM recording.
+     *
+     * When preferSpeechToText is false (default):
+     *   Both platforms record raw PCM; onChunk fires with audio chunks;
+     *   resolves with { audio }.
+     *
+     * @param silenceThresholdMs  ms of silence before auto-stop (default 1500)
+     * @param maxDurationMs       hard cap on recording duration (default 10000)
+     * @param listeningText       iOS only — text shown on CPVoiceControlTemplate
+     * @param preferSpeechToText  request STT transcription instead of raw PCM
+     * @param onChunk             optional streaming callback
+     * @param language            specify the language for the SpeechRecognizer, falls back to system language if not set
+     */
+    startVoiceInput: StartVoiceInput;
+    /**
+     * Stop the active voice session early.
+     * For PCM mode: resolves startVoiceInput with audio captured so far.
+     * For STT mode: finalises the recognition request.
+     * No-op if no session is active.
+     */
+    stopVoiceInput: () => void;
+};
+export {};

package/lib/hybrid/HybridVoice.js

@@ -0,0 +1,52 @@
+import { NitroModules } from 'react-native-nitro-modules';
+const _native = NitroModules.createHybridObject('Voice');
+const startVoiceInput = async (options) => {
+    const { onChunk, silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText, language, } = options ?? {};
+    return await _native.startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText, onChunk, language);
+};
+export const HybridVoice = {
+    /**
+     * Returns true if all permissions required for voice input are granted.
+     * On iOS: checks both microphone and speech recognition authorization.
+     * On Android: checks RECORD_AUDIO permission.
+     */
+    hasVoiceInputPermission: () => _native.hasVoiceInputPermission(),
+    /**
+     * Request all permissions required for voice input.
+     * On iOS: requests microphone permission then speech recognition authorization.
+     * On Android: requests RECORD_AUDIO via car context when connected, otherwise
+     * via the React Native application context.
+     * Returns true only if all required permissions were granted.
+     */
+    requestVoiceInputPermission: () => _native.requestVoiceInputPermission(),
+    /**
+     * Start an in-app voice session.
+     *
+     * When preferSpeechToText is true:
+     *   iOS — streams audio buffers into SFSpeechRecognizer during recording;
+     *          onChunk fires with partial transcription results; resolves with
+     *          { transcription } or falls back to { audio } if unavailable.
+     *   Android — checks SpeechRecognizer availability upfront; if available it
+     *              owns the mic and streams partial results via onChunk; if not
+     *              available falls back to PCM recording.
+     *
+     * When preferSpeechToText is false (default):
+     *   Both platforms record raw PCM; onChunk fires with audio chunks;
+     *   resolves with { audio }.
+     *
+     * @param silenceThresholdMs  ms of silence before auto-stop (default 1500)
+     * @param maxDurationMs       hard cap on recording duration (default 10000)
+     * @param listeningText       iOS only — text shown on CPVoiceControlTemplate
+     * @param preferSpeechToText  request STT transcription instead of raw PCM
+     * @param onChunk             optional streaming callback
+     * @param language            specify the language for the SpeechRecognizer, falls back to system language if not set
+     */
+    startVoiceInput,
+    /**
+     * Stop the active voice session early.
+     * For PCM mode: resolves startVoiceInput with audio captured so far.
+     * For STT mode: finalises the recognition request.
+     * No-op if no session is active.
+     */
+    stopVoiceInput: () => _native.stopVoiceInput(),
+};

package/lib/hybrid.d.ts

@@ -0,0 +1,2 @@
+import type { AutoPlay as NitroAutoPlay } from './specs/AutoPlay.nitro';
+export declare const HybridAutoPlay: NitroAutoPlay;

package/lib/hybrid.js

@@ -0,0 +1,2 @@
+import { NitroModules } from 'react-native-nitro-modules';
+export const HybridAutoPlay = NitroModules.createHybridObject('AutoPlay');

package/lib/index.d.ts

@@ -1,7 +1,8 @@
 import { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
 import { HybridAutoPlay } from './hybrid/HybridAutoPlay';
+import { HybridVoice } from './hybrid/HybridVoice';
 import type { AndroidAutomotive } from './specs/AndroidAutomotive.nitro';
-export { HybridAndroidAutoTelemetry, HybridAutoPlay };
+export { HybridAndroidAutoTelemetry, HybridAutoPlay, HybridVoice };
 export declare const HybridAndroidAutomotive: AndroidAutomotive | null;
 /**
  * These are the static module names for the app running on the mobile device, head unit screen and the CarPlay dashboard.
@@ -39,6 +40,7 @@ export * from './types/SignInMethod';
 export * from './types/Telemetry';
 export * from './types/Text';
 export * from './types/Trip';
+export type { VoiceInputChunk, VoiceInputOptions, VoiceInputResult } from './types/Voice';
 export type { AlertPriority, NavigationAlert as Alert, NavigationAlertAction as AlertAction, } from './utils/NitroAlert';
 export type { ThemedColor } from './utils/NitroColor';
 export type { GridButton } from './utils/NitroGrid';

package/lib/index.js

@@ -3,8 +3,9 @@ import { NitroModules } from 'react-native-nitro-modules';
 import AutoPlayHeadlessJsTask from './AutoPlayHeadlessJsTask';
 import { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
 import { HybridAutoPlay } from './hybrid/HybridAutoPlay';
+import { HybridVoice } from './hybrid/HybridVoice';
 AutoPlayHeadlessJsTask.registerHeadlessTask(HybridAutoPlay);
-export { HybridAndroidAutoTelemetry, HybridAutoPlay };
+export { HybridAndroidAutoTelemetry, HybridAutoPlay, HybridVoice };
 export const HybridAndroidAutomotive = Platform.OS === 'android'
     ? NitroModules.createHybridObject('AndroidAutomotive')
     : null;