@iternio/react-native-auto-play 0.5.5 → 0.5.7

package/README.md

@@ -1074,7 +1074,8 @@ CarPlayDashboard.setButtons([
 
 -   **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's 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`.
+-   **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/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAndroidWindowInformation.kt

@@ -0,0 +1,49 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.CopyOnWriteArrayList
+
+class HybridAndroidWindowInformation : HybridAndroidWindowInformationSpec() {
+    init {
+        windowInformationListeners.clear()
+    }
+
+    override fun addWindowInformationListener(
+        moduleName: String, callback: (WindowInformation) -> Unit
+    ): () -> Unit {
+        val callbacks = windowInformationListeners.getOrPut(moduleName) {
+            CopyOnWriteArrayList()
+        }
+        callbacks.add(callback)
+
+        VirtualRenderer.getWindowInformation(moduleName)?.let {
+            callback(it)
+        }
+
+        return {
+            windowInformationListeners[moduleName]?.let {
+                it.remove(callback)
+                if (it.isEmpty()) {
+                    windowInformationListeners.remove(moduleName)
+                }
+            }
+        }
+    }
+
+    companion object {
+        const val TAG = "HybridAndroidWindowInformation"
+
+        private val windowInformationListeners =
+            ConcurrentHashMap<String, CopyOnWriteArrayList<(WindowInformation) -> Unit>>()
+
+        fun removeListeners(templateId: String) {
+            windowInformationListeners.remove(templateId)
+        }
+
+        fun emitWindowInformation(moduleName: String, window: WindowInformation) {
+            windowInformationListeners[moduleName]?.forEach {
+                it(window)
+            }
+        }
+    }
+}

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

@@ -264,6 +264,7 @@ class HybridAutoPlay : HybridAutoPlaySpec() {
         fun removeListeners(templateId: String) {
             renderStateListeners.remove(templateId)
             safeAreaInsetsListeners.remove(templateId)
+            HybridAndroidWindowInformation.removeListeners(templateId)
         }
 
         fun emit(event: EventName) {

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

@@ -42,20 +42,24 @@ class VirtualRenderer(
 ) {
     private var virtualDisplay: VirtualDisplay? = null
 
-    private lateinit var reactSurfaceImpl: ReactSurfaceImpl
+    private var reactSurfaceImpl: ReactSurfaceImpl? = null
     private var reactSurfaceView: ReactSurfaceView? = null
     private var reactSurfaceId: Int? = null
 
     private var height: Int = 0
     private var width: Int = 0
+    private var dpi: Int = 0
 
     private var splashWillDisappear = false
 
     /**
-     * scale is the actual scale factor required to calculate proper insets and is passed in initialProperties to js side
+     * scale is the actual scale factor required to calculate proper insets and is passed in initialProperties to js side.
+     * The density is derived from the surface container's dpi so it always matches the VirtualDisplay,
+     * and is recomputed on every onSurfaceAvailable since the host may recreate the surface with new metrics.
      */
-    private val virtualScreenDensity = context.resources.displayMetrics.density
-    val scale = BuildConfig.SCALE_FACTOR * virtualScreenDensity
+    private var virtualScreenDensity = context.resources.displayMetrics.density
+    var scale = BuildConfig.SCALE_FACTOR * virtualScreenDensity
+        private set
 
     private fun isSurfaceReady(surfaceContainer: SurfaceContainer): Boolean {
         return surfaceContainer.surface != null && surfaceContainer.dpi != 0 && surfaceContainer.height != 0 && surfaceContainer.width != 0
@@ -68,7 +72,7 @@ class VirtualRenderer(
             val areaDebouncer = Debouncer(200)
 
             // 12dp seems to be the default margin on AA for the ETA widget and the maneuver so use it as fallback
-            val defaultMargin = (12.0 * context.resources.displayMetrics.density).toInt()
+            val defaultMargin get() = (12.0 * virtualScreenDensity).toInt()
             var minMargin = Int.MAX_VALUE
             var stableArea = Rect(0, 0, 0, 0)
             var visibleArea = Rect(0, 0, 0, 0)
@@ -78,25 +82,16 @@ class VirtualRenderer(
                     return
                 }
 
-                val manager = context.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
-                virtualDisplay?.release()
-                virtualDisplay = manager.createVirtualDisplay(
-                    moduleName,
-                    surfaceContainer.width,
-                    surfaceContainer.height,
-                    surfaceContainer.dpi,
-                    surfaceContainer.surface,
-                    DisplayManager.VIRTUAL_DISPLAY_FLAG_PRESENTATION,
-                )
-
-                val display = virtualDisplay?.display ?: return
-                height = surfaceContainer.height
-                width = surfaceContainer.width
-
-                initRenderer(display)
+                applySurface(surfaceContainer)
             }
 
             override fun onSurfaceDestroyed(surfaceContainer: SurfaceContainer) {
+                // the host re-emits visible/stable areas for the next surface, so drop state derived
+                // from the old surface instead of combining it with the new dimensions
+                minMargin = Int.MAX_VALUE
+                stableArea = Rect(0, 0, 0, 0)
+                visibleArea = Rect(0, 0, 0, 0)
+
                 virtualDisplay?.release()
                 virtualDisplay = null
             }
@@ -230,6 +225,46 @@ class VirtualRenderer(
         })
     }
 
+    @MainThread
+    private fun applySurface(surfaceContainer: SurfaceContainer) {
+        val surfaceWidth = surfaceContainer.width
+        val surfaceHeight = surfaceContainer.height
+
+        // The host signals surface size changes only via onSurfaceDestroyed -> onSurfaceAvailable
+        // with new dimensions, so all size-derived state (layout params, scale, Fabric measure
+        // specs) must be recomputed when the metrics differ from the current ones. The react
+        // surface itself is kept alive so JS state survives the resize; the JS side is informed
+        // via the windowInformation listener since the window initial prop stays stale.
+        val isResize = reactSurfaceView != null && (width != surfaceWidth
+            || height != surfaceHeight || dpi != surfaceContainer.dpi)
+
+        val manager = context.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
+        virtualDisplay?.release()
+        virtualDisplay = manager.createVirtualDisplay(
+            moduleName,
+            surfaceWidth,
+            surfaceHeight,
+            surfaceContainer.dpi,
+            surfaceContainer.surface,
+            DisplayManager.VIRTUAL_DISPLAY_FLAG_PRESENTATION,
+        )
+
+        val display = virtualDisplay?.display ?: return
+        height = surfaceHeight
+        width = surfaceWidth
+        dpi = surfaceContainer.dpi
+        virtualScreenDensity = surfaceContainer.dpi / 160f
+        scale = BuildConfig.SCALE_FACTOR * virtualScreenDensity
+
+        initRenderer(display)
+
+        if (isResize) {
+            getWindowInformation(moduleName)?.let {
+                HybridAndroidWindowInformation.emitWindowInformation(moduleName, it)
+            }
+        }
+    }
+
     private fun getMapTemplateConfig(): MapTemplateConfig? {
         val screenManager = AndroidAutoScreen.getScreen(moduleName)?.screenManager ?: return null
         val marker = screenManager.top.marker ?: return null
@@ -290,19 +325,48 @@ class VirtualRenderer(
             val appTheme = context.applicationContext.applicationInfo.theme
             val themedContext = ContextThemeWrapper(context.applicationContext, appTheme)
 
-            if (!this@VirtualRenderer::reactSurfaceImpl.isInitialized) {
-                reactSurfaceImpl = ReactSurfaceImpl(themedContext, moduleName, initialProperties)
+            val surfaceImpl = reactSurfaceImpl ?: ReactSurfaceImpl(
+                themedContext, moduleName, initialProperties
+            ).also {
+                reactSurfaceImpl = it
             }
 
             var splashScreenView: View? = null
 
             reactSurfaceView?.let {
                 (it.parent as ViewGroup).removeView(it)
+
+                // the surface may have been recreated with new dimensions, so reapply all
+                // size-derived values and push the new layout specs into the running Fabric surface
+                it.layoutParams = FrameLayout.LayoutParams(
+                    (width / reactNativeScale).toInt(), (height / reactNativeScale).toInt()
+                )
+                it.scaleX = reactNativeScale
+                it.scaleY = reactNativeScale
+
+                reactSurfaceId?.let { surfaceId ->
+                    fabricUiManager.updateRootLayoutSpecs(
+                        surfaceId,
+                        View.MeasureSpec.makeMeasureSpec(
+                            (width / reactNativeScale).toInt(), View.MeasureSpec.EXACTLY
+                        ),
+                        View.MeasureSpec.makeMeasureSpec(
+                            (height / reactNativeScale).toInt(), View.MeasureSpec.EXACTLY
+                        ),
+                        0,
+                        0
+                    )
+                }
             } ?: run {
+                // skip the splash when the surface is rebuilt after a resize, content is already loaded
                 splashScreenView =
-                    if (isCluster) getClusterSplashScreen(themedContext, height, width) else null
+                    if (isCluster && !splashWillDisappear) {
+                        getClusterSplashScreen(themedContext, height, width)
+                    } else {
+                        null
+                    }
 
-                val surfaceView = ReactSurfaceView(themedContext, reactSurfaceImpl).apply {
+                val surfaceView = ReactSurfaceView(themedContext, surfaceImpl).apply {
                     layoutParams = FrameLayout.LayoutParams(
                         (width / reactNativeScale).toInt(), (height / reactNativeScale).toInt()
                     )
@@ -402,10 +466,7 @@ class VirtualRenderer(
     }
 
     @MainThread
-    private fun stop() {
-        virtualDisplay?.release()
-        virtualDisplay = null
-
+    private fun stopReactSurface() {
         val uiManager = NitroModules.applicationContext?.let {
             UIManagerHelper.getUIManager(
                 it, UIManagerType.FABRIC
@@ -420,6 +481,19 @@ class VirtualRenderer(
             // Fabric already invalidated
         } finally {
             reactSurfaceId = null
+            reactSurfaceView = null
+            reactSurfaceImpl = null
+        }
+    }
+
+    @MainThread
+    private fun stop() {
+        virtualDisplay?.release()
+        virtualDisplay = null
+
+        try {
+            stopReactSurface()
+        } finally {
             virtualRenderer.remove(moduleName)
         }
     }
@@ -433,6 +507,19 @@ class VirtualRenderer(
             return virtualRenderer.contains(moduleId)
         }
 
+        fun getWindowInformation(moduleId: String): WindowInformation? {
+            val renderer = virtualRenderer[moduleId] ?: return null
+            if (renderer.width == 0 || renderer.height == 0) {
+                return null
+            }
+
+            return WindowInformation(
+                width = (renderer.width / renderer.scale).toInt().toDouble(),
+                height = (renderer.height / renderer.scale).toInt().toDouble(),
+                scale = renderer.scale.toDouble()
+            )
+        }
+
         fun removeRenderer(moduleId: String) {
             virtualRenderer[moduleId]?.stop()
             virtualRenderer.remove(moduleId)

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

@@ -86,7 +86,7 @@ class VoiceInputManager(
             throw IllegalStateException("Audio focus request denied")
         }
         try {
-            startSoundUri?.let { playSound(it) }
+            val startSoundJob = startSoundUri?.let { uri -> scope.launch { playSound(uri) } }
             val result = if (preferSpeechToText) {
                 val context = NitroModules.applicationContext ?: throw IllegalArgumentException()
                 if (SpeechRecognizer.isRecognitionAvailable(context)) {
@@ -106,6 +106,7 @@ class VoiceInputManager(
             } else {
                 startPCM(silenceThresholdMs, maxDurationMs, onChunk)
             }
+            startSoundJob?.join()
             if (cancelledByUser) throw VoiceInputCancelledException()
             endSoundUri?.let { playSound(it) }
             return result

package/ios/utils/VoiceInputManager.swift

@@ -3,9 +3,7 @@ import CarPlay
 import NitroModules
 import Speech
 
-/// Keeps itself and the player alive until playback finishes.
-/// Needed because AVAudioPlayer.delegate is weak, so without an external strong
-/// reference the delegate (and player) would be released immediately after play().
+/// Retains the player and itself until playback finishes — AVAudioPlayer.delegate is weak.
 private final class AudioPlayerDelegate: NSObject, AVAudioPlayerDelegate, @unchecked Sendable {
     private let onFinish: () -> Void
     private var keepAlive: AudioPlayerDelegate?
@@ -28,8 +26,7 @@ private final class AudioPlayerDelegate: NSObject, AVAudioPlayerDelegate, @unche
     func audioPlayerDecodeErrorDidOccur(_: AVAudioPlayer, error _: Error?) { finish() }
 }
 
-/// Wraps CheckedContinuation so it can only be resumed once even when
-/// shared between a stop() call and an async recognition task callback.
+/// CheckedContinuation wrapper that can only be resumed once, safe across concurrent stop() and recognition callbacks.
 private final class ResultBox: @unchecked Sendable {
     private var continuation: CheckedContinuation<VoiceInputResult, Error>?
     private let lock = NSLock()
@@ -53,8 +50,7 @@ private final class ResultBox: @unchecked Sendable {
     }
 }
 
-/// Captures audio from the car microphone and buffers raw 16 kHz / 16-bit / mono PCM,
-/// or transcribes it via SFSpeechRecognizer when preferSpeechToText is true.
+/// Records 16 kHz / 16-bit mono PCM from the car mic, or transcribes via SFSpeechRecognizer.
 class VoiceInputManager {
     private var audioEngine: AVAudioEngine?
     private var voiceControlTemplate: CPVoiceControlTemplate?
@@ -62,7 +58,6 @@ class VoiceInputManager {
     private var samples: [Int16] = []
     private var isStopping = false
     private var cancelledByUser = false
-    private var isIgnoringSamples = false
     private let stopLock = NSLock()
 
     // STT
@@ -72,6 +67,7 @@ class VoiceInputManager {
     // Timing
     private var recordingStart: Date?
     private var silenceStart: Date?
+    private var firstBufferContinuation: CheckedContinuation<Void, Never>?
 
     private static let sampleRate: Double = 16_000
     private static let tapBufferSize: AVAudioFrameCount = 4_096
@@ -103,6 +99,13 @@ class VoiceInputManager {
         stopLock.withLock {
             cancelledByUser = false
         }
+        // Single session for the full flow (start sound + recording + end sound); defer deactivates once at the end.
+        let session = AVAudioSession.sharedInstance()
+        try session.setCategory(.playAndRecord, mode: .measurement, options: [])
+        try session.setActive(true)
+        defer {
+            try? session.setActive(false, options: .notifyOthersOnDeactivation)
+        }
 
         let result = try await withCheckedThrowingContinuation { cont in
             let box = ResultBox(cont)
@@ -128,12 +131,17 @@ class VoiceInputManager {
                 return
             }
 
-            // Mic is open — present template then play start sound.
-            // isIgnoringSamples discards tap buffers during the sound so it isn't recorded.
-            // recordingStart is set after the sound so silence/max-duration timers are accurate.
-            self.stopLock.withLock { self.isIgnoringSamples = startSoundUri != nil }
-            Task {
-                if let interfaceController = interfaceController {
+            // Start sound fires immediately; template is deferred until the first tap buffer so the mic indicator is already on.
+            if let uri = startSoundUri {
+                Task { await self.playSound(uri: uri) }
+            }
+            if let interfaceController = interfaceController {
+                Task {
+                    await withCheckedContinuation { (cont: CheckedContinuation<Void, Never>) in
+                        self.stopLock.withLock { self.firstBufferContinuation = cont }
+                    }
+                    // Skip if stop() fired before the first buffer — cleanup already dismissed.
+                    guard !self.stopLock.withLock({ self.isStopping }) else { return }
                     await self.presentVoiceTemplate(
                         interfaceController: interfaceController,
                         listeningText: listeningText,
@@ -141,13 +149,6 @@ class VoiceInputManager {
                         listeningImageRepeats: listeningImageRepeats
                     )
                 }
-                if let uri = startSoundUri {
-                    await self.playSound(uri: uri, setupSession: false)
-                }
-                self.stopLock.withLock {
-                    self.isIgnoringSamples = false
-                    self.recordingStart = Date()
-                }
             }
         }
 
@@ -158,14 +159,9 @@ class VoiceInputManager {
         return result
     }
 
-    private func playSound(uri: String, setupSession: Bool = true) async {
+    private func playSound(uri: String) async {
         guard let url = URL(string: uri) else { return }
         do {
-            let session = AVAudioSession.sharedInstance()
-            if setupSession {
-                try session.setCategory(.playback, mode: .default)
-                try session.setActive(true)
-            }
             // URLSession handles both http:// (Metro dev server) and file:// (release bundle)
             let (data, _) = try await URLSession.shared.data(from: url)
             await withCheckedContinuation { (cont: CheckedContinuation<Void, Never>) in
@@ -206,8 +202,7 @@ class VoiceInputManager {
         stopLock.unlock()
 
         if wasSTTMode {
-            // endAudio() causes the recognition task to fire its final result,
-            // which resumes the box. Engine teardown happens there too.
+            // endAudio() triggers the final recognition result, which resumes the box and tears down the engine.
             capturedRequest?.endAudio()
         }
         else {
@@ -236,10 +231,6 @@ class VoiceInputManager {
             throw VoiceInputError.microphonePermissionDenied
         }
 
-        let session = AVAudioSession.sharedInstance()
-        try session.setCategory(.playAndRecord, mode: .measurement, options: [])
-        try session.setActive(true)
-
         var activeRecognitionRequest: SFSpeechAudioBufferRecognitionRequest? = nil
 
         if preferSpeechToText, SFSpeechRecognizer.authorizationStatus() == .authorized,
@@ -311,9 +302,9 @@ class VoiceInputManager {
             throw VoiceInputError.converterUnavailable
         }
 
-        recordingStart = nil
+        recordingStart = Date()
         silenceStart = nil
-        isIgnoringSamples = false
+        firstBufferContinuation = nil
 
         inputNode.installTap(
             onBus: 0,
@@ -324,11 +315,14 @@ class VoiceInputManager {
 
             self.stopLock.lock()
             let stopping = self.isStopping
-            let ignoringSamples = self.isIgnoringSamples
             let recordingStartSnapshot = self.recordingStart
+            let firstBufferCont = self.firstBufferContinuation
+            self.firstBufferContinuation = nil
             self.stopLock.unlock()
 
-            guard !stopping, !ignoringSamples else { return }
+            firstBufferCont?.resume()
+
+            guard !stopping else { return }
 
             // Feed STT if active
             activeRecognitionRequest?.append(buffer)
@@ -378,8 +372,7 @@ class VoiceInputManager {
                 return
             }
 
-            // Silence detection — skip during warm-up so the pipeline has time
-            // to stabilise before we start measuring amplitude
+            // Silence detection — skip during warm-up to let the pipeline stabilise.
             if let start = recordingStartSnapshot,
                 now.timeIntervalSince(start) * 1000 >= VoiceInputManager.warmupMs
             {
@@ -417,7 +410,13 @@ class VoiceInputManager {
         recognitionRequest = nil
         recordingStart = nil
         silenceStart = nil
-        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+        // Drain firstBufferContinuation so the template Task doesn't hang if stop() fired before the first buffer.
+        let pendingCont = stopLock.withLock { () -> CheckedContinuation<Void, Never>? in
+            let c = firstBufferContinuation
+            firstBufferContinuation = nil
+            return c
+        }
+        pendingCont?.resume()
         if let interfaceController {
             dismissVoiceTemplate(interfaceController: interfaceController)
         }
@@ -432,15 +431,10 @@ class VoiceInputManager {
     // CPVoiceControlState enforces a maximum image size of 150x150 points.
     private static let voiceImageMaxSize = CGSize(width: 150, height: 150)
 
-    // CPVoiceControlState also enforces a 0.3s–5s animation cycle; the 0.3s floor is applied
-    // by the system regardless of what we pass, so we only need to clamp our own ceiling.
+    // CPVoiceControlState enforces a 0.3s–5s animation cycle; the 0.3s floor is system-applied, clamp only the ceiling.
     private static let maxVoiceImageCycleDuration: TimeInterval = 5.0
 
-    // Bypasses RCTConvert for asset images: it collapses animated UIImages to a single frame
-    // via CGImage during scale adjustment. Parser.decodeImage preserves animation frames by
-    // walking every frame in the source via ImageIO — UIImage(data:) never builds a multi-frame
-    // .images array itself, for GIF, APNG, or WebP. Tinting is skipped for animated images since
-    // frames cannot be tinted individually.
+    // Uses Parser.decodeImage instead of RCTConvert to preserve animation frames for GIF/APNG/WebP.
     private func loadVoiceImage(image: Variant_GlyphImage_AssetImage_RemoteImage?, traitCollection: UITraitCollection)
         -> UIImage?
     {

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/components/OnAppearedChildRenderer.d.ts

@@ -0,0 +1,10 @@
+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): import("react").ReactNode;
+export {};

package/lib/components/OnAppearedChildRenderer.js

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

package/lib/components/WindowInformationWrapper.d.ts

@@ -0,0 +1,15 @@
+import type React from 'react';
+import type { RootComponentInitialProps } from '../types/RootComponent';
+/**
+ * Renders a user-provided root component and keeps its `window` prop up to date when the host
+ * recreates the render surface with new dimensions (some head units run Android Auto windowed
+ * and resize it at runtime), so consumers can simply read `props.window` without registering a
+ * listener themselves.
+ * On iOS this only passes the initial props through — CarPlay windows keep their size for the
+ * lifetime of a scene, so there is nothing to subscribe to.
+ */
+export declare function WindowInformationWrapper({ moduleName, component, componentProps, }: {
+    moduleName: string;
+    component: React.ComponentType<RootComponentInitialProps>;
+    componentProps: RootComponentInitialProps;
+}): React.ReactElement<RootComponentInitialProps, string | React.JSXElementConstructor<any>>;

package/lib/components/WindowInformationWrapper.js

@@ -0,0 +1,17 @@
+import { createElement, useEffect, useState } from 'react';
+import { HybridAndroidWindowInformation } from '../hybrid/HybridAndroidWindowInformation';
+/**
+ * Renders a user-provided root component and keeps its `window` prop up to date when the host
+ * recreates the render surface with new dimensions (some head units run Android Auto windowed
+ * and resize it at runtime), so consumers can simply read `props.window` without registering a
+ * listener themselves.
+ * On iOS this only passes the initial props through — CarPlay windows keep their size for the
+ * lifetime of a scene, so there is nothing to subscribe to.
+ */
+export function WindowInformationWrapper({ moduleName, component, componentProps, }) {
+    const [window, setWindow] = useState(componentProps.window);
+    useEffect(() => {
+        return HybridAndroidWindowInformation?.addWindowInformationListener(moduleName, setWindow);
+    }, [moduleName]);
+    return createElement(component, { ...componentProps, window });
+}

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/HybridAndroidWindowInformation.android.d.ts

@@ -0,0 +1,2 @@
+import type { AndroidWindowInformation } from '../specs/AndroidWindowInformation.nitro';
+export declare const HybridAndroidWindowInformation: AndroidWindowInformation | null;

package/lib/hybrid/HybridAndroidWindowInformation.android.js

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

package/lib/hybrid/HybridAndroidWindowInformation.d.ts

@@ -0,0 +1,2 @@
+import type { AndroidWindowInformation } from '../specs/AndroidWindowInformation.nitro';
+export declare const HybridAndroidWindowInformation: AndroidWindowInformation | null;

package/lib/hybrid/HybridAndroidWindowInformation.js

@@ -0,0 +1 @@
+export const HybridAndroidWindowInformation = null;

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');