@iternio/react-native-auto-play 0.3.12 → 0.3.14

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/template/MapTemplate.kt

@@ -66,10 +66,6 @@ class MapTemplate(
                 navigationManager.setNavigationManagerCallback(navigationManagerCallback)
             }
         }
-
-        config.defaultGuidanceBackgroundColor?.let { nitroColor ->
-            MapTemplate.cardBackgroundColor = Parser.parseColor(nitroColor)
-        }
     }
 
     override fun parse(): Template {

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/template/Parser.kt

@@ -598,11 +598,20 @@ object Parser {
         val image = result?.get()
         try {
             if (image is CloseableBitmap) {
-                return image.underlyingBitmap.copy(Bitmap.Config.ARGB_8888, false)
+                // underlyingBitmap can be null when Fresco decodes to a CloseableBitmap
+                // whose backing bitmap has already been recycled or failed to allocate;
+                // copy() can also throw (e.g., OOM on very large remote images). Either
+                // way we return null so the caller falls back to a placeholder icon.
+                return image.underlyingBitmap?.copy(Bitmap.Config.ARGB_8888, false)
             } else if (image is CloseableXml) {
                 val drawable = image.buildDrawable()
                 return drawable?.toBitmap(width = image.width, height = image.height, Bitmap.Config.ARGB_8888)
             }
+        } catch (_: Exception) {
+            // Any decode/copy failure (OOM, recycled bitmap, invalid config, …) should
+            // not crash the car app — the image is optional decoration and the caller
+            // handles a null return with CarIcon.ALERT.
+            return null
         } finally {
             image?.close()
             result?.close()

package/ios/utils/VoiceInputManager.swift

@@ -90,7 +90,7 @@ class VoiceInputManager {
 
         // Activate the session first so inputNode reports the correct hardware format
         let session = AVAudioSession.sharedInstance()
-        try session.setCategory(.playAndRecord, mode: .measurement, options: [.mixWithOthers])
+        try session.setCategory(.playAndRecord, mode: .measurement, options: [])
         try session.setActive(true)
 
         if let interfaceController {

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/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,12 @@
+import type { VoiceInputOptions, VoiceInputResult } from '../types/Voice';
+type StartVoiceInput = {
+    (options: VoiceInputOptions & Required<Pick<VoiceInputOptions, 'onChunk'>>): Promise<void>;
+    (options?: Omit<VoiceInputOptions, 'onChunk'>): Promise<VoiceInputResult>;
+};
+export declare const HybridVoice: {
+    hasVoiceInputPermission: () => boolean;
+    requestVoiceInputPermission: () => Promise<boolean>;
+    startVoiceInput: StartVoiceInput;
+    stopVoiceInput: () => void;
+};
+export {};

package/lib/hybrid/HybridVoice.js

@@ -0,0 +1,13 @@
+import { NitroModules } from 'react-native-nitro-modules';
+const _native = NitroModules.createHybridObject('Voice');
+const startVoiceInput = (async (options) => {
+    const { onChunk, silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText } = options ?? {};
+    const result = await _native.startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText, onChunk);
+    return onChunk !== undefined ? undefined : result;
+});
+export const HybridVoice = {
+    hasVoiceInputPermission: () => _native.hasVoiceInputPermission(),
+    requestVoiceInputPermission: () => _native.requestVoiceInputPermission(),
+    startVoiceInput,
+    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/specs/AutomotivePermissionRequestTemplate.d.ts

@@ -0,0 +1,11 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroAutomotivePermissionRequestTemplateConfig } from '../templates/AutomotivePermissionRequestTemplate';
+import type { NitroTemplateConfig } from './AutoPlay.nitro';
+interface AutomotivePermissionRequestTemplateConfig extends NitroTemplateConfig, NitroAutomotivePermissionRequestTemplateConfig {
+}
+export interface AutomotivePermissionRequestTemplate extends HybridObject<{
+    android: 'kotlin';
+}> {
+    createAutomotivePermissionRequestTemplate(config: AutomotivePermissionRequestTemplateConfig): void;
+}
+export {};

package/lib/specs/AutomotivePermissionRequestTemplate.js

@@ -0,0 +1 @@
+export {};

package/lib/specs/AutomotivePermissionRequestTemplate.nitro.d.ts

@@ -0,0 +1,11 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroAutomotivePermissionRequestTemplateConfig } from '../templates/AutomotivePermissionRequestTemplate';
+import type { NitroTemplateConfig } from './AutoPlay.nitro';
+interface AutomotivePermissionRequestTemplateConfig extends NitroTemplateConfig, NitroAutomotivePermissionRequestTemplateConfig {
+}
+export interface AutomotivePermissionRequestTemplate extends HybridObject<{
+    android: 'kotlin';
+}> {
+    createAutomotivePermissionRequestTemplate(config: AutomotivePermissionRequestTemplateConfig): void;
+}
+export {};

package/lib/specs/AutomotivePermissionRequestTemplate.nitro.js

@@ -0,0 +1 @@
+export {};

package/lib/specs/Voice.nitro.d.ts

@@ -0,0 +1,51 @@
+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/lib/specs/Voice.nitro.js

@@ -0,0 +1 @@
+export {};

package/lib/templates/AutomotivePermissionRequestTemplate.d.ts

@@ -0,0 +1,23 @@
+import type { CustomActionButtonAndroid } from '../types/Button';
+import type { AutoText } from '../types/Text';
+import { type NitroAction } from '../utils/NitroAction';
+import { type HeaderActions, Template, type TemplateConfig } from './Template';
+export interface NitroAutomotivePermissionRequestTemplateConfig extends TemplateConfig {
+    headerActions?: Array<NitroAction>;
+    title: AutoText;
+    actions: Array<NitroAction>;
+}
+export type AutomotivePermissionRequestTemplateConfig = Omit<NitroAutomotivePermissionRequestTemplateConfig, 'headerActions' | 'buttons'> & {
+    /**
+     * action buttons, usually at the the top right on Android and a top bar on iOS
+     */
+    headerActions?: HeaderActions<AutomotivePermissionRequestTemplate>;
+    actions: [CustomActionButtonAndroid<AutomotivePermissionRequestTemplate>] | [
+        CustomActionButtonAndroid<AutomotivePermissionRequestTemplate>,
+        CustomActionButtonAndroid<AutomotivePermissionRequestTemplate>
+    ];
+};
+export declare class AutomotivePermissionRequestTemplate extends Template<AutomotivePermissionRequestTemplateConfig, HeaderActions<AutomotivePermissionRequestTemplate>> {
+    private template;
+    constructor(config: AutomotivePermissionRequestTemplateConfig);
+}

package/lib/templates/AutomotivePermissionRequestTemplate.js

@@ -0,0 +1,18 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { NitroActionUtil } from '../utils/NitroAction';
+import { Template, } from './Template';
+const HybridAutomotivePermissionRequestTemplate = NitroModules.createHybridObject('AutomotivePermissionRequestTemplate');
+export class AutomotivePermissionRequestTemplate extends Template {
+    template = this;
+    constructor(config) {
+        super(config);
+        const { headerActions, actions, ...rest } = config;
+        const nitroConfig = {
+            ...rest,
+            id: this.id,
+            headerActions: NitroActionUtil.convert(this.template, headerActions),
+            actions: NitroActionUtil.convert(this.template, actions),
+        };
+        HybridAutomotivePermissionRequestTemplate.createAutomotivePermissionRequestTemplate(nitroConfig);
+    }
+}

package/lib/templates/MapTemplate.d.ts

@@ -96,7 +96,10 @@ export type MapTemplateConfig = Omit<NitroMapTemplateConfig, 'mapButtons' | 'hea
      */
     onAutoDriveEnabled?: (template: MapTemplate) => void;
     /**
-     * Initial navigation maneuver background color. Mainly useful, when in CarPlay the default loading maneuver does not have the right color.
+     * Use this to set the default maneuver background color on iOS.
+     * Only used when starting navigation and not providing any maneuvers yet,
+     * visible on the system provided loading maneuver then.
+     * @namespace iOS
      */
     defaultGuidanceBackgroundColor?: ThemedColor | string;
 };

package/lib/types/Voice.d.ts

@@ -0,0 +1,15 @@
+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;
+}

package/lib/types/Voice.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iternio/react-native-auto-play",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "Android Auto and Apple CarPlay for react-native",
   "main": "lib/index",
   "module": "lib/index",

package/src/templates/MapTemplate.ts

@@ -159,7 +159,10 @@ export type MapTemplateConfig = Omit<
     onAutoDriveEnabled?: (template: MapTemplate) => void;
 
     /**
-     * Initial navigation maneuver background color. Mainly useful, when in CarPlay the default loading maneuver does not have the right color.
+     * Use this to set the default maneuver background color on iOS.
+     * Only used when starting navigation and not providing any maneuvers yet,
+     * visible on the system provided loading maneuver then.
+     * @namespace iOS
      */
     defaultGuidanceBackgroundColor?: ThemedColor | string;
   };