@iternio/react-native-auto-play 0.3.11 → 0.3.13

package/ios/utils/SymbolFont.swift

@@ -9,67 +9,65 @@ import CoreText
 import UIKit
 
 class SymbolFont {
-    private static let defaultCanvasSize = 32
+    private static var cachedFontName: String?
+    private static var cachedPSName: String?
 
-    private static var isRegistered = false
-    private static var fontName: String?
-
-    static func loadFont() {
-        let podBundle = Bundle(for: SymbolFont.self)
+    private static func loadFont(named fontName: String) -> String? {
+        if fontName == cachedFontName {
+            return cachedPSName
+        }
 
-        guard
-            let bundleURL = podBundle.url(
-                forResource: "ReactNativeAutoPlay",
-                withExtension: "bundle"
-            ),
-            let resourceBundle = Bundle(url: bundleURL),
-            let fontURL = resourceBundle.url(
-                forResource: "MaterialSymbolsOutlined-Regular",
-                withExtension: "ttf"
-            )
-        else {
-            return
+        guard let url = Bundle.main.url(forResource: fontName, withExtension: "ttf") else {
+            print("[AutoPlay] \(fontName).ttf not found in the app bundle — glyph images will not render.")
+            return nil
         }
 
-        guard let fontData = try? Data(contentsOf: fontURL) as CFData,
+        guard let fontData = try? Data(contentsOf: url) as CFData,
             let provider = CGDataProvider(data: fontData),
             let font = CGFont(provider)
         else {
-            return
+            return nil
         }
 
         var error: Unmanaged<CFError>?
         CTFontManagerRegisterGraphicsFont(font, &error)
-        if let error = error?.takeUnretainedValue() {
-            print("Failed to register font: \(error)")
+        // Ignore already-registered errors (e.g. hot reload)
+
+        guard let psName = font.fullName as? String else {
+            return nil
         }
-        else {
-            print("Font \(font.fullName as String? ?? "unknown") registered")
+
+        cachedFontName = fontName
+        cachedPSName = psName
+        return psName
+    }
+
+    private static func uiFont(for glyphImage: GlyphImage, size: CGFloat, fontScale: CGFloat) -> UIFont? {
+        let pointSize = size * fontScale
+
+        guard let psName = loadFont(named: glyphImage.fontName) else {
+            return nil
         }
 
-        SymbolFont.fontName = font.fullName as? String
-        SymbolFont.isRegistered = true
+        return UIFont(name: psName, size: pointSize)
     }
 
     // creates a single color UIImage
     static func imageFromGlyph(
-        glyph: Double,
+        glyphImage: GlyphImage,
         foregroundColor: UIColor,
         backgroundColor: UIColor,
         size: CGFloat,
         fontScale: CGFloat
     ) -> UIImage? {
-        if !SymbolFont.isRegistered {
-            SymbolFont.loadFont()
+        guard let font = uiFont(for: glyphImage, size: size, fontScale: fontScale) else {
+            return nil
         }
 
-        guard let fontName = SymbolFont.fontName,
-            let font = UIFont(name: fontName, size: size * fontScale)
-        else {
+        guard let scalar = UnicodeScalar(UInt32(glyphImage.glyph)) else {
             return nil
         }
-
-        let codepoint = String(UnicodeScalar(UInt32(glyph))!)
+        let codepoint = String(Character(scalar))
         let canvasSize = CGSize(width: size, height: size)
         let rect = CGRect(origin: .zero, size: canvasSize)
 
@@ -99,14 +97,14 @@ class SymbolFont {
         let y = (canvasSize.height - textSize.height) / 2
         attrString.draw(at: CGPoint(x: x, y: y))
 
-        let image = UIGraphicsGetImageFromCurrentImageContext()
+        let uiImage = UIGraphicsGetImageFromCurrentImageContext()
         UIGraphicsEndImageContext()
 
-        return image
+        return uiImage
     }
 
     static func imageFromGlyph(
-        glyph: Double,
+        glyphImage: GlyphImage,
         size: CGFloat,
         foregroundColor: NitroColor,
         backgroundColor: NitroColor,
@@ -115,7 +113,7 @@ class SymbolFont {
     ) -> UIImage? {
         guard
             let lightImage = imageFromGlyph(
-                glyph: glyph,
+                glyphImage: glyphImage,
                 foregroundColor: Parser.doubleToColor(
                     value: foregroundColor.lightColor
                 ),
@@ -126,7 +124,7 @@ class SymbolFont {
                 fontScale: fontScale
             ),
             let darkImage = imageFromGlyph(
-                glyph: glyph,
+                glyphImage: glyphImage,
                 foregroundColor: Parser.doubleToColor(
                     value: foregroundColor.darkColor
                 ),
@@ -167,6 +165,8 @@ class SymbolFont {
     ) -> UIImage? {
         guard let image else { return nil }
 
+        let fontScale = image.fontScale ?? 1.0
+
         if noImageAsset {
             let foregroundColor = Parser.doubleToColor(
                 value: traitCollection.userInterfaceStyle == .light
@@ -180,21 +180,21 @@ class SymbolFont {
             )
 
             return SymbolFont.imageFromGlyph(
-                glyph: image.glyph,
+                glyphImage: image,
                 foregroundColor: foregroundColor,
                 backgroundColor: backgroundColor,
                 size: size,
-                fontScale: image.fontScale ?? 1.0
+                fontScale: fontScale
             )
         }
 
         return SymbolFont.imageFromGlyph(
-            glyph: image.glyph,
+            glyphImage: image,
             size: size,
             foregroundColor: image.color,
             backgroundColor: image.backgroundColor,
-            fontScale: image.fontScale ?? 1.0,
+            fontScale: fontScale,
             traitCollection: traitCollection
-        )!
+        )
     }
 }

package/ios/utils/VoiceInputManager.swift

@@ -0,0 +1,233 @@
+import AVFoundation
+import CarPlay
+
+/// 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.
+class VoiceInputManager {
+    private var audioEngine: AVAudioEngine?
+    private var voiceControlTemplate: CPVoiceControlTemplate?
+    private var continuation: CheckedContinuation<[Int16], Error>?
+    private var samples: [Int16] = []
+    private var isStopping = false
+    private let stopLock = NSLock()
+
+    // Timing
+    private var recordingStart: Date?
+    private var silenceStart: Date?
+
+    private static let sampleRate: Double = 16_000
+    private static let tapBufferSize: AVAudioFrameCount = 4_096
+    private static let silenceAmplitudeThreshold = 500
+    private static let warmupMs: Double = 500
+
+    private static let targetFormat = AVAudioFormat(
+        commonFormat: .pcmFormatInt16,
+        sampleRate: sampleRate,
+        channels: 1,
+        interleaved: true
+    )!
+
+    // MARK: - Public
+
+    func start(
+        interfaceController: AutoPlayInterfaceController?,
+        silenceThresholdMs: Double,
+        maxDurationMs: Double,
+        listeningText: String
+    ) async throws -> Data {
+        let samples = try await withCheckedThrowingContinuation {
+            (cont: CheckedContinuation<[Int16], Error>) in
+            self.continuation = cont
+            self.samples = []
+            self.isStopping = false
+
+            do {
+                try self.startCapture(
+                    interfaceController: interfaceController,
+                    silenceThresholdMs: silenceThresholdMs,
+                    maxDurationMs: maxDurationMs,
+                    listeningText: listeningText
+                )
+            }
+            catch {
+                self.stopCapture(interfaceController: interfaceController)
+                self.continuation = nil
+                cont.resume(throwing: error)
+            }
+        }
+
+        return samplesAsData(samples)
+    }
+
+    func stop(interfaceController: AutoPlayInterfaceController? = nil) {
+        stopLock.lock()
+        guard !isStopping else {
+            stopLock.unlock()
+            return
+        }
+        isStopping = true
+        let capturedContinuation = continuation
+        let capturedSamples = samples
+        continuation = nil
+        samples = []
+        stopLock.unlock()
+
+        stopCapture(interfaceController: interfaceController)
+        capturedContinuation?.resume(returning: capturedSamples)
+    }
+
+    // MARK: - Private
+
+    private func startCapture(
+        interfaceController: AutoPlayInterfaceController?,
+        silenceThresholdMs: Double,
+        maxDurationMs: Double,
+        listeningText: 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)
+
+        if let interfaceController {
+            presentVoiceTemplate(interfaceController: interfaceController, listeningText: listeningText)
+        }
+
+        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 {
+            throw VoiceInputError.converterUnavailable
+        }
+
+        recordingStart = Date()
+        silenceStart = nil
+
+        inputNode.installTap(
+            onBus: 0,
+            bufferSize: VoiceInputManager.tapBufferSize,
+            format: nativeFormat
+        ) { [weak self] buffer, _ in
+            guard let self, !self.isStopping else { return }
+
+            let outputFrameCapacity = AVAudioFrameCount(
+                Double(buffer.frameLength)
+                    * VoiceInputManager.sampleRate
+                    / nativeFormat.sampleRate
+            )
+
+            guard
+                let outputBuffer = AVAudioPCMBuffer(
+                    pcmFormat: targetFormat,
+                    frameCapacity: outputFrameCapacity
+                )
+            else { return }
+
+            var conversionError: NSError?
+            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)
+
+            let now = Date()
+
+            // Max duration check
+            if let start = self.recordingStart,
+                now.timeIntervalSince(start) * 1000 >= maxDurationMs
+            {
+                self.triggerAutoStop(interfaceController: interfaceController)
+                return
+            }
+
+            // Silence detection — skip during warm-up so the pipeline has time
+            // to stabilise before we start measuring amplitude
+            if let start = self.recordingStart,
+                now.timeIntervalSince(start) * 1000 >= VoiceInputManager.warmupMs
+            {
+                let peak = newSamples.reduce(0) { max($0, abs(Int($1))) }
+                if peak < VoiceInputManager.silenceAmplitudeThreshold {
+                    if self.silenceStart == nil { self.silenceStart = now }
+                    if let silenceBegin = self.silenceStart,
+                        now.timeIntervalSince(silenceBegin) * 1000 >= silenceThresholdMs
+                    {
+                        self.triggerAutoStop(interfaceController: interfaceController)
+                    }
+                }
+                else {
+                    self.silenceStart = nil
+                }
+            }
+        }
+
+        try engine.start()
+        audioEngine = engine
+    }
+
+    private func triggerAutoStop(interfaceController: AutoPlayInterfaceController?) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            self.stop(interfaceController: interfaceController)
+        }
+    }
+
+    private func stopCapture(interfaceController: AutoPlayInterfaceController?) {
+        audioEngine?.inputNode.removeTap(onBus: 0)
+        audioEngine?.stop()
+        audioEngine = nil
+        recordingStart = nil
+        silenceStart = nil
+        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+        if let interfaceController {
+            dismissVoiceTemplate(interfaceController: interfaceController)
+        }
+    }
+
+    private func presentVoiceTemplate(interfaceController: AutoPlayInterfaceController, listeningText: String) {
+        let listeningState = CPVoiceControlState(
+            identifier: "listening",
+            titleVariants: [listeningText],
+            image: nil,
+            repeats: true
+        )
+        let template = CPVoiceControlTemplate(voiceControlStates: [listeningState])
+        initTemplate(template: template, id: "voice-input")
+        voiceControlTemplate = template
+
+        Task { @MainActor in
+            try? await interfaceController.presentTemplate(template, animated: true)
+            template.activateVoiceControlState(withIdentifier: "listening")
+        }
+    }
+
+    private func dismissVoiceTemplate(interfaceController: AutoPlayInterfaceController) {
+        Task { @MainActor in
+            try? await interfaceController.dismissTemplate(animated: true)
+        }
+        voiceControlTemplate = nil
+    }
+
+    private func samplesAsData(_ samples: [Int16]) -> Data {
+        samples.withUnsafeBufferPointer { ptr in
+            Data(buffer: ptr)
+        }
+    }
+}
+
+enum VoiceInputError: Error {
+    case microphonePermissionDenied
+    case converterUnavailable
+    case noActiveSession
+}

package/lib/index.d.ts

@@ -43,3 +43,4 @@ export * from './types/Trip';
 export type { AlertPriority, NavigationAlert as Alert, NavigationAlertAction as AlertAction, } from './utils/NitroAlert';
 export type { ThemedColor } from './utils/NitroColor';
 export type { GridButton } from './utils/NitroGrid';
+export { setIconFont } from './utils/NitroImage';

package/lib/index.js

@@ -45,3 +45,4 @@ export * from './types/SignInMethod';
 export * from './types/Telemetry';
 export * from './types/Text';
 export * from './types/Trip';
+export { setIconFont } from './utils/NitroImage';

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

@@ -24,12 +24,42 @@ export interface AutoPlay extends HybridObject<{
      */
     addListenerRenderState(moduleName: string, callback: (payload: VisibilityState) => void): CleanupCallback;
     /**
-     * Adds a listener for voice input events. Not implemented on iOS.
+     * Adds a listener for voice input events fired by the OS (Android Auto only).
+     * On iOS this is a no-op — use startVoiceInput instead.
      * @param callback the callback to receive the voice input
      * @returns callback to remove the listener
      * @namespace Android
      */
     addListenerVoiceInput(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/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/Image.d.ts

@@ -1,8 +1,22 @@
 import type { ImageSourcePropType } from 'react-native';
 import type { ThemedColor } from '../utils/NitroColor';
-import type { GlyphName } from './Glyphmap';
-export type AutoImage = {
-    name: GlyphName;
+/**
+ * Augment this interface in your app to get type-safe glyph name autocompletion.
+ *
+ * @example
+ * ```ts
+ * // autoplay-glyphs.d.ts
+ * import type { GlyphName } from './assets/symbolFont/Glyphmap';
+ * declare module '@iternio/react-native-auto-play' {
+ *   interface AutoPlayGlyphMap extends Record<GlyphName, number> {}
+ * }
+ * ```
+ */
+export interface AutoPlayGlyphMap {
+}
+/** Resolves to the augmented glyph name union, or falls back to `string` when not augmented. */
+export type GlyphMapKey = keyof AutoPlayGlyphMap extends never ? string : Extract<keyof AutoPlayGlyphMap, string>;
+type GlyphStyleFields = {
     /**
      * Sets the icon dark and light mode color or a single color for both.
      * Defaults to white for dark mode and black for light mode if not specified.
@@ -15,8 +29,22 @@ export type AutoImage = {
      */
     backgroundColor?: ThemedColor | string;
     fontScale?: number;
+};
+/** Glyph by name — looked up in the glyph map registered via {@link setIconFont}. */
+export type AutoGlyphByName = GlyphStyleFields & {
     type: 'glyph';
-} | {
+    /** Key in the glyph map passed to `setIconFont`. */
+    name: GlyphMapKey;
+    /** Optional override — if set, used instead of the map lookup. */
+    codepoint?: number;
+};
+/** Glyph by raw Unicode code point. */
+export type AutoGlyphByCodepoint = GlyphStyleFields & {
+    type: 'glyph';
+    codepoint: number;
+};
+export type AutoGlyph = AutoGlyphByName | AutoGlyphByCodepoint;
+export type AutoImage = AutoGlyph | {
     image: ImageSourcePropType;
     /**
      * if specified the image gets tinted, if not it will just use the original image
@@ -24,4 +52,18 @@ export type AutoImage = {
      */
     color?: ThemedColor | string;
     type: 'asset';
+} | {
+    /** HTTPS URL to a remote image. HTTP is not supported (blocked by App Transport Security). */
+    uri: string;
+    /**
+     * if specified the image gets tinted, if not it will just use the original image
+     */
+    color?: ThemedColor | string;
+    /**
+     * Network timeout in milliseconds before the remote fetch is abandoned and `null` is returned.
+     * Defaults to 500ms when not specified.
+     */
+    timeoutMs?: number;
+    type: 'remote';
 };
+export {};

package/lib/types/Maneuver.d.ts

@@ -1,6 +1,6 @@
 import type { ImageSourcePropType } from 'react-native';
 import type { ThemedColor } from '../utils/NitroColor';
-import type { GlyphName } from './Glyphmap';
+import type { AutoGlyphByCodepoint, AutoGlyphByName } from './Image';
 import type { TravelEstimates } from './Trip';
 export declare enum ManeuverType {
     Depart = 0,
@@ -148,15 +148,7 @@ export interface PreferredLane extends Lane {
     highlightedAngle: number;
     isPreferred: boolean;
 }
-export type ManeuverImage = {
-    name: GlyphName;
-    /**
-     * make sure to specify a color with a proper contrast ratio to cardBackgroundColor otherwise it might not get applied
-     * defaults to white/black for dark/light mode
-     */
-    color?: ThemedColor | string;
-    type: 'glyph';
-} | {
+export type ManeuverImage = Pick<AutoGlyphByName, 'type' | 'name' | 'codepoint' | 'color'> | Pick<AutoGlyphByCodepoint, 'type' | 'codepoint' | 'color'> | {
     image: ImageSourcePropType;
     /**
      * if specified the image gets tinted, if not it will just use the original image

package/lib/utils/NitroImage.d.ts

@@ -1,21 +1,47 @@
 import { type ImageResolvedAssetSource } from 'react-native';
 import type { AutoImage } from '../types/Image';
 import { type NitroColor } from './NitroColor';
+/**
+ * Register the icon font and (optionally) a glyph map for name-based lookups.
+ * Must be called **once** before creating any templates. Subsequent calls are ignored.
+ *
+ * The font name maps directly to a native font asset:
+ * - **Android** — `res/font/<name>.ttf` (must be lowercase)
+ * - **iOS** — `<name>.ttf` in the app bundle (registered via CoreText automatically)
+ *
+ * For cross-platform compatibility use lowercase with underscores only.
+ *
+ * @param name  Native font asset name (without extension).
+ * @param glyphMap  Optional map of glyph names to Unicode code points.
+ *                  When provided, glyphs can use `{ type: 'glyph', name: 'icon_name' }`.
+ *
+ * @example
+ * ```ts
+ * import { glyphMap } from './assets/Glyphmap';
+ * setIconFont('material_symbols', glyphMap);
+ * ```
+ */
+export declare function setIconFont(name: string, glyphMap?: Record<string, number>): void;
 interface AssetImage extends ImageResolvedAssetSource {
     color?: NitroColor;
     packager_asset: boolean;
 }
 interface GlyphImage {
     glyph: number;
+    fontName: string;
     color: NitroColor;
     backgroundColor: NitroColor;
     fontScale?: number;
 }
+interface RemoteImage {
+    uri: string;
+    color?: NitroColor;
+    timeoutMs?: number;
+}
 /**
- * we need to map the ButtonImage.name from GlyphName to
- * the actual numeric value so we need a nitro specific type
+ * NitroModules-compatible image types passed to native.
  */
-export type NitroImage = GlyphImage | AssetImage;
+export type NitroImage = GlyphImage | AssetImage | RemoteImage;
 declare function convert(image: AutoImage): NitroImage;
 declare function convert(image?: AutoImage): NitroImage | undefined;
 export declare const NitroImageUtil: {