@iternio/react-native-auto-play 0.4.6 → 0.4.8

package/src/hybrid/HybridVoice.ts

@@ -0,0 +1,79 @@
+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<VoiceInputResult>;
+  (options?: Omit<VoiceInputOptions, 'onChunk'>): Promise<VoiceInputResult>;
+};
+
+const startVoiceInput: StartVoiceInput = async (options?: VoiceInputOptions) => {
+  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/src/index.ts

@@ -3,11 +3,12 @@ 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 { HybridAndroidAutoTelemetry, HybridAutoPlay };
+export { HybridAndroidAutoTelemetry, HybridAutoPlay, HybridVoice };
 
 export const HybridAndroidAutomotive =
   Platform.OS === 'android'
@@ -54,6 +55,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,16 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { VoiceInputChunk, VoiceInputResult } from '../types/Voice';
+
+export interface Voice extends HybridObject<{ android: 'kotlin'; ios: 'swift' }> {
+  hasVoiceInputPermission(): boolean;
+  requestVoiceInputPermission(): Promise<boolean>;
+  startVoiceInput(
+    silenceThresholdMs?: number,
+    maxDurationMs?: number,
+    listeningText?: string,
+    preferSpeechToText?: boolean,
+    onChunk?: (chunk: VoiceInputChunk) => void,
+    language?: string
+  ): Promise<VoiceInputResult>;
+  stopVoiceInput(): void;
+}

package/src/templates/MapTemplate.ts

@@ -3,7 +3,6 @@ import { AppRegistry, Platform } from 'react-native';
 import { NitroModules } from 'react-native-nitro-modules';
 import type { AutoText } from '..';
 import { MapTemplateProvider } from '../components/MapTemplateContext';
-import OnAppearedChildRenderer from '../components/OnAppearedChildRenderer';
 import { SafeAreaInsetsProvider } from '../components/SafeAreaInsetsContext';
 import { HybridAutoPlay } from '../hybrid/HybridAutoPlay';
 import type { MapTemplate as NitroMapTemplate } from '../specs/MapTemplate.nitro';
@@ -197,11 +196,7 @@ export class MapTemplate extends Template<MapTemplateConfig, MapTemplateConfig['
           children: React.createElement(SafeAreaInsetsProvider, {
             moduleName: this.id,
             // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
-            children: React.createElement(OnAppearedChildRenderer, {
-              // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
-              children: React.createElement(component, props),
-              moduleName: this.id,
-            }),
+            children: React.createElement(component, props),
           }),
         })
     );

package/src/types/Voice.ts

@@ -0,0 +1,18 @@
+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;
+  language?: string;
+}

package/src/components/OnAppearedChildRenderer.tsx

@@ -1,37 +0,0 @@
-import { useEffect, useState } from 'react';
-import { HybridAutoPlay } from '../hybrid/HybridAutoPlay';
-import type { CleanupCallback } from '../types/Event';
-
-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) {
-  const [didAppear, setDidAppear] = useState(false);
-
-  useEffect(() => {
-    let remove: CleanupCallback | null = HybridAutoPlay.addListenerRenderState(
-      moduleName,
-      (renderState) => {
-        if (renderState === 'didAppear') {
-          remove?.();
-          remove = null;
-          setDidAppear(true);
-        }
-      }
-    );
-
-    return () => {
-      remove?.();
-      remove = null;
-    };
-  }, [moduleName]);
-
-  if (didAppear) {
-    return children;
-  }
-
-  return null;
-}