@iternio/react-native-auto-play 0.3.9 → 0.3.11

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

@@ -55,6 +55,7 @@ class AndroidAutoSession(sessionInfo: SessionInfo) :
                 null,
                 arrayOf(action),
                 null,
+                null,
                 null
             )
 

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/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/template/MapTemplate.kt

@@ -66,6 +66,10 @@ class MapTemplate(
                 navigationManager.setNavigationManagerCallback(navigationManagerCallback)
             }
         }
+
+        config.defaultGuidanceBackgroundColor?.let { nitroColor ->
+            MapTemplate.cardBackgroundColor = Parser.parseColor(nitroColor)
+        }
     }
 
     override fun parse(): Template {
@@ -329,7 +333,9 @@ class MapTemplate(
             }
 
             if (loadingInfo != null) {
+                cardBackgroundColor = Parser.parseColor(loadingInfo.cardBackgroundColor)
                 navigationInfo = RoutingInfo.Builder().setLoading(true).build()
+                AndroidAutoScreen.invalidateSurfaceScreens()
                 return
             }
 

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

@@ -138,12 +138,9 @@ class HybridMapTemplate: HybridMapTemplateSpec {
                 {
                     template.updateManeuvers(messageManeuver: messageManeuver)
                 }()
-            case .third(let loadingManeuver):
+            case .third(let loading):
                 {
-                    template.navigationSession?.pauseTrip(
-                        for: .loading,
-                        description: nil
-                    )
+                    template.updateManeuversLoading(loading: loading)
                 }()
             }
 
@@ -164,4 +161,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

@@ -50,6 +50,18 @@ class MapTemplate: AutoPlayHeaderProviding,
         visibleTravelEstimate = config.visibleTravelEstimate
 
         template = CPMapTemplate(id: config.id)
+        if let nitroColor = config.defaultGuidanceBackgroundColor,
+            let traitCollection = SceneStore.getRootTraitCollection()
+        {
+            let cardBackgroundColor = Parser.routingManeuverCardBackgroundUIColor(
+                color: nitroColor,
+                traitCollection: traitCollection
+            )
+            template.guidanceBackgroundColor = cardBackgroundColor
+        }
+        else {
+            template.guidanceBackgroundColor = .black
+        }
 
         if let initialProperties = SceneStore.getRootScene()?.initialProperties,
             let windowDict = initialProperties["window"] as? [String: Any],
@@ -607,6 +619,35 @@ class MapTemplate: AutoPlayHeaderProviding,
         updateVisibleTravelEstimate(visibleTravelEstimate: nil)
     }
 
+    func updateManeuversLoading(loading: NitroLoadingManeuver) {
+        guard let navigationSession = navigationSession else { return }
+
+        let description = loading.text
+
+        guard let traitCollection = SceneStore.getRootTraitCollection() else {
+            navigationSession.pauseTrip(for: .loading, description: description)
+            return
+        }
+
+        let cardBackgroundColor = Parser.routingManeuverCardBackgroundUIColor(
+            color: loading.cardBackgroundColor,
+            traitCollection: traitCollection
+        )
+
+        template.guidanceBackgroundColor = cardBackgroundColor
+
+        if #available(iOS 18.0, *) {
+            navigationSession.pauseTrip(
+                for: .loading,
+                description: description,
+                turnCardColor: cardBackgroundColor
+            )
+        }
+        else {
+            navigationSession.pauseTrip(for: .loading, description: description)
+        }
+    }
+
     func updateManeuvers(messageManeuver: NitroMessageManeuver) {
         guard let navigationSession = navigationSession else { return }
 
@@ -784,4 +825,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/ios/templates/Parser.swift

@@ -503,6 +503,21 @@ class Parser {
         )
     }
 
