@iternio/react-native-auto-play 0.6.1 → 0.7.0

package/README.md

@@ -25,6 +25,7 @@
 ## Requirements
 
 -   **iOS builds require Xcode 27+** (the iOS 27 SDK), even for apps that don't use any `mapConfig`/panel features — the library references `CPMapPanel`/`CPPanel` types internally behind `@available(iOS 27.0, *)` checks, but `@available` only defers *runtime* execution, not compile-time symbol resolution, so the SDK must be present to build at all.
+-   **`react-native-nitro-modules` 0.37.1 or newer** — the generated native bindings target that runtime shape; an older nitro-modules install fails at native build time.
 
 ## Installation
 
@@ -474,10 +475,11 @@ Use the color `'default'` for every monochrome icon that has to stay readable in
 
 ### 1. Register the AutoPlay Components
 
-You need to register your AutoPlay components in your app's entry file (e.g., `index.js`). This includes setting up the headless task that runs when CarPlay or Android Auto is connected.
+You need to register your AutoPlay components in your app's entry file (e.g., `index.js`). Import `@iternio/react-native-auto-play/installTimers` — a side-effect-only module that replaces the global `setTimeout`/`setInterval`/`requestAnimationFrame` (and their `clear*`/`cancel*` counterparts) with versions that keep running while CarPlay/Android Auto is actively driving the car screen, even if the phone itself is backgrounded or its screen is locked. React Native's own timers throttle or pause in that state regardless of whether the app process is actually still alive, which would otherwise stall ETA updates and telemetry polling. It must run before any other module has a chance to capture a reference to the original globals, which means it must be your entry file's **first import** — ES import declarations are hoisted and evaluated in source order, so it needs to come before everything else, including `react-native` itself:
 
 ```javascript
 // index.js
+import '@iternio/react-native-auto-play/installTimers';
 import { AppRegistry } from 'react-native';
 import { name as appName } from './app.json';
 import App from './src/App';
@@ -1314,8 +1316,6 @@ The same no-op surface is what `react-native-web` builds get automatically via `
 
 -   **Broken exceptions with `react-native-skia`**: When using `react-native-skia` exceptions on iOS are not reported correctly. This is fixed since version `2.4.19` of `react-native-skia`. For more details, see this [pull request](https://github.com/Shopify/react-native-skia/pull/3595) and [issue](https://github.com/Shopify/react-native-skia/issues/3635).
 -   **AppState on iOS**: The `AppState` module from React Native does not work correctly on iOS because this library uses scenes, which are not supported by the stock `AppState` module. This library provides a custom state listener that works for both Android and iOS. Use `HybridAutoPlay.addListenerRenderState` instead of `AppState`.
--   **Timers stop on screen lock**: iOS stops all timers when the device main screen is turned off. To ensure timers continue to run (which is often necessary for background tasks related to autoplay), a patch for `react-native` is required. A patch is included in the root `patches/` directory and can be applied using `patch-package`.
-In case you are using Expo SDK >= 56 make sure to set `buildReactNativeFromSource` to `true` in your app config for [expo-build-properties](https://docs.expo.dev/versions/latest/sdk/build-properties/#sharedbuildconfigfields), otherwise the patch can't be applied.
 -   **expo-splash-screen stuck on iOS**: The `expo-splash-screen` module is broken on iOS because it does not support scenes, which are used by this library. This can cause the splash screen to be stuck on either the mobile device or on CarPlay. To fix this, a patch for `expo-splash-screen` is included in the root `patches/` directory and can be applied using `patch-package`. After applying the patch, you can hide the splash screen for a specific scene by passing the module name to the `hide` or `hideAsync` function. The module name can be one of the values from the `AutoPlayModules` enum or the UUID of a cluster screen.
     ```tsx
     import { hideAsync } from 'expo-splash-screen';

package/android/src/automotive/AndroidManifest-nonnav.xml

@@ -58,8 +58,6 @@
             </intent-filter>
         </service>
 
-        <service android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.HeadlessTaskService" />
-
         <activity android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.SignInWithGoogleActivity" />
 
         <provider

package/android/src/automotive/AndroidManifest.xml

@@ -74,8 +74,6 @@
             </intent-filter>
         </service>
 
-        <service android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.HeadlessTaskService" />
-
         <activity android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.SignInWithGoogleActivity" />
 
         <provider

package/android/src/main/AndroidManifest-nonnav.xml

@@ -28,8 +28,6 @@
         <meta-data android:name="com.google.android.gms.car.application" android:resource="@xml/automotive_app_desc" tools:ignore="MetadataTagInsideApplicationTag" />
         <meta-data android:name="androidx.car.app.minCarApiLevel" android:value="1" />
 
-        <service android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.HeadlessTaskService" />
-
         <provider android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.ActivityRenderStateProvider" android:authorities="${applicationId}.ActivityRenderStateProvider" android:exported="false" />
     </application>
 </manifest>

package/android/src/main/AndroidManifest.xml

@@ -37,8 +37,6 @@
         <meta-data android:name="com.google.android.gms.car.application" android:resource="@xml/automotive_app_desc" tools:ignore="MetadataTagInsideApplicationTag" />
         <meta-data android:name="androidx.car.app.minCarApiLevel" android:value="1" />
 
-        <service android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.HeadlessTaskService" />
-
         <provider android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.ActivityRenderStateProvider" android:authorities="${applicationId}.ActivityRenderStateProvider" android:exported="false" />
     </application>
 </manifest>

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

@@ -5,14 +5,10 @@ import android.annotation.SuppressLint
 import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
-import android.content.ComponentName
-import android.content.Intent
-import android.content.ServiceConnection
 import android.content.pm.ApplicationInfo
 import android.content.pm.PackageManager
 import android.graphics.Bitmap
 import android.os.Build
-import android.os.IBinder
 import android.util.Log
 import androidx.car.app.CarAppService
 import androidx.car.app.Session
@@ -23,6 +19,7 @@ import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.LifecycleOwner
+import com.facebook.react.ReactApplication
 import com.facebook.react.bridge.LifecycleEventListener
 import com.margelo.nitro.NitroModules
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.utils.AppInfo
@@ -30,7 +27,6 @@ import com.margelo.nitro.swe.iternio.reactnativeautoplay.utils.AppInfo
 class AndroidAutoService : CarAppService() {
     private lateinit var notificationManager: NotificationManager
 
-    private var isServiceBound = false
     private var isSessionStarted = false
     private var isReactAppStarted = false
 
@@ -48,6 +44,8 @@ class AndroidAutoService : CarAppService() {
         super.onCreate()
         instance = this
 
+        (application as? ReactApplication)?.reactHost?.start()
+
         NitroModules.applicationContext?.addLifecycleEventListener(reactLifecycleObserver)
 
         notificationManager = getSystemService(NotificationManager::class.java)
@@ -98,11 +96,6 @@ class AndroidAutoService : CarAppService() {
     }
 
     private val sessionLifecycleObserver = object : DefaultLifecycleObserver {
-        override fun onCreate(owner: LifecycleOwner) {
-            val serviceIntent = Intent(applicationContext, HeadlessTaskService::class.java)
-            bindService(serviceIntent, connection, BIND_AUTO_CREATE)
-        }
-
         override fun onResume(owner: LifecycleOwner) {
             isSessionStarted = true
         }
@@ -112,27 +105,10 @@ class AndroidAutoService : CarAppService() {
         }
 
         override fun onDestroy(owner: LifecycleOwner) {
-            if (isServiceBound) {
-                unbindService(connection)
-                isServiceBound = false
-            }
-
             this@AndroidAutoService.stopForeground(STOP_FOREGROUND_REMOVE)
         }
     }
 
-    private val connection: ServiceConnection = object : ServiceConnection {
-        override fun onServiceConnected(
-            className: ComponentName, service: IBinder
-        ) {
-            isServiceBound = true
-        }
-
-        override fun onServiceDisconnected(arg0: ComponentName) {
-            isServiceBound = false
-        }
-    }
-
     private fun createNotification(
         title: String?, text: String?, largeIcon: Bitmap?
     ): Notification {

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

@@ -0,0 +1,122 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+import java.lang.ref.WeakReference
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicLong
+
+private class ScheduledTimer(
+    val callback: () -> Unit,
+    val interval: Long,
+    val repeats: Boolean,
+    var target: Long,
+)
+
+// Weak ref, so a stale instance (dev reload / host restart) can't tick forever in the queue.
+private class TickRunnable(target: HybridAutoPlayTiming) : Runnable {
+    private val ref = WeakReference(target)
+
+    override fun run() {
+        ref.get()?.tick()
+    }
+}
+
+/**
+ * Backs setTimeout/setInterval (see AutoPlayTimers.ts) with a plain Handler loop on the main
+ * Looper -- not Choreographer, which JavaTimerManager itself uses and only keeps ticking while
+ * the host is resumed or a headless JS task is running. See AutoPlayTiming.nitro.ts.
+ *
+ * Ticks at a fixed ~60Hz while any timer is pending and stops entirely once idle, rather than
+ * scheduling a delay to the next due target: postDelayed's dispatch is gated on uptimeMillis(),
+ * which pauses during deep sleep, so a long pre-sleep delay would need that much *awake* time
+ * after waking. A short, repeated delay only needs ~16ms of awake time, so it fires within
+ * about one frame of the device waking regardless of sleep length -- due timers are then found
+ * correctly because target/now use elapsedRealtime(), which counts straight through sleep.
+ */
+class HybridAutoPlayTiming : HybridAutoPlayTimingSpec() {
+    companion object {
+        private const val FRAME_DURATION_MS = 1000L / 60L
+
+        // RN's TimerManager also numbers ids from 1; offsetting avoids collisions with ids a
+        // pre-install caller (e.g. React's own scheduler) still holds against the original
+        // clearTimeout, now replaced.
+        private const val ID_OFFSET = 1_000_000_000L
+    }
+
+    private val handler = Handler(Looper.getMainLooper())
+    private val timers = ConcurrentHashMap<Double, ScheduledTimer>()
+    private val nextId = AtomicLong(ID_OFFSET)
+    private val isTicking = AtomicBoolean(false)
+    private val tickRunnable = TickRunnable(this)
+
+    private fun ensureTicking() {
+        if (isTicking.compareAndSet(false, true)) {
+            handler.postDelayed(tickRunnable, FRAME_DURATION_MS)
+        }
+    }
+
+    internal fun tick() {
+        // elapsedRealtime(), not uptimeMillis(): both are immune to NTP/manual clock changes,
+        // but unlike uptimeMillis() this one keeps counting through deep sleep.
+        val now = SystemClock.elapsedRealtime()
+
+        // Sort by (target, id): ConcurrentHashMap iteration order is unspecified, so
+        // setTimeout(a, 0); setTimeout(b, 0) could otherwise fire b before a.
+        val dueIds = timers.entries.filter { it.value.target <= now }
+            .sortedWith(compareBy({ it.value.target }, { it.key }))
+            .map { it.key }
+
+        for (id in dueIds) {
+            // Re-check membership: a same-tick callback may have cleared a later timer in
+            // this snapshotted list (e.g. `clearTimeout(t); t = setTimeout(...)`).
+            val timer = timers[id] ?: continue
+
+            if (timer.repeats) {
+                timer.target = now + timer.interval
+            } else {
+                timers.remove(id)
+            }
+
+            timer.callback()
+        }
+
+        if (timers.isNotEmpty()) {
+            handler.postDelayed(tickRunnable, FRAME_DURATION_MS)
+            return
+        }
+
+        isTicking.set(false)
+        // Reclaim: a concurrent createTimer() may have inserted an entry and found `isTicking`
+        // still true (skipping its own post) in the gap before the flag was cleared above.
+        if (timers.isNotEmpty()) {
+            ensureTicking()
+        }
+    }
+
+    override fun createTimer(callback: () -> Unit, durationMs: Double, repeats: Boolean): Double {
+        val interval = durationMs.toLong().coerceAtLeast(0)
+        val id = nextId.getAndIncrement().toDouble()
+        timers[id] = ScheduledTimer(
+            callback = callback,
+            interval = interval,
+            repeats = repeats,
+            target = SystemClock.elapsedRealtime() + interval,
+        )
+        ensureTicking()
+        return id
+    }
+
+    override fun deleteTimer(id: Double) {
+        timers.remove(id)
+    }
+
+    override fun dispose() {
+        handler.removeCallbacks(tickRunnable)
+        isTicking.set(false)
+        timers.clear()
+        super.dispose()
+    }
+}

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

@@ -378,7 +378,7 @@ object Parser {
                     }
                     row.onPress?.let {
                         setOnClickListener {
-                            row.onPress(null)
+                            it(null)
                         }
                     }
                     row.browsable?.let {
@@ -650,7 +650,7 @@ object Parser {
                 // 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)
+                return image.underlyingBitmap?.copy(Bitmap.Config.ARGB_8888, false)
             } else if (image is CloseableXml) {
                 val drawable = image.buildDrawable()
                 return drawable?.toBitmap(

package/installTimers.ts

@@ -0,0 +1,3 @@
+// Root re-export so `@iternio/react-native-auto-play/installTimers` is a deliberate, explicitly
+// published public entry point rather than a reach into src/ internals -- see src/installTimers.ts.
+import './src/installTimers';

package/installTimers.web.ts

@@ -0,0 +1,2 @@
+// Web/Jest counterpart to installTimers.ts, picked by Metro's platform resolution.
+import './src/installTimers.web';

package/ios/hybrid/HybridAutoPlayTiming.swift

@@ -0,0 +1,123 @@
+import Foundation
+import NitroModules
+
+private struct ScheduledTimer {
+    let callback: () -> Void
+    let interval: TimeInterval
+    let repeats: Bool
+    var target: TimeInterval
+}
+
+// Unlike ProcessInfo.systemUptime/mach_absolute_time(), keeps counting through sleep. RAW over
+// plain CLOCK_MONOTONIC: also immune to NTP frequency-discipline adjustments.
+private func now() -> TimeInterval {
+    TimeInterval(clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW)) / 1_000_000_000
+}
+
+/// Backs setTimeout/setInterval (see AutoPlayTimers.ts) with a plain `Timer` -- not tied to
+/// `CADisplayLink`/screen refresh, so it keeps firing while the phone screen is locked and
+/// CarPlay is actively driving the external screen. See AutoPlayTiming.nitro.ts.
+///
+/// Ticks at a fixed ~60Hz while any timer is pending and stops entirely once idle, rather than
+/// scheduling a delay to the next due target: a `Timer`'s dispatch is gated on the run loop's
+/// own monotonic clock, which (like `mach_absolute_time()`) pauses during sleep, so a long
+/// pre-sleep delay would need that much *awake* time after waking. A short, repeated delay only
+/// needs ~16ms of awake time, so it fires within about one frame of the device waking
+/// regardless of sleep length.
+class HybridAutoPlayTiming: HybridAutoPlayTimingSpec {
+    private static let frameDuration: TimeInterval = 1.0 / 60.0
+
+    // RN's TimerManager also numbers ids from 1; offsetting avoids collisions with ids a
+    // pre-install caller (e.g. React's own scheduler) still holds against the original
+    // clearTimeout, now replaced.
+    private static let idOffset: Double = 1_000_000_000
+
+    private let lock = NSLock()
+    private var timers = [Double: ScheduledTimer]()
+    private var nextId: Double = HybridAutoPlayTiming.idOffset
+    private var timer: Timer?
+
+    deinit {
+        timer?.invalidate()
+    }
+
+    private func withLock<T>(_ body: () -> T) -> T {
+        lock.lock()
+        defer { lock.unlock() }
+        return body()
+    }
+
+    // Must be called while already holding `lock`.
+    private func scheduleTick() {
+        let next = Timer(timeInterval: HybridAutoPlayTiming.frameDuration, repeats: false) { [weak self] _ in
+            self?.tick()
+        }
+        RunLoop.main.add(next, forMode: .common)
+        timer = next
+    }
+
+    private func tick() {
+        let currentTime = now()
+
+        // Sort by (target, id): Dictionary iteration order is unspecified, so
+        // setTimeout(a, 0); setTimeout(b, 0) could otherwise fire b before a.
+        let dueIds = withLock {
+            timers.filter { $0.value.target <= currentTime }
+                .sorted { lhs, rhs in
+                    lhs.value.target != rhs.value.target
+                        ? lhs.value.target < rhs.value.target
+                        : lhs.key < rhs.key
+                }
+                .map(\.key)
+        }
+
+        for id in dueIds {
+            // Re-check membership: a same-tick callback may have cleared a later timer in
+            // this snapshotted list (e.g. `clearTimeout(t); t = setTimeout(...)`).
+            let callback: (() -> Void)? = withLock {
+                guard var entry = timers[id] else { return nil }
+                if entry.repeats {
+                    entry.target = now() + entry.interval
+                    timers[id] = entry
+                } else {
+                    timers.removeValue(forKey: id)
+                }
+                return entry.callback
+            }
+
+            callback?()
+        }
+
+        withLock {
+            timer = nil
+            if !timers.isEmpty {
+                scheduleTick()
+            }
+        }
+    }
+
+    func createTimer(callback: @escaping () -> Void, durationMs: Double, repeats: Bool) throws -> Double {
+        let interval = max(durationMs, 0) / 1000.0
+
+        return withLock {
+            let id = nextId
+            nextId += 1
+            timers[id] = ScheduledTimer(
+                callback: callback,
+                interval: interval,
+                repeats: repeats,
+                target: now() + interval
+            )
+            if timer == nil {
+                scheduleTick()
+            }
+            return id
+        }
+    }
+
+    func deleteTimer(id: Double) throws {
+        withLock {
+            _ = timers.removeValue(forKey: id)
+        }
+    }
+}

package/lib/components/SafeAreaView.js

@@ -7,7 +7,7 @@ export const SafeAreaView = (props) => {
     return (_jsx(View, { style: [
             style,
             {
-                ...StyleSheet.absoluteFillObject,
+                ...StyleSheet.absoluteFill,
                 paddingTop: safeAreaInsets.top,
                 paddingBottom: safeAreaInsets.bottom,
                 paddingRight: safeAreaInsets.right,

package/lib/hybrid/HybridAutoPlayTiming.d.ts

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

package/lib/hybrid/HybridAutoPlayTiming.js

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

package/lib/hybrid/HybridVoice.js

@@ -5,8 +5,8 @@ const _native = NitroModules.createHybridObject('Voice');
 const startVoiceInput = async (options) => {
     const { onChunk, silenceThresholdMs, maxDurationMs, listeningText, listeningImage, preferSpeechToText, language, startSound, endSound, encoding, } = options ?? {};
     const listeningImageRepeats = listeningImage?.type === 'asset' ? listeningImage.repeats : undefined;
-    const startSoundUri = startSound != null ? Image.resolveAssetSource(startSound).uri : undefined;
-    const endSoundUri = endSound != null ? Image.resolveAssetSource(endSound).uri : undefined;
+    const startSoundUri = startSound != null ? Image.resolveAssetSource(startSound)?.uri : undefined;
+    const endSoundUri = endSound != null ? Image.resolveAssetSource(endSound)?.uri : undefined;
     return await _native.startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, NitroImageUtil.convert(listeningImage), listeningImageRepeats, preferSpeechToText, onChunk, language, startSoundUri, endSoundUri, encoding);
 };
 export const HybridVoice = {

package/lib/index.js

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

package/lib/index.web.d.ts

@@ -1,4 +1,4 @@
-import { View, type ViewProps } from 'react-native';
+import { type ViewProps } from 'react-native';
 import type { AndroidAutomotive } from './specs/AndroidAutomotive.nitro';
 import type { AutoPlay } from './specs/AutoPlay.nitro';
 import type { Voice } from './specs/Voice.nitro';
@@ -44,7 +44,9 @@ export declare enum AutoPlayModules {
     CarPlayDashboard = "CarPlayDashboard"
 }
 export declare const useSafeAreaInsets: () => SafeAreaInsets;
-export declare const SafeAreaView: (props: ViewProps) => import("react").CElement<ViewProps, View>;
+export declare const SafeAreaView: (props: ViewProps) => import("react").FunctionComponentElement<Omit<ViewProps, "ref"> & {
+    ref?: import("react").Ref<import("react-native").ViewInstance> | undefined;
+}>;
 export declare function setIconFont(_name: string, _glyphMap?: Record<string, number>): void;
 export declare const useFocusedEffect: () => void;
 export declare const useVoiceInput: () => {

package/lib/installTimers.d.ts

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

package/lib/installTimers.js

@@ -0,0 +1,8 @@
+// Side-effect-only entry point, re-exported at the package root as `installTimers` (see
+// ../installTimers.ts) for `import '@iternio/react-native-auto-play/installTimers';` as the
+// app's first import. installAutoPlayTimers() itself isn't part of the public API -- funneling
+// installation through this one module is what actually guarantees "runs before anything else
+// captures the original globals" (see the README) instead of just documenting it as a rule
+// callers have to get right.
+import { installAutoPlayTimers } from './utils/AutoPlayTimers';
+installAutoPlayTimers();

package/lib/installTimers.web.d.ts

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

package/lib/installTimers.web.js

@@ -0,0 +1,2 @@
+// Web/Jest stub -- nothing to install there. See installTimers.ts.
+export {};

package/lib/scenes/CarPlayDashboardScene.d.ts

@@ -28,9 +28,9 @@ declare class Dashboard {
      * @param eventType generic events
      * @returns callback to remove the listener
      */
-    addListener(event: EventName, callback: () => void): import("../types/Event").CleanupCallback;
-    addListenerRenderState(callback: (payload: VisibilityState) => void): import("../types/Event").CleanupCallback;
-    addListenerColorScheme(callback: (payload: ColorScheme) => void): import("../types/Event").CleanupCallback;
+    addListener(event: EventName, callback: () => void): import("..").CleanupCallback;
+    addListenerRenderState(callback: (payload: VisibilityState) => void): import("..").CleanupCallback;
+    addListenerColorScheme(callback: (payload: ColorScheme) => void): import("..").CleanupCallback;
 }
 export declare const CarPlayDashboard: Dashboard;
 export {};

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

@@ -0,0 +1,27 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+/**
+ * Backs setTimeout/setInterval with a scheduler that never pauses -- unlike RN's own JS
+ * timers, which RN throttles or pauses whenever the app backgrounds, regardless of whether
+ * the process is actually still running.
+ *
+ * iOS: CarPlay keeps this app's process alive and driving the external screen even when the
+ * phone's own screen is off, but RN's own RCTTiming still pauses in that state regardless.
+ *
+ * Android: JavaTimerManager only keeps ticking while the host is resumed *or* a headless JS
+ * task is running -- previously satisfied by registering a permanent no-op headless task
+ * (see AutoPlayHeadlessJsTask), which this replaces.
+ *
+ * All due-time bookkeeping lives here natively (mirroring RCTTiming's/JavaTimerManager's own
+ * architecture) so JS only crosses the bridge when a timer actually fires, not on every tick.
+ */
+export interface AutoPlayTiming extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    /**
+     * Schedules `callback` to run after `durationMs`, repeating every `durationMs` if `repeats`
+     * is true. Returns an id to pass to `deleteTimer`.
+     */
+    createTimer(callback: () => void, durationMs: number, repeats: boolean): number;
+    deleteTimer(id: number): void;
+}

package/lib/specs/AutoPlayTiming.nitro.js

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

package/lib/types/Telemetry.d.ts

@@ -1,4 +1,4 @@
-import type { Permission } from 'react-native/types';
+import type { Permission } from 'react-native';
 export type AndroidAutoPermissions = Permission | AndroidAutoTelemetryPermissions | AndroidAutomotiveTelemetryPermissions;
 export declare enum AndroidAutoTelemetryPermissions {
     Speed = "com.google.android.gms.permission.CAR_SPEED",

package/lib/utils/AutoPlayTimers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Replaces the global `setTimeout`/`setInterval`/`clearTimeout`/`clearInterval` and
+ * `requestAnimationFrame`/`cancelAnimationFrame` with implementations backed by the native
+ * `AutoPlayTiming` module, so they keep running while the app is actively driving a car
+ * surface even though the phone itself is backgrounded or its screen is locked. React
+ * Native's own timers throttle or pause in that state regardless of whether the process is
+ * actually still alive, which would otherwise stall ETA updates and telemetry polling.
+ *
+ * `requestIdleCallback`/`cancelIdleCallback` are deliberately not covered: bridgeless RN
+ * backs those with a separate native module unrelated to `setTimeout`/`requestAnimationFrame`
+ * (and its own callback delivery path is an unimplemented stub on iOS), so there is nothing
+ * for this library to intercept there.
+ *
+ * All due-time bookkeeping happens natively -- this is a thin pass-through, so JS only
+ * crosses the bridge when a timer actually fires, not on some fixed interval.
+ *
+ * Call this **once**, as early as possible in your app -- ideally the first line of your
+ * entry file, before any other import -- so nothing else has already captured a reference to
+ * the original globals. Safe to call more than once; only the first call has any effect.
+ */
+export declare function installAutoPlayTimers(): void;

package/lib/utils/AutoPlayTimers.js

@@ -0,0 +1,45 @@
+import { HybridAutoPlayTiming } from '../hybrid/HybridAutoPlayTiming';
+let installed = false;
+/**
+ * Replaces the global `setTimeout`/`setInterval`/`clearTimeout`/`clearInterval` and
+ * `requestAnimationFrame`/`cancelAnimationFrame` with implementations backed by the native
+ * `AutoPlayTiming` module, so they keep running while the app is actively driving a car
+ * surface even though the phone itself is backgrounded or its screen is locked. React
+ * Native's own timers throttle or pause in that state regardless of whether the process is
+ * actually still alive, which would otherwise stall ETA updates and telemetry polling.
+ *
+ * `requestIdleCallback`/`cancelIdleCallback` are deliberately not covered: bridgeless RN
+ * backs those with a separate native module unrelated to `setTimeout`/`requestAnimationFrame`
+ * (and its own callback delivery path is an unimplemented stub on iOS), so there is nothing
+ * for this library to intercept there.
+ *
+ * All due-time bookkeeping happens natively -- this is a thin pass-through, so JS only
+ * crosses the bridge when a timer actually fires, not on some fixed interval.
+ *
+ * Call this **once**, as early as possible in your app -- ideally the first line of your
+ * entry file, before any other import -- so nothing else has already captured a reference to
+ * the original globals. Safe to call more than once; only the first call has any effect.
+ */
+export function installAutoPlayTimers() {
+    if (installed || HybridAutoPlayTiming == null) {
+        return;
+    }
+    installed = true;
+    const timing = HybridAutoPlayTiming;
+    const schedule = (repeats) => (callback, delay, ...args) => timing.createTimer(() => callback(...args), delay ?? 0, repeats);
+    const clear = (id) => {
+        if (typeof id === 'number') {
+            timing.deleteTimer(id);
+        }
+    };
+    globalThis.setTimeout = schedule(false);
+    globalThis.setInterval = schedule(true);
+    globalThis.clearTimeout = clear;
+    globalThis.clearInterval = clear;
+    // Mirrors bridgeless RN's own implementation: requestAnimationFrame is setTimeout(0) with
+    // a performance.now() timestamp handed to the callback, and cancelAnimationFrame deletes
+    // the same underlying timer clearTimeout would.
+    const now = () => globalThis.performance?.now() ?? Date.now();
+    globalThis.requestAnimationFrame = ((callback) => timing.createTimer(() => callback(now()), 0, false));
+    globalThis.cancelAnimationFrame = clear;
+}

package/lib/utils/NitroImage.d.ts

@@ -1,4 +1,3 @@
-import { type ImageResolvedAssetSource } from 'react-native';
 import type { AutoImage } from '../types/Image';
 import { type NitroColor } from './NitroColor';
 /**
@@ -22,7 +21,11 @@ import { type NitroColor } from './NitroColor';
  * ```
  */
 export declare function setIconFont(name: string, glyphMap?: Record<string, number>): void;
-interface AssetImage extends ImageResolvedAssetSource {
+interface AssetImage {
+    uri: string;
+    width: number;
+    height: number;
+    scale: number;
     color?: NitroColor;
     packager_asset: boolean;
 }