@iternio/react-native-auto-play 0.5.8 → 0.5.10

package/README.md

@@ -206,6 +206,14 @@ In case you have ProGuard enabled (`def enableProguardInReleaseBuilds = true` in
 ### Android Auto Customization
 You can customize certain behaviors of the library on Android Auto by setting properties in your app's `android/gradle.properties` file.
 
+-   **App Category**: Declare which Android Auto / Automotive app type the `CarAppService` advertises — the Android counterpart to choosing your CarPlay scene type in `Info.plist`.
+    ```properties
+    ReactNativeAutoPlay_androidAutoAppCategory=navigation
+    ```
+    Supported values are `navigation`, `poi`, `parking`, `charging`, `iot`, `messaging`, `calling`, and `weather` (see the [supported app categories](https://developer.android.com/training/cars)); each maps to `androidx.car.app.category.<UPPERCASE>`. An unrecognized value fails the build. The default `navigation` keeps the existing behavior. Any other value selects a lean manifest that declares the chosen category and omits the navigation-only permissions (`NAVIGATION_TEMPLATES`, `MAP_TEMPLATES`, `ACCESS_SURFACE`), the `FEATURE_CLUSTER` category, and the `NAVIGATE`/`geo` intent filters — a non-navigation, no-map template app needs none of these, and declaring them gets the app reviewed against the navigation-app bar on the Play Store.
+
+    On Android Automotive, the app-focus helpers on `HybridAndroidAutomotive` (`requestAppFocus`, `registerAppFocusListener`, `getAppFocusState`) request/observe **navigation** focus specifically; they are meant for navigation apps and should not be used with a non-navigation category.
+
 -   **Telemetry Update Interval**: Control how often telemetry data is updated.
     ```properties
     ReactNativeAutoPlay_androidTelemetryUpdateInterval=4000

package/android/build.gradle

@@ -28,6 +28,11 @@ def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ReactNativeAutoPlay_" + name]).toInteger()
 }
 
+// Non-navigation categories select the lean manifest (AndroidManifest-nonnav.xml).
+def androidAutoAppCategory = getExtOrDefault("androidAutoAppCategory").toString().trim().toLowerCase(java.util.Locale.ROOT)
+def validAndroidAutoCategories = ['navigation', 'poi', 'parking', 'charging', 'iot', 'messaging', 'calling', 'weather']
+def isNavigationApp = androidAutoAppCategory == "navigation"
+
 android {
   namespace "com.margelo.nitro.swe.iternio.reactnativeautoplay"
 
@@ -35,6 +40,10 @@ android {
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
   defaultConfig {
+    if (!validAndroidAutoCategories.contains(androidAutoAppCategory)) {
+      throw new GradleException("Invalid ReactNativeAutoPlay_androidAutoAppCategory '${androidAutoAppCategory}'. Must be one of: ${validAndroidAutoCategories.join(', ')}")
+    }
+
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
 
@@ -55,6 +64,9 @@ android {
       }
     }
 
+    manifestPlaceholders.autoPlayAppCategory = "androidx.car.app.category." + androidAutoAppCategory.toUpperCase(java.util.Locale.ROOT)
+
+    buildConfigField "boolean", "IS_NAVIGATION_APP", isNavigationApp.toString()
     buildConfigField "float", "SCALE_FACTOR", getExtOrDefault("androidAutoScaleFactor")
     buildConfigField "long", "TELEMETRY_UPDATE_INTERVAL", getExtOrDefault("androidTelemetryUpdateInterval")
     buildConfigField "long", "CLUSTER_SPLASH_DELAY_MS", getExtOrDefault("clusterSplashDelayMs")
@@ -117,10 +129,10 @@ android {
 
       if (getExtOrDefault("isAutomotiveApp") == "true") {
         java.srcDirs += 'src/automotive/java'
-        manifest.srcFile 'src/automotive/AndroidManifest.xml'
+        manifest.srcFile isNavigationApp ? 'src/automotive/AndroidManifest.xml' : 'src/automotive/AndroidManifest-nonnav.xml'
       } else {
         java.srcDirs += 'src/auto/java'
-        manifest.srcFile 'src/main/AndroidManifest.xml'
+        manifest.srcFile isNavigationApp ? 'src/main/AndroidManifest.xml' : 'src/main/AndroidManifest-nonnav.xml'
       }
     }
   }

package/android/gradle.properties

@@ -5,6 +5,8 @@ ReactNativeAutoPlay_compileSdkVersion=36
 ReactNativeAutoPlay_ndkVersion=27.1.12297006
 # specifies if the Android Auto (androidx.car.app:app-projected) or Automotive (androidx.car.app:app-automotive) library is used
 ReactNativeAutoPlay_isAutomotiveApp=false
+# Android Auto/Automotive app category -> androidx.car.app.category.<UPPERCASE>. Non-navigation values use a lean manifest.
+ReactNativeAutoPlay_androidAutoAppCategory=navigation
 # apply a scale factor on the root view that affects everything rendered by react-native, does not affect templates
 ReactNativeAutoPlay_androidAutoScaleFactor=1.5f
 ReactNativeAutoPlay_androidTelemetryUpdateInterval=4000

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

@@ -0,0 +1,78 @@
+<!-- Non-navigation Android Automotive manifest; see AndroidManifest.xml for the navigation variant. -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-feature
+        android:name="android.hardware.type.automotive"
+        android:required="true" />
+
+    <uses-feature
+        android:name="android.software.car.templates_host"
+        android:required="true" />
+
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
+
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+
+
+    <!-- Android Automotive specific permissions -->
+    <uses-permission android:name="android.car.permission.CAR_ENERGY" />
+    <uses-permission android:name="android.car.permission.CAR_ENERGY_PORTS" />
+    <uses-permission android:name="android.car.permission.CAR_EXTERIOR_ENVIRONMENT" />
+    <uses-permission android:name="android.car.permission.CAR_IDENTIFICATION" />
+    <uses-permission android:name="android.car.permission.CAR_INFO" />
+    <uses-permission android:name="android.car.permission.CAR_POWERTRAIN" />
+    <uses-permission android:name="android.car.permission.CAR_SPEED" />
+
+    <application>
+        <activity
+            android:name="androidx.car.app.activity.CarAppActivity"
+            android:exported="true"
+            android:launchMode="singleTask"
+            android:theme="@android:style/Theme.DeviceDefault.NoActionBar">
+
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+
+            <meta-data
+                android:name="distractionOptimized"
+                android:value="true" />
+
+        </activity>
+
+        <service
+            android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.AndroidAutoService"
+            android:exported="true"
+            android:foregroundServiceType="location">
+            <intent-filter>
+                <action android:name="androidx.car.app.CarAppService" />
+
+                <category android:name="${autoPlayAppCategory}" />
+            </intent-filter>
+        </service>
+
+        <service android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.HeadlessTaskService" />
+
+        <activity android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.SignInWithGoogleActivity" />
+
+        <provider
+            android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.ActivityRenderStateProvider"
+            android:authorities="${applicationId}.ActivityRenderStateProvider"
+            android:exported="false" />
+
+        <meta-data
+            android:name="com.android.automotive"
+            android:resource="@xml/automotive_app_desc" />
+        <meta-data
+            android:name="androidx.car.app.minCarApiLevel"
+            android:value="1" />
+    </application>
+
+</manifest>

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

@@ -0,0 +1,35 @@
+<!-- Non-navigation Android Auto manifest; see AndroidManifest.xml for the navigation variant. -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
+
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+
+    <!-- Android Auto specific permissions -->
+    <uses-permission android:name="com.google.android.gms.permission.CAR_FUEL" />
+    <uses-permission android:name="com.google.android.gms.permission.CAR_MILEAGE" />
+    <uses-permission android:name="com.google.android.gms.permission.CAR_SPEED" />
+
+    <application>
+        <service android:name="com.margelo.nitro.swe.iternio.reactnativeautoplay.AndroidAutoService" android:exported="true" android:foregroundServiceType="location">
+            <intent-filter>
+                <action android:name="androidx.car.app.CarAppService" />
+
+                <category android:name="${autoPlayAppCategory}" />
+            </intent-filter>
+        </service>
+
+        <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

@@ -136,9 +136,14 @@ class AndroidAutoService : CarAppService() {
     private fun createNotification(
         title: String?, text: String?, largeIcon: Bitmap?
     ): Notification {
+        val notificationCategory = if (BuildConfig.IS_NAVIGATION_APP) {
+            NotificationCompat.CATEGORY_NAVIGATION
+        } else {
+            NotificationCompat.CATEGORY_SERVICE
+        }
         return NotificationCompat.Builder(this, CHANNEL_ID)
             .setSmallIcon(R.drawable.ic_notification).setOngoing(true)
-            .setCategory(NotificationCompat.CATEGORY_NAVIGATION).setOnlyAlertOnce(true)
+            .setCategory(notificationCategory).setOnlyAlertOnce(true)
             .setWhen(System.currentTimeMillis()).setPriority(NotificationManager.IMPORTANCE_LOW)
             .extend(
                 CarAppExtender.Builder().setImportance(NotificationManagerCompat.IMPORTANCE_LOW)

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

@@ -1,8 +1,9 @@
 import { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
+import { HybridAndroidWindowInformation } from './hybrid/HybridAndroidWindowInformation';
 import { HybridAutoPlay } from './hybrid/HybridAutoPlay';
 import { HybridVoice } from './hybrid/HybridVoice';
 import type { AndroidAutomotive } from './specs/AndroidAutomotive.nitro';
-export { HybridAndroidAutoTelemetry, HybridAutoPlay, HybridVoice };
+export { HybridAndroidAutoTelemetry, HybridAndroidWindowInformation, HybridAutoPlay, HybridVoice };
 export declare const HybridAndroidAutomotive: AndroidAutomotive | null;
 /**
  * These are the static module names for the app running on the mobile device, head unit screen and the CarPlay dashboard.

package/lib/index.js

@@ -2,10 +2,11 @@ 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, HybridAutoPlay, HybridVoice };
+export { HybridAndroidAutoTelemetry, HybridAndroidWindowInformation, HybridAutoPlay, HybridVoice };
 export const HybridAndroidAutomotive = Platform.OS === 'android'
     ? NitroModules.createHybridObject('AndroidAutomotive')
     : null;

package/lib/scenes/AutoPlayCluster.js

@@ -2,6 +2,7 @@ import React from 'react';
 import { AppRegistry, Platform } from 'react-native';
 import { NitroModules } from 'react-native-nitro-modules';
 import { SafeAreaInsetsProvider } from '../components/SafeAreaInsetsContext';
+import { WindowInformationWrapper } from '../components/WindowInformationWrapper';
 import { NitroImageUtil } from '../utils/NitroImage';
 const HybridCluster = NitroModules.createHybridObject('Cluster');
 class Cluster {
@@ -49,7 +50,11 @@ class Cluster {
             AppRegistry.registerComponent(clusterId, () => (props) => React.createElement(SafeAreaInsetsProvider, {
                 moduleName: clusterId,
                 // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
-                children: React.createElement(component, props),
+                children: React.createElement(WindowInformationWrapper, {
+                    moduleName: clusterId,
+                    component,
+                    componentProps: props,
+                }),
             }));
             this.clusters[clusterId] = true;
             await HybridCluster.initRootView(clusterId);

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

@@ -0,0 +1,22 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { CleanupCallback } from '../types/Event';
+import type { WindowInformation } from '../types/RootComponent';
+/**
+ * Android-only access to render-surface window dimensions. On iOS this module does not exist —
+ * use the platform-split `HybridAndroidWindowInformation` wrapper which resolves to `null` there.
+ */
+export interface AndroidWindowInformation extends HybridObject<{
+    android: 'kotlin';
+}> {
+    /**
+     * callback for window dimension changes, fired when the host recreates the render surface
+     * with a different size (some head units run Android Auto windowed and resize it at runtime).
+     * Root components rendered via a template's `component` prop do NOT need this — their
+     * `window` prop is kept up to date automatically. Use this listener only for
+     * size-dependent logic living outside a root component.
+     * Fires with the last known window information immediately if the surface is already initialized.
+     * @param moduleName one of @AutoPlayModules or a cluster scene uuid
+     * @namespace Android
+     */
+    addWindowInformationListener(moduleName: string, callback: (window: WindowInformation) => void): CleanupCallback;
+}

package/lib/specs/AndroidWindowInformation.nitro.js

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

package/lib/templates/MapTemplate.js

@@ -3,6 +3,7 @@ import { AppRegistry, Platform } from 'react-native';
 import { NitroModules } from 'react-native-nitro-modules';
 import { MapTemplateProvider } from '../components/MapTemplateContext';
 import { SafeAreaInsetsProvider } from '../components/SafeAreaInsetsContext';
+import { WindowInformationWrapper } from '../components/WindowInformationWrapper';
 import { HybridAutoPlay } from '../hybrid/HybridAutoPlay';
 import { NitroActionUtil } from '../utils/NitroAction';
 import { NitroAlertUtil } from '../utils/NitroAlert';
@@ -23,7 +24,11 @@ export class MapTemplate extends Template {
             children: React.createElement(SafeAreaInsetsProvider, {
                 moduleName: this.id,
                 // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
-                children: React.createElement(component, props),
+                children: React.createElement(WindowInformationWrapper, {
+                    moduleName: this.id,
+                    component,
+                    componentProps: props,
+                }),
             }),
         }));
         const nitroConfig = {

package/lib/types/RootComponent.d.ts

@@ -19,6 +19,10 @@ export type RootComponentInitialProps = {
      * this is the initial color scheme, add onAppearanceDidChange on MapTemplate to get updates
      */
     colorScheme: ColorScheme;
+    /**
+     * the dimensions of the render surface, kept up to date when the host resizes the surface
+     * (e.g. head units running Android Auto windowed)
+     */
     window: WindowInformation;
 };
 export type AutoPlayClusterInitialProps = RootComponentInitialProps & {