@iternio/react-native-auto-play 0.0.10 → 0.0.12

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

@@ -2,6 +2,7 @@ package com.margelo.nitro.swe.iternio.reactnativeautoplay
 
 import android.content.Intent
 import android.content.res.Configuration
+import android.util.Log
 import androidx.car.app.CarContext
 import androidx.car.app.Screen
 import androidx.car.app.Session
@@ -135,6 +136,63 @@ class AndroidAutoSession(sessionInfo: SessionInfo, private val reactApplication:
         AndroidAutoScreen.invalidateScreens()
     }
 
+    override fun onNewIntent(intent: Intent) {
+        val action = intent.action ?: return
+
+        if (action == CarContext.ACTION_NAVIGATE) {
+            intent.data?.schemeSpecificPart?.let { schemeSpecificPart ->
+                try {
+                    // Parse the geo URI format: lat,lon?q=query&mode=x&intent=y
+                    val queryIndex = schemeSpecificPart.indexOf("?q=")
+
+                    val location = if (queryIndex > 0) {
+                        val coordinatesPart = schemeSpecificPart.substring(0, queryIndex)
+                        parseCoordinates(coordinatesPart)
+                    } else {
+                        null
+                    }
+
+                    val query = if (queryIndex >= 0) {
+                        val queryPart = schemeSpecificPart.substring(queryIndex + 3) // Skip "?q="
+                        val additionalParamsIndex = queryPart.indexOf('&')
+
+                        if (additionalParamsIndex >= 0) {
+                            val rawQuery = queryPart.substring(0, additionalParamsIndex)
+                            java.net.URLDecoder.decode(rawQuery, "UTF-8")
+                        } else {
+                            java.net.URLDecoder.decode(queryPart, "UTF-8")
+                        }
+                    } else {
+                        java.net.URLDecoder.decode(schemeSpecificPart, "UTF-8")
+                    }
+
+                    HybridAutoPlay.emitVoiceInput(location, query)
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to parse navigation intent: ${e.message}")
+                }
+            }
+        }
+    }
+
+    /**
+     * Parses coordinates from a string in format "lat,lon".
+     * Returns null for invalid formats or 0,0 coordinates (which indicate "use geocoding").
+     */
+    private fun parseCoordinates(coordinatesPart: String): Location? {
+        val parts = coordinatesPart.split(",")
+        if (parts.size != 2) return null
+
+        val lat = parts[0].toDoubleOrNull() ?: return null
+        val lon = parts[1].toDoubleOrNull() ?: return null
+
+        // Treat 0,0 as "no coordinates" - it means use geocoding for the query
+        if (lat == 0.0 && lon == 0.0) {
+            return null
+        }
+
+        return Location(lat, lon)
+    }
+
     private val sessionLifecycleObserver = object : DefaultLifecycleObserver {
         override fun onCreate(owner: LifecycleOwner) {
             sessions[moduleName]?.state = VisibilityState.WILLAPPEAR
@@ -201,7 +259,7 @@ class AndroidAutoSession(sessionInfo: SessionInfo, private val reactApplication:
         }
 
         fun getCarContext(marker: String): CarContext? {
-            return sessions.get(marker)?.carContext
+            return sessions[marker]?.carContext
         }
 
         fun getRootContext(): CarContext? {

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

@@ -223,6 +223,16 @@ class HybridAutoPlay : HybridAutoPlaySpec() {
         }
     }
 
+
+
+    override fun addListenerVoiceInput(callback: (Location?, String?) -> Unit): () -> Unit {
+        voiceInputListeners.add(callback)
+
+        return {
+            voiceInputListeners.remove(callback)
+        }
+    }
+
     companion object {
         const val TAG = "HybridAutoPlay"
 
@@ -230,6 +240,9 @@ class HybridAutoPlay : HybridAutoPlaySpec() {
 
         private val renderStateListeners =
             mutableMapOf<String, MutableList<(VisibilityState) -> Unit>>()
+
+        private val voiceInputListeners = mutableListOf<(Location?, String?) -> Unit>()
+
         private val safeAreaInsetsListeners =
             mutableMapOf<String, MutableList<(SafeAreaInsets) -> Unit>>()
 
@@ -249,6 +262,12 @@ class HybridAutoPlay : HybridAutoPlaySpec() {
             }
         }
 
+        fun emitVoiceInput(location: Location?, query: String?) {
+            voiceInputListeners.forEach {
+                it(location, query)
+            }
+        }
+
         fun emitSafeAreaInsets(
             moduleName: String,
             top: Double,

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

@@ -86,10 +86,6 @@ class MapTemplate(
             if (isNavigating) {
                 navigationInfo?.let {
                     setNavigationInfo(it)
-                } ?: run {
-                    setNavigationInfo(RoutingInfo.Builder().apply {
-                        setLoading(true)
-                    }.build())
                 }
             }
             config.onDidChangePanningInterface?.let {
@@ -309,13 +305,19 @@ class MapTemplate(
 
             val routingInfo = maneuvers.asFirstOrNull()
             val messageInfo = maneuvers.asSecondOrNull()
+            val loadingInfo = maneuvers.asThirdOrNull()
 
-            if (routingInfo.isNullOrEmpty() && messageInfo == null) {
+            if (routingInfo.isNullOrEmpty() && messageInfo == null && loadingInfo == null) {
                 navigationInfo = null
                 AndroidAutoScreen.invalidateSurfaceScreens()
                 return
             }
 
+            if (loadingInfo != null) {
+                navigationInfo = RoutingInfo.Builder().setLoading(true).build()
+                return
+            }
+
             if (messageInfo != null) {
                 val backgroundColor =
                     if (context.isDarkMode) messageInfo.cardBackgroundColor.darkColor else messageInfo.cardBackgroundColor.lightColor
@@ -359,7 +361,9 @@ class MapTemplate(
 
                 val notificationText = currentStep.cue?.toString()
 
-                val notificationTitle = "${currentDistance.displayDistance.toInt()} ${Parser.parseDistanceUnit(currentDistance.displayUnit)}"
+                val notificationTitle = "${currentDistance.displayDistance.toInt()} ${
+                    Parser.parseDistanceUnit(currentDistance.displayUnit)
+                }"
 
                 it.notify(
                     notificationTitle, notificationText, notificationIcon

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

@@ -670,6 +670,9 @@ object Parser {
             setManeuver(parseManeuver(context, nitroManeuver))
             nitroManeuver.linkedLaneGuidance?.let { laneGuidance ->
                 val lanes = laneGuidance.lanes.mapNotNull { it.asFirstOrNull() }
+                if (lanes.isEmpty()) {
+                    return@let
+                }
                 lanes.forEach { lane ->
                     addLane(Lane.Builder().apply {
                         addDirection(

package/ios/hybrid/HybridAutoPlay.swift

@@ -107,6 +107,13 @@ class HybridAutoPlay: HybridAutoPlaySpec {
         }
     }
 
+    func addListenerVoiceInput(
+        callback: @escaping (Location?, String?) -> Void
+    ) throws -> () -> Void {
+        // TODO: Inplement voice input
+        return {}
+    }
+
     // MARK: set/push/pop templates
     func setRootTemplate(templateId: String) throws -> Promise<Void> {
         return Promise.async {

package/ios/hybrid/HybridMapTemplate.swift

@@ -29,7 +29,7 @@ class HybridMapTemplate: HybridMapTemplateSpec {
                     "\(templateId) is not a MapTemplate"
                 )
             }
-            
+
             await MainActor.run {
                 template.config.mapButtons = buttons
                 template.invalidate()
@@ -141,6 +141,13 @@ class HybridMapTemplate: HybridMapTemplateSpec {
                 {
                     template.updateManeuvers(messageManeuver: messageManeuver)
                 }()
+            case .third(let loadingManeuver):
+                {
+                    template.navigationSession?.pauseTrip(
+                        for: .loading,
+                        description: nil
+                    )
+                }()
             }
 
         }

package/ios/templates/MapTemplate.swift

@@ -182,9 +182,7 @@ class MapTemplate: NSObject, AutoPlayTemplate, AutoPlayHeaderProviding,
 
         template.tripEstimateStyle = isDark ? .dark : .light
 
-        DispatchQueue.main.async {
-            self.invalidate()
-        }
+        invalidate()
     }
 
     // MARK: gestures
@@ -502,9 +500,7 @@ class MapTemplate: NSObject, AutoPlayTemplate, AutoPlayHeaderProviding,
         onTripSelected = nil
         onTripStarted = nil
 
-        DispatchQueue.main.async {
-            self.invalidate()
-        }
+        invalidate()
     }
 
     func mapTemplate(
@@ -616,11 +612,16 @@ class MapTemplate: NSObject, AutoPlayTemplate, AutoPlayHeaderProviding,
     func updateManeuvers(maneuvers: [NitroRoutingManeuver]) {
         guard let navigationSession = navigationSession else { return }
 
+        if maneuvers.isEmpty {
+            navigationSession.upcomingManeuvers = []
+            return
+        }
+
         if #unavailable(iOS 15.4),
             let color = maneuvers.first?.cardBackgroundColor
         {
             // before iOS 15.4 the color had to be set on the template
-            // later on the maneuer which Parser.parseManeuver does
+            // later on the maneuver which Parser.parseManeuver does
             template.guidanceBackgroundColor = Parser.parseColor(color: color)
         }
 

package/lib/hooks/useVoiceInput.d.ts

@@ -0,0 +1,8 @@
+import { type Location } from '..';
+export declare const useVoiceInput: () => {
+    voiceInputResult: {
+        coordinates: Location | undefined;
+        query: string | undefined;
+    } | undefined;
+    resetVoiceInputResult: () => void;
+};

package/lib/hooks/useVoiceInput.js

@@ -0,0 +1,38 @@
+import { useCallback, useEffect, useState } from 'react';
+import { HybridAutoPlay } from '..';
+export const useVoiceInput = () => {
+    const [isConnected, setIsConnected] = useState(false);
+    const [voiceInputResult, setVoiceInputResult] = useState();
+    /**
+     * Resets the voice input result to undefined. This is useful when you want to clear the voice input result after processing it.
+     */
+    const resetVoiceInputResult = useCallback(() => {
+        setVoiceInputResult(undefined);
+    }, []);
+    useEffect(() => {
+        const removeDidConnect = HybridAutoPlay.addListener('didConnect', () => setIsConnected(true));
+        const removeDidDisconnect = HybridAutoPlay.addListener('didDisconnect', () => setIsConnected(false));
+        setIsConnected(HybridAutoPlay.isConnected());
+        return () => {
+            removeDidConnect();
+            removeDidDisconnect();
+        };
+    }, []);
+    useEffect(() => {
+        if (!isConnected) {
+            return;
+        }
+        const remove = HybridAutoPlay.addListenerVoiceInput((coordinates, query) => {
+            if (coordinates || query) {
+                setVoiceInputResult({ coordinates, query });
+            }
+            else {
+                setVoiceInputResult(undefined);
+            }
+        });
+        return () => {
+            remove();
+        };
+    }, [isConnected]);
+    return { voiceInputResult, resetVoiceInputResult };
+};

package/lib/index.d.ts

@@ -15,6 +15,7 @@ export * from './components/SafeAreaView';
 export * from './hooks/useAndroidAutoTelemetry';
 export * from './hooks/useMapTemplate';
 export * from './hooks/useSafeAreaInsets';
+export * from './hooks/useVoiceInput';
 export * from './scenes/AutoPlayCluster';
 export * from './scenes/CarPlayDashboardScene';
 export * from './templates/GridTemplate';

package/lib/index.js

@@ -20,6 +20,7 @@ export * from './components/SafeAreaView';
 export * from './hooks/useAndroidAutoTelemetry';
 export * from './hooks/useMapTemplate';
 export * from './hooks/useSafeAreaInsets';
+export * from './hooks/useVoiceInput';
 export * from './scenes/AutoPlayCluster';
 export * from './scenes/CarPlayDashboardScene';
 export * from './templates/GridTemplate';

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

@@ -1,6 +1,6 @@
 import type { HybridObject } from 'react-native-nitro-modules';
 import type { TemplateConfig } from '../templates/Template';
-import type { CleanupCallback, EventName, SafeAreaInsets, VisibilityState } from '../types/Event';
+import type { CleanupCallback, EventName, Location, SafeAreaInsets, VisibilityState } from '../types/Event';
 import type { NitroAction } from '../utils/NitroAction';
 export interface NitroTemplateConfig extends TemplateConfig {
     id: string;
@@ -23,6 +23,13 @@ export interface AutoPlay extends HybridObject<{
      * @param moduleName on of @AutoPlayModules, a cluster scene uuid or your main for the WindowApplicationSceneDelegate
      */
     addListenerRenderState(moduleName: string, callback: (payload: VisibilityState) => void): CleanupCallback;
+    /**
+     * Adds a listener for voice input events. Not implemented on iOS.
+     * @param callback the callback to receive the voice input
+     * @returns callback to remove the listener
+     * @namespace Android
+     */
+    addListenerVoiceInput(callback: (coordinates: Location | undefined, query: string | undefined) => void): CleanupCallback;
     /**
      * sets the specified template as root template, initializes a new stack
      * Promise might contain an error message in case setting root template failed

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

@@ -0,0 +1,8 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { CleanupCallback } from '../types/Event';
+export interface VoiceInput extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    registerVoiceInputListener(callback: (voiceInputResult?: string, error?: string) => void): CleanupCallback;
+}

package/lib/templates/MapTemplate.js

@@ -105,6 +105,10 @@ export class MapTemplate extends Template {
             HybridMapTemplate.updateManeuvers(this.id, nitroManeuvers);
             return;
         }
+        if (maneuvers.type === 'loading') {
+            HybridMapTemplate.updateManeuvers(this.id, { isLoading: true });
+            return;
+        }
         const messageManeuver = NitroManeuverUtil.convert(maneuvers);
         HybridMapTemplate.updateManeuvers(this.id, messageManeuver);
     }

package/lib/types/Event.d.ts

@@ -12,3 +12,7 @@ export type SafeAreaInsets = {
      */
     isLegacyLayout?: boolean;
 };
+export interface Location {
+    lat: number;
+    lon: number;
+}

package/lib/types/Maneuver.d.ts

@@ -196,7 +196,10 @@ export type MessageManeuver = {
     cardBackgroundColor: ThemedColor | string;
     type: 'message';
 };
+export type LoadingManeuver = {
+    type: 'loading';
+};
 export type AutoManeuver = (Array<RoutingManeuver> & {
-    length: 1 | 2;
-}) | MessageManeuver;
+    length: 0 | 1 | 2;
+}) | MessageManeuver | LoadingManeuver;
 export {};

package/lib/utils/NitroManeuver.d.ts

@@ -33,7 +33,10 @@ export interface NitroMessageManeuver {
     image?: NitroImage;
     cardBackgroundColor: NitroColor;
 }
-export type NitroManeuver = Array<NitroRoutingManeuver> | NitroMessageManeuver;
+interface NitroLoadingManeuver {
+    isLoading: true;
+}
+export type NitroManeuver = Array<NitroRoutingManeuver> | NitroMessageManeuver | NitroLoadingManeuver;
 declare function convert(autoManeuver: MessageManeuver): NitroMessageManeuver;
 declare function convert(autoManeuver: RoutingManeuver): NitroRoutingManeuver;
 export declare const NitroManeuverUtil: {

package/nitrogen/generated/android/ReactNativeAutoPlayOnLoad.cpp

@@ -20,6 +20,7 @@
 #include "JFunc_void_std__optional_Telemetry__std__optional_std__string_.hpp"
 #include "JHybridAutoPlaySpec.hpp"
 #include "JFunc_void_VisibilityState.hpp"
+#include "JFunc_void_std__optional_Location__std__optional_std__string_.hpp"
 #include "JFunc_void_SafeAreaInsets.hpp"
 #include "JHybridClusterSpec.hpp"
 #include "JFunc_void_std__string.hpp"
@@ -56,6 +57,7 @@ int initialize(JavaVM* vm) {
     margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_std__optional_Telemetry__std__optional_std__string__cxx::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JHybridAutoPlaySpec::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_VisibilityState_cxx::registerNatives();
+    margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_std__optional_Location__std__optional_std__string__cxx::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_SafeAreaInsets_cxx::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JHybridClusterSpec::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_std__string_cxx::registerNatives();

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

@@ -0,0 +1,78 @@
+///
+/// JFunc_void_std__optional_Location__std__optional_std__string_.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "Location.hpp"
+#include <optional>
+#include <string>
+#include <functional>
+#include "JLocation.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(coordinates: Location?, query: String?) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__optional_Location__std__optional_std__string_: public jni::JavaClass<JFunc_void_std__optional_Location__std__optional_std__string_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_std__optional_Location__std__optional_std__string_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__optional_Location__std__optional_std__string_` instance holds through JNI.
+     */
+    void invoke(const std::optional<Location>& coordinates, const std::optional<std::string>& query) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JLocation> /* coordinates */, jni::alias_ref<jni::JString> /* query */)>("invoke");
+      method(self(), coordinates.has_value() ? JLocation::fromCpp(coordinates.value()) : nullptr, query.has_value() ? jni::make_jstring(query.value()) : nullptr);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__optional_Location__std__optional_std__string_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_std__optional_Location__std__optional_std__string__cxx final: public jni::HybridClass<JFunc_void_std__optional_Location__std__optional_std__string__cxx, JFunc_void_std__optional_Location__std__optional_std__string_> {
+  public:
+    static jni::local_ref<JFunc_void_std__optional_Location__std__optional_std__string_::javaobject> fromCpp(const std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>& func) {
+      return JFunc_void_std__optional_Location__std__optional_std__string__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__optional_Location__std__optional_std__string__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JLocation> coordinates, jni::alias_ref<jni::JString> query) {
+      _func(coordinates != nullptr ? std::make_optional(coordinates->toCpp()) : std::nullopt, query != nullptr ? std::make_optional(query->toStdString()) : std::nullopt);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_std__optional_Location__std__optional_std__string__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__optional_Location__std__optional_std__string__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__optional_Location__std__optional_std__string__cxx(const std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)> _func;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -11,6 +11,8 @@
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class EventName; }
 // Forward declaration of `VisibilityState` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class VisibilityState; }
+// Forward declaration of `Location` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct Location; }
 // Forward declaration of `SafeAreaInsets` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct SafeAreaInsets; }
 // Forward declaration of `NitroAction` to properly resolve imports.
@@ -38,7 +40,10 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroBu
 #include "VisibilityState.hpp"
 #include "JFunc_void_VisibilityState.hpp"
 #include "JVisibilityState.hpp"
+#include "Location.hpp"
 #include <optional>
+#include "JFunc_void_std__optional_Location__std__optional_std__string_.hpp"
+#include "JLocation.hpp"
 #include "SafeAreaInsets.hpp"
 #include "JFunc_void_SafeAreaInsets.hpp"
 #include "JSafeAreaInsets.hpp"
@@ -122,6 +127,21 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       }
     }();
   }
+  std::function<void()> JHybridAutoPlaySpec::addListenerVoiceInput(const std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_std__optional_Location__std__optional_std__string_::javaobject> /* callback */)>("addListenerVoiceInput_cxx");
+    auto __result = method(_javaPart, JFunc_void_std__optional_Location__std__optional_std__string__cxx::fromCpp(callback));
+    return [&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return [__resultRef]() -> void {
+          return __resultRef->invoke();
+        };
+      }
+    }();
+  }
   std::shared_ptr<Promise<void>> JHybridAutoPlaySpec::setRootTemplate(const std::string& templateId) {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* templateId */)>("setRootTemplate");
     auto __result = method(_javaPart, jni::make_jstring(templateId));

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

@@ -56,6 +56,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     // Methods
     std::function<void()> addListener(EventName eventType, const std::function<void()>& callback) override;
     std::function<void()> addListenerRenderState(const std::string& moduleName, const std::function<void(VisibilityState /* payload */)>& callback) override;
+    std::function<void()> addListenerVoiceInput(const std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>& callback) override;
     std::shared_ptr<Promise<void>> setRootTemplate(const std::string& templateId) override;
     std::shared_ptr<Promise<void>> pushTemplate(const std::string& templateId) override;
     std::shared_ptr<Promise<void>> popTemplate(std::optional<bool> animate) override;

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

@@ -65,6 +65,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripPreview
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroRoutingManeuver; }
 // Forward declaration of `NitroMessageManeuver` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroMessageManeuver; }
+// Forward declaration of `NitroLoadingManeuver` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroLoadingManeuver; }
 // Forward declaration of `NitroAttributedString` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroAttributedString; }
 // Forward declaration of `NitroAttributedStringImage` to properly resolve imports.
@@ -167,6 +169,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig;
 #include "JFunc_void_std__string_std__string.hpp"
 #include "NitroRoutingManeuver.hpp"
 #include "NitroMessageManeuver.hpp"
+#include "NitroLoadingManeuver.hpp"
 #include "JNitroManeuver.hpp"
 #include "JNitroRoutingManeuver.hpp"
 #include "NitroAttributedString.hpp"
@@ -195,6 +198,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig;
 #include "ManeuverType.hpp"
 #include "JManeuverType.hpp"
 #include "JNitroMessageManeuver.hpp"
+#include "JNitroLoadingManeuver.hpp"
 #include "TripConfig.hpp"
 #include "JTripConfig.hpp"
 
@@ -314,7 +318,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       return __array;
     }());
   }
-  void JHybridMapTemplateSpec::updateManeuvers(const std::string& templateId, const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver>& maneuvers) {
+  void JHybridMapTemplateSpec::updateManeuvers(const std::string& templateId, const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver, NitroLoadingManeuver>& maneuvers) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* templateId */, jni::alias_ref<JNitroManeuver> /* maneuvers */)>("updateManeuvers");
     method(_javaPart, jni::make_jstring(templateId), JNitroManeuver::fromCpp(maneuvers));
   }

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

@@ -63,7 +63,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     std::shared_ptr<Promise<void>> setTemplateMapButtons(const std::string& templateId, const std::optional<std::vector<NitroMapButton>>& buttons) override;
     void updateVisibleTravelEstimate(const std::string& templateId, VisibleTravelEstimate visibleTravelEstimate) override;
     void updateTravelEstimates(const std::string& templateId, const std::vector<TripPoint>& steps) override;
-    void updateManeuvers(const std::string& templateId, const std::variant<std::vector<NitroRoutingManeuver>, NitroMessageManeuver>& maneuvers) override;
+    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;
 

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

@@ -0,0 +1,61 @@
+///
+/// JLocation.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "Location.hpp"
+
+
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "Location" and the the Kotlin data class "Location".
+   */
+  struct JLocation final: public jni::JavaClass<JLocation> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Location;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct Location by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Location toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldLat = clazz->getField<double>("lat");
+      double lat = this->getFieldValue(fieldLat);
+      static const auto fieldLon = clazz->getField<double>("lon");
+      double lon = this->getFieldValue(fieldLon);
+      return Location(
+        lat,
+        lon
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JLocation::javaobject> fromCpp(const Location& value) {
+      using JSignature = JLocation(double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.lat,
+        value.lon
+      );
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay