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

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.0.12",
   "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/lib/specs/HybridAndroidAutoTelemetry.nitro.d.ts

@@ -1,15 +0,0 @@
-import type { HybridObject } from 'react-native-nitro-modules';
-import type { CleanupCallback } from '../types/Event';
-import type { Telemetry } from '../types/Telemetry';
-export interface HybridAndroidAutoTelemetry extends HybridObject<{
-    android: 'kotlin';
-}> {
-    /**
-     * Register a listener for Android Auto telemetry data. Should be registered only after the telemetry permissions are granted otherwise no data will be received.
-     * @param callback the callback to receive the telemetry data
-     * @param error the error message if the telemetry listener failed to start
-     * @returns callback to remove the listener
-     * @namespace Android
-     */
-    registerTelemetryListener(callback: (tlm?: Telemetry, error?: string) => void): CleanupCallback;
-}

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

@@ -1,64 +0,0 @@
-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 { NitroAction } from '../utils/NitroAction';
-export interface NitroTemplateConfig extends TemplateConfig {
-    id: string;
-}
-export interface HybridAutoPlay extends HybridObject<{
-    android: 'kotlin';
-    ios: 'swift';
-}> {
-    /**
-     * attach a listener for didConnect and didDisconnect
-     * @namespace all
-     * @param eventType generic events
-     * @returns callback to remove the listener
-     */
-    addListener(eventType: EventName, callback: () => void): CleanupCallback;
-    /**
-     * adds a listener for the session/scene state
-     * fires willAppear & didAppear when the scene/session is visible
-     * fires willDisappear & didDisappear when the scene/session is not visible
-     * @param moduleName on of @AutoPlayModules, a cluster scene uuid or your main for the WindowApplicationSceneDelegate
-     */
-    addListenerRenderState(moduleName: string, callback: (payload: VisibilityState) => 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
-     * can be used on any Android screen/iOS scene
-     */
-    setRootTemplate(templateId: string): Promise<void>;
-    /**
-     * push a template to the AutoPlayRoot Android screen/iOS scene
-     */
-    pushTemplate(templateId: string): Promise<void>;
-    /**
-     * remove the top template from the stack
-     * @param animate - defaults to true
-     */
-    popTemplate(animate?: boolean): Promise<void>;
-    /**
-     * remove all templates from the stack except the root template
-     * @param animate - defaults to true
-     */
-    popToRootTemplate(animate?: boolean): Promise<void>;
-    /**
-     * removes all templates until the specified one is the top template
-     */
-    popToTemplate(templateId: string, animate?: boolean): Promise<void>;
-    /**
-     * callback for safe area insets changes
-     * @param insets the insets that you use to determine the safe area for this view.
-     */
-    addSafeAreaInsetsListener(moduleName: string, callback: (insets: SafeAreaInsets) => void): CleanupCallback;
-    /**
-     * update a templates headerActions
-     */
-    setTemplateHeaderActions(templateId: string, headerActions?: Array<NitroAction>): void;
-    /**
-     * Check if AutoPlay is connected.
-     * @returns true if AutoPlay is connected, false otherwise.
-     */
-    isConnected(): boolean;
-}

package/lib/specs/HybridAutoPlay.nitro.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,22 +0,0 @@
-import type { HybridObject } from 'react-native-nitro-modules';
-import type { CleanupCallback, EventName } from '../types/Event';
-import type { ColorScheme } from '../types/RootComponent';
-import type { NitroImage } from '../utils/NitroImage';
-export interface BaseCarPlayDashboardButton {
-    titleVariants: Array<string>;
-    subtitleVariants: Array<string>;
-    onPress: () => void;
-    launchHeadUnitScene?: boolean;
-}
-interface NitroCarPlayDashboardButton extends BaseCarPlayDashboardButton {
-    image: NitroImage;
-}
-export interface HybridCarPlayDashboard extends HybridObject<{
-    ios: 'swift';
-}> {
-    addListener(eventType: EventName, callback: () => void): CleanupCallback;
-    setButtons(buttons: Array<NitroCarPlayDashboardButton>): Promise<void>;
-    initRootView(): void;
-    addListenerColorScheme(callback: (payload: ColorScheme) => void): CleanupCallback;
-}
-export {};

package/lib/specs/HybridCarPlayDashboard.nitro.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,19 +0,0 @@
-import type { HybridObject } from 'react-native-nitro-modules';
-import type { CleanupCallback } from '../types/Event';
-import type { ColorScheme } from '../types/RootComponent';
-import type { NitroAttributedString } from '../utils/NitroAttributedString';
-type ClusterEventName = 'didConnect' | 'didConnectWithWindow' | 'didDisconnect' | 'didDisconnectFromWindow';
-export type ZoomEvent = 'in' | 'out';
-export interface HybridCluster extends HybridObject<{
-    android: 'kotlin';
-    ios: 'swift';
-}> {
-    addListener(eventType: ClusterEventName, callback: (clusterId: string) => void): CleanupCallback;
-    initRootView(clusterId: string): Promise<void>;
-    setAttributedInactiveDescriptionVariants(clusterId: string, attributedInactiveDescriptionVariants: Array<NitroAttributedString>): void;
-    addListenerColorScheme(callback: (clusterId: string, payload: ColorScheme) => void): CleanupCallback;
-    addListenerZoom(callback: (clusterId: string, payload: ZoomEvent) => void): CleanupCallback;
-    addListenerCompass(callback: (clusterId: string, payload: boolean) => void): CleanupCallback;
-    addListenerSpeedLimit(callback: (clusterId: string, payload: boolean) => void): CleanupCallback;
-}
-export {};