+    /// Card background `UIColor` for routing maneuvers and loading pause — same light/dark component pick as `parseManeuver`.
+    static func routingManeuverCardBackgroundUIColor(
+        color: NitroColor,
+        traitCollection: UITraitCollection
+    ) -> UIColor {
+        if #available(iOS 15.4, *) {
+            let component =
+                traitCollection.userInterfaceStyle == .dark
+                ? color.darkColor
+                : color.lightColor
+            return doubleToColor(value: component)
+        }
+        return parseColor(color: color)
+    }
+
     static func parseManeuver(
         nitroManeuver: NitroRoutingManeuver,
         traitCollection: UITraitCollection
@@ -528,13 +543,9 @@ class Parser {
         )
 
         if #available(iOS 15.4, *) {
-            let cardBackgroundColor =
-                traitCollection.userInterfaceStyle == .dark
-                ? nitroManeuver.cardBackgroundColor.darkColor
-                : nitroManeuver.cardBackgroundColor.lightColor
-
-            maneuver.cardBackgroundColor = doubleToColor(
-                value: cardBackgroundColor
+            maneuver.cardBackgroundColor = routingManeuverCardBackgroundUIColor(
+                color: nitroManeuver.cardBackgroundColor,
+                traitCollection: traitCollection
             )
         }
 

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,11 +1,12 @@
 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';
 import { type NavigationAlert } from '../utils/NitroAlert';
+import { type NitroColor, type ThemedColor } from '../utils/NitroColor';
 import { NitroMapButton } from '../utils/NitroMapButton';
 import { type HeaderActionsIos, type NitroBaseMapTemplateConfig, Template, type TemplateConfig } from './Template';
 export type Point = {
@@ -53,6 +54,7 @@ export interface NitroMapTemplateConfig extends TemplateConfig, NitroBaseMapTemp
     onAutoDriveEnabled?: () => void;
     mapButtons?: Array<NitroMapButton>;
     headerActions?: Array<NitroAction>;
+    defaultGuidanceBackgroundColor?: NitroColor;
     /**
      * specify the percentage of screen height/width the pan button should scroll
      * @namespace iOS
@@ -78,7 +80,7 @@ export type BaseMapTemplateConfig<T> = {
      */
     headerActions?: MapHeaderActions<T>;
 };
-export type MapTemplateConfig = Omit<NitroMapTemplateConfig, 'mapButtons' | 'headerActions' | 'onStopNavigation' | 'onAutoDriveEnabled'> & BaseMapTemplateConfig<MapTemplate> & {
+export type MapTemplateConfig = Omit<NitroMapTemplateConfig, 'mapButtons' | 'headerActions' | 'onStopNavigation' | 'onAutoDriveEnabled' | 'defaultGuidanceBackgroundColor'> & BaseMapTemplateConfig<MapTemplate> & {
     /**
      * react component that is rendered
      */
@@ -93,6 +95,10 @@ export type MapTemplateConfig = Omit<NitroMapTemplateConfig, 'mapButtons' | 'hea
      * @namespace Android
      */
     onAutoDriveEnabled?: (template: MapTemplate) => void;
+    /**
+     * Initial navigation maneuver background color. Mainly useful, when in CarPlay the default loading maneuver does not have the right color.
+     */
+    defaultGuidanceBackgroundColor?: ThemedColor | string;
 };
 export interface TripSelectorCallback {
     setSelectedTrip: (id: string) => void;
@@ -148,4 +154,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,10 +2,12 @@ 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';
 import { NitroAlertUtil } from '../utils/NitroAlert';
+import { NitroColorUtil } from '../utils/NitroColor';
 import { NitroManeuverUtil } from '../utils/NitroManeuver';
 import { NitroMapButton } from '../utils/NitroMapButton';
 import { Template, } from './Template';
@@ -15,14 +17,18 @@ export class MapTemplate extends Template {
     template = this;
     constructor(config) {
         super(config);
-        const { component, mapButtons, headerActions, onStopNavigation, onAutoDriveEnabled, ...baseConfig } = config;
+        const { component, mapButtons, headerActions, onStopNavigation, onAutoDriveEnabled, defaultGuidanceBackgroundColor, ...baseConfig } = config;
         AppRegistry.registerComponent(this.id, () => (props) => React.createElement(MapTemplateProvider, {
             mapTemplate: this.template,
             // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
             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 = {
@@ -32,6 +38,9 @@ export class MapTemplate extends Template {
             mapButtons: NitroMapButton.convert(this.template, mapButtons),
             onStopNavigation: () => onStopNavigation(this.template),
             onAutoDriveEnabled: onAutoDriveEnabled ? () => onAutoDriveEnabled(this.template) : undefined,
+            defaultGuidanceBackgroundColor: defaultGuidanceBackgroundColor != null
+                ? NitroColorUtil.convert(defaultGuidanceBackgroundColor)
+                : undefined,
         };
         HybridMapTemplate.createMapTemplate(nitroConfig);
     }
@@ -106,7 +115,11 @@ export class MapTemplate extends Template {
             return;
         }
         if (maneuvers.type === 'loading') {
-            HybridMapTemplate.updateManeuvers(this.id, { isLoading: true });
+            HybridMapTemplate.updateManeuvers(this.id, {
+                isLoading: true,
+                cardBackgroundColor: NitroColorUtil.convert(maneuvers.cardBackgroundColor),
+                text: maneuvers.text != null ? maneuvers.text : undefined,
+            });
             return;
         }
         const messageManeuver = NitroManeuverUtil.convert(maneuvers);
@@ -122,4 +135,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
@@ -198,6 +210,12 @@ export type MessageManeuver = {
 };
 export type LoadingManeuver = {
     type: 'loading';
+    cardBackgroundColor: ThemedColor | string;
+    /**
+     * @namespace iOS CarPlay — shows text on the loading maneuver card
+     * @namespace Android Auto — not supported
+     */
+    text?: string;
 };
 export type AutoManeuver = (Array<RoutingManeuver> & {
     length: 0 | 1 | 2;

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

@@ -35,6 +35,8 @@ export interface NitroMessageManeuver {
 }
 interface NitroLoadingManeuver {
     isLoading: true;
+    cardBackgroundColor: NitroColor;
+    text?: string;
 }
 export type NitroManeuver = Array<NitroRoutingManeuver> | NitroMessageManeuver | NitroLoadingManeuver;
 declare function convert(autoManeuver: MessageManeuver): NitroMessageManeuver;

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/c++/JMapTemplateConfig.hpp

@@ -103,6 +103,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       jni::local_ref<jni::JArrayClass<JNitroMapButton>> mapButtons = this->getFieldValue(fieldMapButtons);
       static const auto fieldHeaderActions = clazz->getField<jni::JArrayClass<JNitroAction>>("headerActions");
       jni::local_ref<jni::JArrayClass<JNitroAction>> headerActions = this->getFieldValue(fieldHeaderActions);
+      static const auto fieldDefaultGuidanceBackgroundColor = clazz->getField<JNitroColor>("defaultGuidanceBackgroundColor");
+      jni::local_ref<JNitroColor> defaultGuidanceBackgroundColor = this->getFieldValue(fieldDefaultGuidanceBackgroundColor);
       static const auto fieldPanButtonScrollPercentage = clazz->getField<jni::JDouble>("panButtonScrollPercentage");
       jni::local_ref<jni::JDouble> panButtonScrollPercentage = this->getFieldValue(fieldPanButtonScrollPercentage);
       static const auto fieldOnDidChangePanningInterface = clazz->getField<JFunc_void_bool::javaobject>("onDidChangePanningInterface");
@@ -239,6 +241,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
           }
           return __vector;
         }()) : std::nullopt,
+        defaultGuidanceBackgroundColor != nullptr ? std::make_optional(defaultGuidanceBackgroundColor->toCpp()) : std::nullopt,
         panButtonScrollPercentage != nullptr ? std::make_optional(panButtonScrollPercentage->value()) : std::nullopt,
         onDidChangePanningInterface != nullptr ? std::make_optional([&]() -> std::function<void(bool /* isPanningInterfaceVisible */)> {
           if (onDidChangePanningInterface->isInstanceOf(JFunc_void_bool_cxx::javaClassStatic())) [[likely]] {
@@ -258,7 +261,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
      */
     [[maybe_unused]]
     static jni::local_ref<JMapTemplateConfig::javaobject> fromCpp(const MapTemplateConfig& value) {
-      using JSignature = JMapTemplateConfig(jni::alias_ref<jni::JString>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JVisibleTravelEstimate>, jni::alias_ref<JFunc_void_Point_std__optional_Point_::javaobject>, jni::alias_ref<JFunc_void_Point_double::javaobject>, jni::alias_ref<JFunc_void_Point::javaobject>, jni::alias_ref<JFunc_void_Point::javaobject>, jni::alias_ref<JFunc_void_ColorScheme::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<jni::JArrayClass<JNitroMapButton>>, jni::alias_ref<jni::JArrayClass<JNitroAction>>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JFunc_void_bool::javaobject>);
+      using JSignature = JMapTemplateConfig(jni::alias_ref<jni::JString>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JVisibleTravelEstimate>, jni::alias_ref<JFunc_void_Point_std__optional_Point_::javaobject>, jni::alias_ref<JFunc_void_Point_double::javaobject>, jni::alias_ref<JFunc_void_Point::javaobject>, jni::alias_ref<JFunc_void_Point::javaobject>, jni::alias_ref<JFunc_void_ColorScheme::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<jni::JArrayClass<JNitroMapButton>>, jni::alias_ref<jni::JArrayClass<JNitroAction>>, jni::alias_ref<JNitroColor>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JFunc_void_bool::javaobject>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -298,6 +301,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
           }
           return __array;
         }() : nullptr,
+        value.defaultGuidanceBackgroundColor.has_value() ? JNitroColor::fromCpp(value.defaultGuidanceBackgroundColor.value()) : nullptr,
         value.panButtonScrollPercentage.has_value() ? jni::JDouble::valueOf(value.panButtonScrollPercentage.value()) : nullptr,
         value.onDidChangePanningInterface.has_value() ? JFunc_void_bool_cxx::fromCpp(value.onDidChangePanningInterface.value()) : nullptr
       );