@iternio/react-native-auto-play 0.0.11 → 0.1.0

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/ios/ReactHelpers/NitroSurface.h

@@ -0,0 +1,10 @@
+//
+//  NitroSurface.h
+//  Pods
+//
+//  Created by Manuel Auer on 28.11.25.
+//
+
+@interface NitroSurface : NSObject
++ (void)stop:(nullable UIView *)view;
+@end

package/ios/ReactHelpers/NitroSurface.m

@@ -0,0 +1,51 @@
+//
+//  NitroSurface.m
+//  Pods
+//
+//  Created by Manuel Auer on 28.11.25.
+//
+
+#import "NitroSurface.h"
+#import <React/RCTInvalidating.h>
+#import <React/RCTRootView.h>
+#import <React/RCTSurface.h>
+#import <React/RCTSurfaceHostingProxyRootView.h>
+
+@implementation NitroSurface
+
++ (void)stop:(nullable UIView *)view {
+    if (view == nil) {
+        NSLog(@"[AutoPlay] View is nil, ignoring");
+        return;
+    }
+
+    if ([view isKindOfClass:[RCTSurfaceHostingProxyRootView class]]) {
+        RCTSurfaceHostingProxyRootView *rootView =
+            (RCTSurfaceHostingProxyRootView *)view;
+        RCTSurface *surface = rootView.surface;
+
+        if (surface == nil) {
+            NSLog(@"[AutoPlay] surface == nil, cannot stop");
+            return;
+        }
+
+        [surface stop];
+        return;
+    }
+    
+    if ([view isKindOfClass:[RCTRootView class]]) {
+        RCTRootView *rootView = (RCTRootView *)view;
+        UIView<RCTInvalidating> *contentView = (UIView<RCTInvalidating> *)rootView.contentView;
+        
+        if ([contentView conformsToProtocol:@protocol(RCTInvalidating)]) {
+            [contentView invalidate];
+        } else {
+            NSLog(@"[AutoPlay] contentView does not conform to RCTInvalidating");
+        }
+        return;
+    }
+
+    NSLog(@"[AutoPlay] View is not recognized type, ignoring");
+}
+
+@end

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/scenes/AutoPlayScene.swift

@@ -7,10 +7,6 @@
 
 import CarPlay
 
-#if RCT_NEW_ARCH_ENABLED
-    import React
-#endif
-
 class AutoPlayScene: UIResponder {
     var initialProperties: [String: Any] = [:]
     var moduleName: String?
@@ -46,22 +42,7 @@ class AutoPlayScene: UIResponder {
     }
 
     func disconnect() {
-        #if RCT_NEW_ARCH_ENABLED
-            if let rootView = self.window?.rootViewController?.view
-                as? RCTSurfaceHostingProxyRootView
-            {
-                rootView.surface.stop()
-            }
-        #else
-            if let rootView = self.window?.rootViewController?.view
-                as? RCTRootView
-            {
-                if let contentView = rootView.contentView as? RCTInvalidating {
-                    contentView.invalidate()
-                }
-            }
-        #endif
-
+        NitroSurface.stop(self.window?.rootViewController?.view)
         self.window = nil
         isConnected = false
 

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

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

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++/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

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

@@ -0,0 +1,80 @@
+///
+/// Func_void_std__optional_Location__std__optional_std__string_.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(coordinates: optional, query: optional) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_std__optional_Location__std__optional_std__string_: (Location?, String?) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(coordinates: Location?, query: String?): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(coordinates: optional, query: optional) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_std__optional_Location__std__optional_std__string__cxx: Func_void_std__optional_Location__std__optional_std__string_ {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(coordinates: Location?, query: String?): Unit
+    = invoke_cxx(coordinates,query)
+
+  @FastNative
+  private external fun invoke_cxx(coordinates: Location?, query: String?): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(coordinates: optional, query: optional) => void`.
+ * This is implemented in Java/Kotlin, via a `(Location?, String?) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_std__optional_Location__std__optional_std__string__java(private val function: (Location?, String?) -> Unit): Func_void_std__optional_Location__std__optional_std__string_ {
+  @DoNotStrip
+  @Keep
+  override fun invoke(coordinates: Location?, query: String?): Unit {
+    return this.function(coordinates, query)
+  }
+}

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

@@ -64,6 +64,15 @@ abstract class HybridAutoPlaySpec: HybridObject() {
     return Func_void_java(__result)
   }
   
+  abstract fun addListenerVoiceInput(callback: (coordinates: Location?, query: String?) -> Unit): () -> Unit
+  
+  @DoNotStrip
+  @Keep
+  private fun addListenerVoiceInput_cxx(callback: Func_void_std__optional_Location__std__optional_std__string_): Func_void {
+    val __result = addListenerVoiceInput(callback)
+    return Func_void_java(__result)
+  }
+  
   @DoNotStrip
   @Keep
   abstract fun setRootTemplate(templateId: String): Promise<Unit>

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

@@ -0,0 +1,41 @@
+///
+/// Location.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "Location".
+ */
+@DoNotStrip
+@Keep
+data class Location(
+  @DoNotStrip
+  @Keep
+  val lat: Double,
+  @DoNotStrip
+  @Keep
+  val lon: Double
+) {
+  /* primary constructor */
+
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(lat: Double, lon: Double): Location {
+      return Location(lat, lon)
+    }
+  }
+}

package/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Bridge.cpp

@@ -37,6 +37,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>
+  Func_void_std__optional_Location__std__optional_std__string_ create_Func_void_std__optional_Location__std__optional_std__string_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeAutoPlay::Func_void_std__optional_Location__std__optional_std__string_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::optional<Location>& coordinates, const std::optional<std::string>& query) mutable -> void {
+      swiftClosure.call(coordinates, query);
+    };
+  }
+  
   // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
   Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeAutoPlay::Func_void_std__exception_ptr::fromUnsafe(swiftClosureWrapper);

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

