@iternio/react-native-auto-play 0.4.1 → 0.4.2

package/src/hybrid/HybridVoice.ts

@@ -0,0 +1,30 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type { Voice } from '../specs/Voice.nitro';
+import type { VoiceInputOptions, VoiceInputResult } from '../types/Voice';
+
+const _native = NitroModules.createHybridObject<Voice>('Voice');
+
+type StartVoiceInput = {
+  (options: VoiceInputOptions & Required<Pick<VoiceInputOptions, 'onChunk'>>): Promise<void>;
+  (options?: Omit<VoiceInputOptions, 'onChunk'>): Promise<VoiceInputResult>;
+};
+
+const startVoiceInput: StartVoiceInput = (async (options?: VoiceInputOptions) => {
+  const { onChunk, silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText } =
+    options ?? {};
+  const result = await _native.startVoiceInput(
+    silenceThresholdMs,
+    maxDurationMs,
+    listeningText,
+    preferSpeechToText,
+    onChunk
+  );
+  return onChunk !== undefined ? undefined : result;
+}) as unknown as StartVoiceInput;
+
+export const HybridVoice = {
+  hasVoiceInputPermission: () => _native.hasVoiceInputPermission(),
+  requestVoiceInputPermission: () => _native.requestVoiceInputPermission(),
+  startVoiceInput,
+  stopVoiceInput: () => _native.stopVoiceInput(),
+};

package/src/index.ts

@@ -3,11 +3,13 @@ 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';
 import type { AndroidAutomotive } from './specs/AndroidAutomotive.nitro';
 
 AutoPlayHeadlessJsTask.registerHeadlessTask(HybridAutoPlay);
 
 export { HybridAutoPlay };
+export { HybridVoice };
 export { HybridAndroidAutoTelemetry };
 
 export const HybridAndroidAutomotive =
@@ -55,6 +57,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,

package/src/specs/AutoPlay.nitro.ts

@@ -44,43 +44,6 @@ export interface AutoPlay extends HybridObject<{ android: 'kotlin'; ios: 'swift'
     callback: (coordinates: Location | undefined, query: string | undefined) => void
   ): CleanupCallback;
 
-  /**
-   * Returns true if microphone permission has already been granted.
-   */
-  hasVoiceInputPermission(): boolean;
-
-  /**
-   * Request microphone permission from the user.
-   * On Android: uses the car context when Android Auto is connected, otherwise
-   * falls back to the React Native application context.
-   * On iOS: uses AVAudioApplication (iOS 17+) or AVAudioSession (iOS 15–16).
-   * Returns true if permission was granted, false if denied.
-   */
-  requestVoiceInputPermission(): Promise<boolean>;
-
-  /**
-   * Start an in-app voice recording session.
-   * On Android: acquires audio focus and captures via CarAudioRecord when
-   * Android Auto is connected, otherwise uses standard AudioRecord.
-   * On iOS: presents CPVoiceControlTemplate (when a car is connected) and
-   * captures audio via AVAudioEngine.
-   * Resolves with the complete raw PCM buffer (16 kHz, 16-bit, mono) when
-   * silence is detected, the max duration is reached, or stopVoiceInput() is called.
-   * Rejects if microphone permission has not been granted or recording fails to start.
-   */
-  startVoiceInput(
-    silenceThresholdMs?: number,
-    maxDurationMs?: number,
-    listeningText?: string
-  ): Promise<ArrayBuffer>;
-
-  /**
-   * Stop the active voice recording session early. Causes the Promise returned
-   * by startVoiceInput() to resolve with the audio captured so far.
-   * No-op if no recording is in progress.
-   */
-  stopVoiceInput(): void;
-
   /**
    * sets the specified template as root template, initializes a new stack
    * Promise might contain an error message in case setting root template failed

package/src/specs/Voice.nitro.ts

@@ -0,0 +1,58 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { VoiceInputChunk, VoiceInputResult } from '../types/Voice';
+
+export interface Voice extends HybridObject<{ android: 'kotlin'; ios: 'swift' }> {
+  /**
+   * 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; when set the
+   *                            promise resolves with an empty VoiceInputResult
+   */
+  startVoiceInput(
+    silenceThresholdMs?: number,
+    maxDurationMs?: number,
+    listeningText?: string,
+    preferSpeechToText?: boolean,
+    onChunk?: (chunk: VoiceInputChunk) => void
+  ): Promise<VoiceInputResult>;
+
+  /**
+   * 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;
+}

package/src/types/Voice.ts

@@ -0,0 +1,17 @@
+export interface VoiceInputChunk {
+  partial?: string;
+  audio?: ArrayBuffer;
+}
+
+export interface VoiceInputResult {
+  transcription?: string;
+  audio?: ArrayBuffer;
+}
+
+export interface VoiceInputOptions {
+  silenceThresholdMs?: number;
+  maxDurationMs?: number;
+  listeningText?: string;
+  preferSpeechToText?: boolean;
+  onChunk?: (chunk: VoiceInputChunk) => void;
+}