@iternio/react-native-auto-play 0.3.8 → 0.3.10

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

@@ -81,8 +81,6 @@ class AndroidAutoService : CarAppService() {
         stopForeground(STOP_FOREGROUND_REMOVE)
 
         NitroModules.applicationContext?.removeLifecycleEventListener(reactLifecycleObserver)
-
-        VirtualRenderer.remove()
     }
 
     private val reactLifecycleObserver = object : LifecycleEventListener {

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

@@ -208,6 +208,7 @@ class AndroidAutoSession(sessionInfo: SessionInfo) :
 
         override fun onDestroy(owner: LifecycleOwner) {
             sessions.remove(moduleName)
+            VirtualRenderer.removeRenderer(moduleName)
             clusterId?.let {
                 HybridCluster.emit(ClusterEventName.DIDDISCONNECT, clusterId)
                 clusterSessions.remove(it)

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

@@ -13,7 +13,7 @@ class HybridMapTemplate : HybridMapTemplateSpec() {
 
     override fun createMapTemplate(config: MapTemplateConfig) {
         val context = AndroidAutoSession.getCarContext(config.id) ?: throw IllegalArgumentException(
-            "createMapTemplate failed, carContext found"
+            "createMapTemplate failed, carContext not found"
         )
 
         val template = MapTemplate(context, config, initNavigationManager = true)
@@ -50,7 +50,7 @@ class HybridMapTemplate : HybridMapTemplateSpec() {
     ) {
         val carContext = AndroidAutoSession.getCarContext(AndroidAutoSession.ROOT_SESSION)
             ?: throw IllegalArgumentException(
-                "dismissNavigationAlert failed, carContext found"
+                "dismissNavigationAlert failed, carContext not found"
             )
         carContext.getCarService(AppManager::class.java).dismissAlert(navigationAlertId.toInt())
     }
@@ -154,4 +154,8 @@ class HybridMapTemplate : HybridMapTemplateSpec() {
     override fun stopNavigation(templateId: String) {
         MapTemplate.stopNavigation()
     }
+
+    override fun setManeuverState(templateId: String, state: ManeuverState) {
+        // Android Auto does not have an equivalent to CPManeuverState
+    }
 }

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

@@ -77,8 +77,6 @@ class VirtualRenderer(
                     return
                 }
 
-                virtualDisplay?.release() // in case this is called multiple times release the old instance
-
                 val manager = context.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
                 virtualDisplay = manager.createVirtualDisplay(
                     moduleName,
@@ -97,7 +95,8 @@ class VirtualRenderer(
             }
 
             override fun onSurfaceDestroyed(surfaceContainer: SurfaceContainer) {
-                stop()
+                virtualDisplay?.release()
+                virtualDisplay = null
             }
 
             override fun onScroll(distanceX: Float, distanceY: Float) {
@@ -426,9 +425,9 @@ class VirtualRenderer(
             return virtualRenderer.contains(moduleId)
         }
 
-        fun remove() {
-            virtualRenderer.forEach { (_, renderer) -> renderer.stop() }
-            virtualRenderer.clear()
+        fun removeRenderer(moduleId: String) {
+            virtualRenderer[moduleId]?.stop()
+            virtualRenderer.remove(moduleId)
         }
     }
 }

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

@@ -5,6 +5,7 @@ import androidx.car.app.Screen
 import androidx.car.app.model.Template
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.AndroidAutoScreen
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroAction
+import java.util.concurrent.ConcurrentHashMap
 
 abstract class AndroidAutoTemplate<T>(val context: CarContext, var config: T) {
     abstract fun parse(): Template
@@ -27,7 +28,7 @@ abstract class AndroidAutoTemplate<T>(val context: CarContext, var config: T) {
 
     companion object {
         const val TAG = "AndroidAutoTemplate"
-        val templates = mutableMapOf<String, AndroidAutoTemplate<*>>()
+        val templates = ConcurrentHashMap<String, AndroidAutoTemplate<*>>()
 
         fun <T> setTemplate(id: String, template: AndroidAutoTemplate<T>) {
             templates.put(id, template)

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

@@ -8,8 +8,8 @@ import com.margelo.nitro.swe.iternio.reactnativeautoplay.GlyphImage
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.NitroColor
 
 object BitmapCache {
-    private val maxMemory = Runtime.getRuntime().maxMemory().toInt()
-    private val cacheSize = minOf(maxMemory / 8, 8388608) //limit cache to 8 megabyte
+    private val maxMemory = Runtime.getRuntime().maxMemory()
+    private val cacheSize = minOf(maxMemory / 8, 8388608).toInt() //limit cache to 8 megabyte
 
     private val bitmapCache = object : LruCache<String, Bitmap>(cacheSize) {
         override fun sizeOf(key: String, bitmap: Bitmap): Int {

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

@@ -7,11 +7,12 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 
 class Debouncer(private val delayMillis: Long = 300L) {
+  private val scope = CoroutineScope(Dispatchers.Main)
   private var debounceJob: Job? = null
 
   fun submit(action: () -> Unit) {
     debounceJob?.cancel()
-    debounceJob = CoroutineScope(Dispatchers.Main).launch {
+    debounceJob = scope.launch {
       delay(delayMillis)
       action()
     }

package/ios/hybrid/HybridMapTemplate.swift

@@ -164,4 +164,11 @@ class HybridMapTemplate: HybridMapTemplateSpec {
             template.stopNavigation()
         }
     }
+
+    func setManeuverState(templateId: String, state: ManeuverState) throws {
+        try RootModule.withAutoPlayTemplate(templateId: templateId) {
+            (template: MapTemplate) in
+            template.setManeuverState(state: state)
+        }
+    }
 }

package/ios/templates/MapTemplate.swift

@@ -784,4 +784,20 @@ class MapTemplate: AutoPlayHeaderProviding,
         navigationSession?.finishTrip()
         navigationSession = nil
     }
+
+    func setManeuverState(state: ManeuverState) {
+        guard #available(iOS 17.4, *) else { return }
+        guard let navigationSession = navigationSession else { return }
+
+        switch state {
+        case .continue:
+            navigationSession.maneuverState = .continue
+        case .initial:
+            navigationSession.maneuverState = .initial
+        case .prepare:
+            navigationSession.maneuverState = .prepare
+        case .execute:
+            navigationSession.maneuverState = .execute
+        }
+    }
 }

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

@@ -1,5 +1,6 @@
 import type { HybridObject } from 'react-native-nitro-modules';
 import type { NitroMapTemplateConfig, TripSelectorCallback, VisibleTravelEstimate } from '../templates/MapTemplate';
+import type { ManeuverState } from '../types/Maneuver';
 import type { AutoText } from '../types/Text';
 import type { TripConfig, TripPoint, TripPreviewTextConfiguration, TripsConfig } from '../types/Trip';
 import type { NitroNavigationAlert } from '../utils/NitroAlert';
@@ -24,5 +25,6 @@ export interface MapTemplate extends HybridObject<{
     updateManeuvers(templateId: string, maneuvers: NitroManeuver): void;
     startNavigation(templateId: string, trip: TripConfig): void;
     stopNavigation(templateId: string): void;
+    setManeuverState(templateId: string, state: ManeuverState): void;
 }
 export {};

package/lib/templates/MapTemplate.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import type { AutoText } from '..';
 import type { ActionButtonAndroid, MapButton, MapPanButton } from '../types/Button';
-import type { AutoManeuver } from '../types/Maneuver';
+import type { AutoManeuver, ManeuverState } from '../types/Maneuver';
 import type { ColorScheme, RootComponentInitialProps } from '../types/RootComponent';
 import type { TripConfig, TripPoint, TripPreviewTextConfiguration, TripsConfig } from '../types/Trip';
 import { type NitroAction } from '../utils/NitroAction';
@@ -148,4 +148,11 @@ export declare class MapTemplate extends Template<MapTemplateConfig, MapTemplate
      */
     startNavigation(trip: TripConfig): void;
     stopNavigation(): void;
+    /**
+     * Sets the current maneuver state indicating progress within a maneuver.
+     * Transition through: continue → initial → prepare → execute → continue
+     * @namespace iOS sets CPManeuverState on the CPNavigationSession, used by instrument cluster and HUD
+     * @namespace Android no-op, Android Auto does not have an equivalent API
+     */
+    setManeuverState(state: ManeuverState): void;
 }

package/lib/templates/MapTemplate.js

@@ -2,6 +2,7 @@ import React from 'react';
 import { AppRegistry, Platform } from 'react-native';
 import { NitroModules } from 'react-native-nitro-modules';
 import { MapTemplateProvider } from '../components/MapTemplateContext';
+import OnAppearedChildRenderer from '../components/OnAppearedChildRenderer';
 import { SafeAreaInsetsProvider } from '../components/SafeAreaInsetsContext';
 import { HybridAutoPlay } from '../hybrid/HybridAutoPlay';
 import { NitroActionUtil } from '../utils/NitroAction';
@@ -22,7 +23,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(OnAppearedChildRenderer, {
+                    // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
+                    children: React.createElement(component, props),
+                    moduleName: this.id,
+                }),
             }),
         }));
         const nitroConfig = {
@@ -122,4 +127,13 @@ export class MapTemplate extends Template {
     stopNavigation() {
         HybridMapTemplate.stopNavigation(this.id);
     }
+    /**
+     * Sets the current maneuver state indicating progress within a maneuver.
+     * Transition through: continue → initial → prepare → execute → continue
+     * @namespace iOS sets CPManeuverState on the CPNavigationSession, used by instrument cluster and HUD
+     * @namespace Android no-op, Android Auto does not have an equivalent API
+     */
+    setManeuverState(state) {
+        HybridMapTemplate.setManeuverState(this.id, state);
+    }
 }

package/lib/types/Maneuver.d.ts

@@ -56,6 +56,18 @@ export declare enum KeepType {
     Right = 1,// Android TYPE_KEEP_RIGHT, iOS keepRight
     FollowRoad = 2
 }
+/**
+ * Describes the progress within a maneuver.
+ * Transition through: Continue → Initial → Prepare → Execute → Continue
+ * @namespace iOS sets CPManeuverState on the CPNavigationSession
+ * @namespace Android no-op, Android Auto does not have an equivalent API
+ */
+export declare enum ManeuverState {
+    Continue = 0,// iOS .continue
+    Initial = 1,// iOS .initial
+    Prepare = 2,// iOS .prepare
+    Execute = 3
+}
 export interface BaseManeuver {
     /**
      * @namespace iOS specify a unique identifier, sending over a Maneuver with a known id will only update the travelEstimates on the previously sent Maneuver

package/lib/types/Maneuver.js

@@ -59,3 +59,16 @@ export var KeepType;
     KeepType[KeepType["Right"] = 1] = "Right";
     KeepType[KeepType["FollowRoad"] = 2] = "FollowRoad";
 })(KeepType || (KeepType = {}));
+/**
+ * Describes the progress within a maneuver.
+ * Transition through: Continue → Initial → Prepare → Execute → Continue
+ * @namespace iOS sets CPManeuverState on the CPNavigationSession
+ * @namespace Android no-op, Android Auto does not have an equivalent API
+ */
+export var ManeuverState;
+(function (ManeuverState) {
+    ManeuverState[ManeuverState["Continue"] = 0] = "Continue";
+    ManeuverState[ManeuverState["Initial"] = 1] = "Initial";
+    ManeuverState[ManeuverState["Prepare"] = 2] = "Prepare";
+    ManeuverState[ManeuverState["Execute"] = 3] = "Execute";
+})(ManeuverState || (ManeuverState = {}));

package/lib/utils/NitroMapButton.js

@@ -13,7 +13,7 @@ const convert = (template, mapButtons) => {
                 : 'backgroundColor' in button.image
                     ? button.image.backgroundColor
                     : 'transparent';
-            const fontScale = (button.image.fontScale ?? Platform.OS === 'android') ? 1.0 : 0.65;
+            const fontScale = button.image.fontScale ?? (Platform.OS === 'android' ? 1.0 : 0.65);
             return {
                 type,
                 onPress,

package/nitrogen/generated/android/c++/JHybridMapTemplateSpec.cpp

@@ -93,6 +93,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class Traffic
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ManeuverType; }
 // Forward declaration of `TripConfig` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig; }
+// Forward declaration of `ManeuverState` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ManeuverState; }
 
 #include "TripSelectorCallback.hpp"
 #include "JTripSelectorCallback.hpp"
@@ -203,6 +205,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig;
 #include "JNitroLoadingManeuver.hpp"
 #include "TripConfig.hpp"
 #include "JTripConfig.hpp"
+#include "ManeuverState.hpp"
+#include "JManeuverState.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -333,5 +337,9 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* templateId */)>("stopNavigation");
     method(_javaPart, jni::make_jstring(templateId));
   }
+  void JHybridMapTemplateSpec::setManeuverState(const std::string& templateId, ManeuverState state) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* templateId */, jni::alias_ref<JManeuverState> /* state */)>("setManeuverState");
+    method(_javaPart, jni::make_jstring(templateId), JManeuverState::fromCpp(state));
+  }
 
 } // namespace margelo::nitro::swe::iternio::reactnativeautoplay

package/nitrogen/generated/android/c++/JHybridMapTemplateSpec.hpp

@@ -66,6 +66,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     void updateManeuvers(const std::string& templateId, const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver>& maneuvers) override;
     void startNavigation(const std::string& templateId, const TripConfig& trip) override;
     void stopNavigation(const std::string& templateId) override;
+    void setManeuverState(const std::string& templateId, ManeuverState state) override;
 
   private:
     jni::global_ref<JHybridMapTemplateSpec::JavaPart> _javaPart;

package/nitrogen/generated/android/c++/JManeuverState.hpp

@@ -0,0 +1,64 @@
+///
+/// JManeuverState.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ManeuverState.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "ManeuverState" and the the Kotlin enum "ManeuverState".
+   */
+  struct JManeuverState final: public jni::JavaClass<JManeuverState> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/ManeuverState;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum ManeuverState.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ManeuverState toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<ManeuverState>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JManeuverState> fromCpp(ManeuverState value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case ManeuverState::CONTINUE:
+          static const auto fieldCONTINUE = clazz->getStaticField<JManeuverState>("CONTINUE");
+          return clazz->getStaticFieldValue(fieldCONTINUE);
+        case ManeuverState::INITIAL:
+          static const auto fieldINITIAL = clazz->getStaticField<JManeuverState>("INITIAL");
+          return clazz->getStaticFieldValue(fieldINITIAL);
+        case ManeuverState::PREPARE:
+          static const auto fieldPREPARE = clazz->getStaticField<JManeuverState>("PREPARE");
+          return clazz->getStaticFieldValue(fieldPREPARE);
+        case ManeuverState::EXECUTE:
+          static const auto fieldEXECUTE = clazz->getStaticField<JManeuverState>("EXECUTE");
+          return clazz->getStaticFieldValue(fieldEXECUTE);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

package/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridMapTemplateSpec.kt

@@ -81,6 +81,10 @@ abstract class HybridMapTemplateSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun stopNavigation(templateId: String): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setManeuverState(templateId: String, state: ManeuverState): Unit
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/ManeuverState.kt

@@ -0,0 +1,25 @@
+///
+/// ManeuverState.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "ManeuverState".
+ */
+@DoNotStrip
+@Keep
+enum class ManeuverState(@DoNotStrip @Keep val value: Int) {
+  CONTINUE(0),
+  INITIAL(1),
+  PREPARE(2),
+  EXECUTE(3);
+
+  companion object
+}

package/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Umbrella.hpp

@@ -64,6 +64,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct LaneGuidanc
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct ListTemplateConfig; }
 // Forward declaration of `Location` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct Location; }
+// Forward declaration of `ManeuverState` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ManeuverState; }
 // Forward declaration of `ManeuverType` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ManeuverType; }
 // Forward declaration of `MapTemplateConfig` to properly resolve imports.
@@ -176,6 +178,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ZoomEve
 #include "LaneGuidance.hpp"
 #include "ListTemplateConfig.hpp"
 #include "Location.hpp"
+#include "ManeuverState.hpp"
 #include "ManeuverType.hpp"
 #include "MapTemplateConfig.hpp"
 #include "MessageTemplateConfig.hpp"

package/nitrogen/generated/ios/c++/HybridMapTemplateSpecSwift.hpp

@@ -98,6 +98,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class Traffic
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ManeuverType; }
 // Forward declaration of `TripConfig` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig; }
+// Forward declaration of `ManeuverState` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ManeuverState; }
 
 #include "MapTemplateConfig.hpp"
 #include <string>
@@ -148,6 +150,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig;
 #include "TrafficSide.hpp"
 #include "ManeuverType.hpp"
 #include "TripConfig.hpp"
+#include "ManeuverState.hpp"
 
 #include "ReactNativeAutoPlay-Swift-Cxx-Umbrella.hpp"
 
@@ -275,6 +278,12 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void setManeuverState(const std::string& templateId, ManeuverState state) override {
+      auto __result = _swiftPart.setManeuverState(templateId, static_cast<int>(state));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
 
   private:
     ReactNativeAutoPlay::HybridMapTemplateSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/HybridMapTemplateSpec.swift

@@ -25,6 +25,7 @@ public protocol HybridMapTemplateSpec_protocol: HybridObject {
   func updateManeuvers(templateId: String, maneuvers: NitroManeuver) throws -> Void
   func startNavigation(templateId: String, trip: TripConfig) throws -> Void
   func stopNavigation(templateId: String) throws -> Void
+  func setManeuverState(templateId: String, state: ManeuverState) throws -> Void
 }
 
 public extension HybridMapTemplateSpec_protocol {

package/nitrogen/generated/ios/swift/HybridMapTemplateSpec_cxx.swift

@@ -308,4 +308,15 @@ open class HybridMapTemplateSpec_cxx {
       return bridge.create_Result_void_(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func setManeuverState(templateId: std.string, state: Int32) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setManeuverState(templateId: String(templateId), state: margelo.nitro.swe.iternio.reactnativeautoplay.ManeuverState(rawValue: state)!)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/ios/swift/ManeuverState.swift

@@ -0,0 +1,48 @@
+///
+/// ManeuverState.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS enum `ManeuverState`, backed by a C++ enum.
+ */
+public typealias ManeuverState = margelo.nitro.swe.iternio.reactnativeautoplay.ManeuverState
+
+public extension ManeuverState {
+  /**
+   * Get a ManeuverState for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "Continue":
+        self = .continue
+      case "Initial":
+        self = .initial
+      case "Prepare":
+        self = .prepare
+      case "Execute":
+        self = .execute
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this ManeuverState represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .continue:
+        return "Continue"
+      case .initial:
+        return "Initial"
+      case .prepare:
+        return "Prepare"
+      case .execute:
+        return "Execute"
+    }
+  }
+}

package/nitrogen/generated/shared/c++/HybridMapTemplateSpec.cpp

@@ -26,6 +26,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       prototype.registerHybridMethod("updateManeuvers", &HybridMapTemplateSpec::updateManeuvers);
       prototype.registerHybridMethod("startNavigation", &HybridMapTemplateSpec::startNavigation);
       prototype.registerHybridMethod("stopNavigation", &HybridMapTemplateSpec::stopNavigation);
+      prototype.registerHybridMethod("setManeuverState", &HybridMapTemplateSpec::setManeuverState);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridMapTemplateSpec.hpp

@@ -39,6 +39,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroMessag
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroLoadingManeuver; }
 // Forward declaration of `TripConfig` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig; }
+// Forward declaration of `ManeuverState` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ManeuverState; }
 
 #include "MapTemplateConfig.hpp"
 #include <string>
@@ -59,6 +61,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig;
 #include "NitroLoadingManeuver.hpp"
 #include <variant>
 #include "TripConfig.hpp"
+#include "ManeuverState.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -103,6 +106,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       virtual void updateManeuvers(const std::string& templateId, const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver>& maneuvers) = 0;
       virtual void startNavigation(const std::string& templateId, const TripConfig& trip) = 0;
       virtual void stopNavigation(const std::string& templateId) = 0;
+      virtual void setManeuverState(const std::string& templateId, ManeuverState state) = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/ManeuverState.hpp

@@ -0,0 +1,64 @@
+///
+/// ManeuverState.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  /**
+   * An enum which can be represented as a JavaScript enum (ManeuverState).
+   */
+  enum class ManeuverState {
+    CONTINUE      SWIFT_NAME(continue) = 0,
+    INITIAL      SWIFT_NAME(initial) = 1,
+    PREPARE      SWIFT_NAME(prepare) = 2,
+    EXECUTE      SWIFT_NAME(execute) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
+
+namespace margelo::nitro {
+
+  // C++ ManeuverState <> JS ManeuverState (enum)
+  template <>
+  struct JSIConverter<margelo::nitro::swe::iternio::reactnativeautoplay::ManeuverState> final {
+    static inline margelo::nitro::swe::iternio::reactnativeautoplay::ManeuverState fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
+      return static_cast<margelo::nitro::swe::iternio::reactnativeautoplay::ManeuverState>(enumValue);
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::swe::iternio::reactnativeautoplay::ManeuverState arg) {
+      int enumValue = static_cast<int>(arg);
+      return JSIConverter<int>::toJSI(runtime, enumValue);
+    }
+    static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+      if (!value.isNumber()) {
+        return false;
+      }
+      double number = value.getNumber();
+      int integer = static_cast<int>(number);
+      if (number != integer) {
+        // The integer is not the same value as the double - we truncated floating points.
+        // Enums are all integers, so the input floating point number is obviously invalid.
+        return false;
+      }
+      // Check if we are within the bounds of the enum.
+      return integer >= 0 && integer <= 3;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iternio/react-native-auto-play",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "description": "Android Auto and Apple CarPlay for react-native",
   "main": "lib/index",
   "module": "lib/index",

package/src/components/OnAppearedChildRenderer.tsx

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

package/src/specs/MapTemplate.nitro.ts

@@ -4,6 +4,7 @@ import type {
   TripSelectorCallback,
   VisibleTravelEstimate,
 } from '../templates/MapTemplate';
+import type { ManeuverState } from '../types/Maneuver';
 import type { AutoText } from '../types/Text';
 import type {
   TripConfig,
@@ -48,4 +49,5 @@ export interface MapTemplate extends HybridObject<{ android: 'kotlin'; ios: 'swi
   updateManeuvers(templateId: string, maneuvers: NitroManeuver): void;
   startNavigation(templateId: string, trip: TripConfig): void;
   stopNavigation(templateId: string): void;
+  setManeuverState(templateId: string, state: ManeuverState): void;
 }

package/src/templates/MapTemplate.ts

@@ -3,11 +3,12 @@ import { AppRegistry, Platform } from 'react-native';
 import { NitroModules } from 'react-native-nitro-modules';
 import type { AutoText } from '..';
 import { MapTemplateProvider } from '../components/MapTemplateContext';
+import OnAppearedChildRenderer from '../components/OnAppearedChildRenderer';
 import { SafeAreaInsetsProvider } from '../components/SafeAreaInsetsContext';
 import { HybridAutoPlay } from '../hybrid/HybridAutoPlay';
 import type { MapTemplate as NitroMapTemplate } from '../specs/MapTemplate.nitro';
 import type { ActionButtonAndroid, MapButton, MapPanButton } from '../types/Button';
-import type { AutoManeuver } from '../types/Maneuver';
+import type { AutoManeuver, ManeuverState } from '../types/Maneuver';
 import type { ColorScheme, RootComponentInitialProps } from '../types/RootComponent';
 import type {
   TripConfig,
@@ -180,7 +181,11 @@ export class MapTemplate extends Template<MapTemplateConfig, MapTemplateConfig['
           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(OnAppearedChildRenderer, {
+              // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
+              children: React.createElement(component, props),
+              moduleName: this.id,
+            }),
           }),
         })
     );
@@ -341,4 +346,14 @@ export class MapTemplate extends Template<MapTemplateConfig, MapTemplateConfig['
   public stopNavigation() {
     HybridMapTemplate.stopNavigation(this.id);
   }
+
+  /**
+   * Sets the current maneuver state indicating progress within a maneuver.
+   * Transition through: continue → initial → prepare → execute → continue
+   * @namespace iOS sets CPManeuverState on the CPNavigationSession, used by instrument cluster and HUD
+   * @namespace Android no-op, Android Auto does not have an equivalent API
+   */
+  public setManeuverState(state: ManeuverState) {
+    HybridMapTemplate.setManeuverState(this.id, state);
+  }
 }

package/src/types/Maneuver.ts

@@ -64,6 +64,19 @@ export enum KeepType {
   FollowRoad = 2,
 }
 
+/**
+ * Describes the progress within a maneuver.
+ * Transition through: Continue → Initial → Prepare → Execute → Continue
+ * @namespace iOS sets CPManeuverState on the CPNavigationSession
+ * @namespace Android no-op, Android Auto does not have an equivalent API
+ */
+export enum ManeuverState {
+  Continue = 0, // iOS .continue
+  Initial = 1, // iOS .initial
+  Prepare = 2, // iOS .prepare
+  Execute = 3, // iOS .execute
+}
+
 export interface BaseManeuver {
   /**
    * @namespace iOS specify a unique identifier, sending over a Maneuver with a known id will only update the travelEstimates on the previously sent Maneuver

package/src/utils/NitroMapButton.ts

@@ -27,7 +27,7 @@ const convert = <T>(template: T, mapButtons?: MapButtons<T>): Array<NitroMapButt
             ? button.image.backgroundColor
             : 'transparent';
 
-      const fontScale = (button.image.fontScale ?? Platform.OS === 'android') ? 1.0 : 0.65;
+      const fontScale = button.image.fontScale ?? (Platform.OS === 'android' ? 1.0 : 0.65);
 
       return {
         type,