@@ -52,6 +52,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct ImageLane;
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class KeepType; }
 // Forward declaration of `LaneGuidance` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct LaneGuidance; }
+// Forward declaration of `Location` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct Location; }
 // Forward declaration of `ManeuverType` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ManeuverType; }
 // Forward declaration of `NavigationAlertAction` to properly resolve imports.
@@ -166,6 +168,7 @@ namespace ReactNativeAutoPlay { class HybridSearchTemplateSpec_cxx; }
 #include "ImageLane.hpp"
 #include "KeepType.hpp"
 #include "LaneGuidance.hpp"
+#include "Location.hpp"
 #include "ManeuverType.hpp"
 #include "NavigationAlertAction.hpp"
 #include "NitroAction.hpp"
@@ -262,6 +265,58 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     return Func_void_VisibilityState_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<Location>
+  /**
+   * Specialized version of `std::optional<Location>`.
+   */
+  using std__optional_Location_ = std::optional<Location>;
+  inline std::optional<Location> create_std__optional_Location_(const Location& value) noexcept {
+    return std::optional<Location>(value);
+  }
+  inline bool has_value_std__optional_Location_(const std::optional<Location>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline Location get_std__optional_Location_(const std::optional<Location>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<Location>&, const std::optional<std::string>&)>`.
+   */
+  using Func_void_std__optional_Location__std__optional_std__string_ = std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<Location>& / * coordinates * /, const std::optional<std::string>& / * query * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_Location__std__optional_std__string__Wrapper final {
+  public:
+    explicit Func_void_std__optional_Location__std__optional_std__string__Wrapper(std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>&& func): _function(std::make_unique<std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>>(std::move(func))) {}
+    inline void call(std::optional<Location> coordinates, std::optional<std::string> query) const noexcept {
+      _function->operator()(coordinates, query);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_Location__std__optional_std__string_ create_Func_void_std__optional_Location__std__optional_std__string_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_Location__std__optional_std__string__Wrapper wrap_Func_void_std__optional_Location__std__optional_std__string_(Func_void_std__optional_Location__std__optional_std__string_ value) noexcept {
+    return Func_void_std__optional_Location__std__optional_std__string__Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<void>>
   /**
    * Specialized version of `std::shared_ptr<Promise<void>>`.
@@ -333,21 +388,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     return Func_void_SafeAreaInsets_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<std::string>
-  /**
-   * Specialized version of `std::optional<std::string>`.
-   */
-  using std__optional_std__string_ = std::optional<std::string>;
-  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
-    return std::optional<std::string>(value);
-  }
-  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return *optional;
-  }
-  
   // pragma MARK: std::optional<double>
   /**
    * Specialized version of `std::optional<double>`.

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

@@ -62,6 +62,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class KeepTyp
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct LaneGuidance; }
 // Forward declaration of `ListTemplateConfig` to properly resolve imports.
 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 `ManeuverType` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ManeuverType; }
 // Forward declaration of `MapTemplateConfig` to properly resolve imports.
@@ -173,6 +175,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ZoomEve
 #include "KeepType.hpp"
 #include "LaneGuidance.hpp"
 #include "ListTemplateConfig.hpp"
+#include "Location.hpp"
 #include "ManeuverType.hpp"
 #include "MapTemplateConfig.hpp"
 #include "MessageTemplateConfig.hpp"

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

@@ -16,6 +16,8 @@ namespace ReactNativeAutoPlay { class HybridAutoPlaySpec_cxx; }
 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.
@@ -37,8 +39,9 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroBu
 #include "EventName.hpp"
 #include <string>
 #include "VisibilityState.hpp"
-#include <NitroModules/Promise.hpp>
+#include "Location.hpp"
 #include <optional>
+#include <NitroModules/Promise.hpp>
 #include "SafeAreaInsets.hpp"
 #include "NitroAction.hpp"
 #include <vector>
@@ -110,6 +113,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::function<void()> addListenerVoiceInput(const std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>& callback) override {
+      auto __result = _swiftPart.addListenerVoiceInput(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<void>> setRootTemplate(const std::string& templateId) override {
       auto __result = _swiftPart.setRootTemplate(templateId);
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/Func_void_std__optional_Location__std__optional_std__string_.swift

@@ -0,0 +1,54 @@
+///
+/// Func_void_std__optional_Location__std__optional_std__string_.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+
+/**
+ * Wraps a Swift `(_ coordinates: Location?, _ query: String?) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__optional_Location__std__optional_std__string_ {
+  public typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
+
+  private let closure: (_ coordinates: Location?, _ query: String?) -> Void
+
+  public init(_ closure: @escaping (_ coordinates: Location?, _ query: String?) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(coordinates: bridge.std__optional_Location_, query: bridge.std__optional_std__string_) -> Void {
+    self.closure(coordinates.value, { () -> String? in
+      if bridge.has_value_std__optional_std__string_(query) {
+        let __unwrapped = bridge.get_std__optional_std__string_(query)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }())
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__optional_Location__std__optional_std__string_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__optional_Location__std__optional_std__string_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__optional_Location__std__optional_std__string_ {
+    return Unmanaged<Func_void_std__optional_Location__std__optional_std__string_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridAutoPlaySpec.swift

@@ -17,6 +17,7 @@ public protocol HybridAutoPlaySpec_protocol: HybridObject {
   // Methods
   func addListener(eventType: EventName, callback: @escaping () -> Void) throws -> () -> Void
   func addListenerRenderState(moduleName: String, callback: @escaping (_ payload: VisibilityState) -> Void) throws -> () -> Void
+  func addListenerVoiceInput(callback: @escaping (_ coordinates: Location?, _ query: String?) -> Void) throws -> () -> Void
   func setRootTemplate(templateId: String) throws -> Promise<Void>
   func pushTemplate(templateId: String) throws -> Promise<Void>
   func popTemplate(animate: Bool?) throws -> Promise<Void>

package/nitrogen/generated/ios/swift/HybridAutoPlaySpec_cxx.swift

@@ -158,6 +158,38 @@ open class HybridAutoPlaySpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func addListenerVoiceInput(callback: bridge.Func_void_std__optional_Location__std__optional_std__string_) -> bridge.Result_std__function_void____ {
+    do {
+      let __result = try self.__implementation.addListenerVoiceInput(callback: { () -> (Location?, String?) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__optional_Location__std__optional_std__string_(callback)
+        return { (__coordinates: Location?, __query: String?) -> Void in
+          __wrappedFunction.call({ () -> bridge.std__optional_Location_ in
+            if let __unwrappedValue = __coordinates {
+              return bridge.create_std__optional_Location_(__unwrappedValue)
+            } else {
+              return .init()
+            }
+          }(), { () -> bridge.std__optional_std__string_ in
+            if let __unwrappedValue = __query {
+              return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+            } else {
+              return .init()
+            }
+          }())
+        }
+      }())
+      let __resultCpp = { () -> bridge.Func_void in
+        let __closureWrapper = Func_void(__result)
+        return bridge.create_Func_void(__closureWrapper.toUnsafe())
+      }()
+      return bridge.create_Result_std__function_void____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__function_void____(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func setRootTemplate(templateId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {

package/nitrogen/generated/ios/swift/Location.swift

@@ -0,0 +1,46 @@
+///
+/// Location.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `Location`, backed by a C++ struct.
+ */
+public typealias Location = margelo.nitro.swe.iternio.reactnativeautoplay.Location
+
+public extension Location {
+  private typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
+
+  /**
+   * Create a new instance of `Location`.
+   */
+  init(lat: Double, lon: Double) {
+    self.init(lat, lon)
+  }
+
+  var lat: Double {
+    @inline(__always)
+    get {
+      return self.__lat
+    }
+    @inline(__always)
+    set {
+      self.__lat = newValue
+    }
+  }
+  
+  var lon: Double {
+    @inline(__always)
+    get {
+      return self.__lon
+    }
+    @inline(__always)
+    set {
+      self.__lon = newValue
+    }
+  }
+}

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

@@ -16,6 +16,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("addListener", &HybridAutoPlaySpec::addListener);
       prototype.registerHybridMethod("addListenerRenderState", &HybridAutoPlaySpec::addListenerRenderState);
+      prototype.registerHybridMethod("addListenerVoiceInput", &HybridAutoPlaySpec::addListenerVoiceInput);
       prototype.registerHybridMethod("setRootTemplate", &HybridAutoPlaySpec::setRootTemplate);
       prototype.registerHybridMethod("pushTemplate", &HybridAutoPlaySpec::pushTemplate);
       prototype.registerHybridMethod("popTemplate", &HybridAutoPlaySpec::popTemplate);

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

@@ -17,6 +17,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.
@@ -26,8 +28,9 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroAction
 #include "EventName.hpp"
 #include <string>
 #include "VisibilityState.hpp"
-#include <NitroModules/Promise.hpp>
+#include "Location.hpp"
 #include <optional>
+#include <NitroModules/Promise.hpp>
 #include "SafeAreaInsets.hpp"
 #include "NitroAction.hpp"
 #include <vector>
@@ -65,6 +68,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       // Methods
       virtual std::function<void()> addListener(EventName eventType, const std::function<void()>& callback) = 0;
       virtual std::function<void()> addListenerRenderState(const std::string& moduleName, const std::function<void(VisibilityState /* payload */)>& callback) = 0;
+      virtual std::function<void()> addListenerVoiceInput(const std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>& callback) = 0;
       virtual std::shared_ptr<Promise<void>> setRootTemplate(const std::string& templateId) = 0;
       virtual std::shared_ptr<Promise<void>> pushTemplate(const std::string& templateId) = 0;
       virtual std::shared_ptr<Promise<void>> popTemplate(std::optional<bool> animate) = 0;

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

@@ -0,0 +1,79 @@
+///
+/// Location.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  /**
+   * A struct which can be represented as a JavaScript object (Location).
+   */
+  struct Location {
+  public:
+    double lat     SWIFT_PRIVATE;
+    double lon     SWIFT_PRIVATE;
+
+  public:
+    Location() = default;
+    explicit Location(double lat, double lon): lat(lat), lon(lon) {}
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
+
+namespace margelo::nitro {
+
+  // C++ Location <> JS Location (object)
+  template <>
+  struct JSIConverter<margelo::nitro::swe::iternio::reactnativeautoplay::Location> final {
+    static inline margelo::nitro::swe::iternio::reactnativeautoplay::Location fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::swe::iternio::reactnativeautoplay::Location(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "lat")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "lon"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::swe::iternio::reactnativeautoplay::Location& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "lat", JSIConverter<double>::toJSI(runtime, arg.lat));
+      obj.setProperty(runtime, "lon", JSIConverter<double>::toJSI(runtime, arg.lon));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "lat"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "lon"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

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

package/src/hooks/useVoiceInput.ts

@@ -0,0 +1,54 @@
+import { useCallback, useEffect, useState } from 'react';
+import { HybridAutoPlay, type Location } from '..';
+
+export const useVoiceInput = () => {
+  const [isConnected, setIsConnected] = useState(false);
+  const [voiceInputResult, setVoiceInputResult] = useState<
+    | {
+        coordinates: Location | undefined;
+        query: string | undefined;
+      }
+    | undefined
+  >();
+
+  /**
+   * 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/src/index.ts

@@ -27,6 +27,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/src/specs/AutoPlay.nitro.ts

@@ -1,6 +1,12 @@
 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 {
@@ -27,6 +33,16 @@ export interface AutoPlay extends HybridObject<{ android: 'kotlin'; ios: 'swift'
     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/src/types/Event.ts

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

package/ios/ReactHelpers/RCTRootView.h

@@ -1,29 +0,0 @@
-//
-//  RootView.h
-//  Pods
-//
-//  Created by Manuel Auer on 07.11.25.
-//
-
-// this is required for old architecture support since the React pod can not be imported
-
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#else
-
-#import <Foundation/Foundation.h>
-
-@protocol RCTInvalidating <NSObject>
-
-- (void)invalidate;
-
-@end
-
-@interface RCTRootView : UIView
-/**
- * The React-managed contents view of the root view.
- */
-@property(nonatomic, strong, readonly) UIView *contentView;
-@end
-
-#endif