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

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

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

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

package/lib/specs/AutomotivePermissionRequestTemplate.js

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

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

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

package/lib/specs/AutomotivePermissionRequestTemplate.nitro.js

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

package/lib/templates/AutomotivePermissionRequestTemplate.d.ts

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

package/lib/templates/AutomotivePermissionRequestTemplate.js

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

package/lib/templates/MapTemplate.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 = {