@iternio/react-native-auto-play 0.0.11 → 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/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/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/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);