@iternio/react-native-auto-play 0.4.8 → 0.4.11

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

@@ -52,8 +52,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { class HybridMapTem
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { class HybridMessageTemplateSpec; }
 // Forward declaration of `HybridSearchTemplateSpec` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { class HybridSearchTemplateSpec; }
-// Forward declaration of `HybridVoiceSpec` to properly resolve imports.
-namespace margelo::nitro::swe::iternio::reactnativeautoplay { class HybridVoiceSpec; }
 // Forward declaration of `ImageLane` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct ImageLane; }
 // Forward declaration of `InformationTemplateConfig` to properly resolve imports.
@@ -150,10 +148,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class TurnTyp
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class VisibilityState; }
 // Forward declaration of `VisibleTravelEstimate` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class VisibleTravelEstimate; }
-// Forward declaration of `VoiceInputChunk` to properly resolve imports.
-namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputChunk; }
-// Forward declaration of `VoiceInputResult` to properly resolve imports.
-namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputResult; }
 // Forward declaration of `ZoomEvent` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ZoomEvent; }
 
@@ -180,7 +174,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ZoomEve
 #include "HybridMapTemplateSpec.hpp"
 #include "HybridMessageTemplateSpec.hpp"
 #include "HybridSearchTemplateSpec.hpp"
-#include "HybridVoiceSpec.hpp"
 #include "ImageLane.hpp"
 #include "InformationTemplateConfig.hpp"
 #include "KeepType.hpp"
@@ -229,8 +222,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ZoomEve
 #include "TurnType.hpp"
 #include "VisibilityState.hpp"
 #include "VisibleTravelEstimate.hpp"
-#include "VoiceInputChunk.hpp"
-#include "VoiceInputResult.hpp"
 #include "ZoomEvent.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/Promise.hpp>
@@ -271,8 +262,6 @@ namespace ReactNativeAutoPlay { class HybridMapTemplateSpec_cxx; }
 namespace ReactNativeAutoPlay { class HybridMessageTemplateSpec_cxx; }
 // Forward declaration of `HybridSearchTemplateSpec_cxx` to properly resolve imports.
 namespace ReactNativeAutoPlay { class HybridSearchTemplateSpec_cxx; }
-// Forward declaration of `HybridVoiceSpec_cxx` to properly resolve imports.
-namespace ReactNativeAutoPlay { class HybridVoiceSpec_cxx; }
 
 // Include Swift defined types
 #if __has_include("ReactNativeAutoPlay-Swift.h")

package/nitrogen/generated/ios/ReactNativeAutoPlayAutolinking.mm

@@ -10,7 +10,6 @@
 #import "ReactNativeAutoPlay-Swift-Cxx-Umbrella.hpp"
 #import <type_traits>
 
-#include "HybridVoiceSpecSwift.hpp"
 #include "HybridAutoPlaySpecSwift.hpp"
 #include "HybridListTemplateSpecSwift.hpp"
 #include "HybridInformationTemplateSpecSwift.hpp"
@@ -30,13 +29,6 @@
   using namespace margelo::nitro;
   using namespace margelo::nitro::swe::iternio::reactnativeautoplay;
 
-  HybridObjectRegistry::registerHybridObjectConstructor(
-    "Voice",
-    []() -> std::shared_ptr<HybridObject> {
-      std::shared_ptr<HybridVoiceSpec> hybridObject = ReactNativeAutoPlay::ReactNativeAutoPlayAutolinking::createVoice();
-      return hybridObject;
-    }
-  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "AutoPlay",
     []() -> std::shared_ptr<HybridObject> {

package/nitrogen/generated/ios/ReactNativeAutoPlayAutolinking.swift

@@ -12,18 +12,6 @@ import NitroModules
 public final class ReactNativeAutoPlayAutolinking {
   public typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
 
-  public static func createVoice() -> bridge.std__shared_ptr_HybridVoiceSpec_ {
-    let hybridObject = HybridVoice()
-    return { () -> bridge.std__shared_ptr_HybridVoiceSpec_ in
-      let __cxxWrapped = hybridObject.getCxxWrapper()
-      return __cxxWrapped.getCxxPart()
-    }()
-  }
-  
-  public static func isVoiceRecyclable() -> Bool {
-    return HybridVoice.self is any RecyclableView.Type
-  }
-  
   public static func createAutoPlay() -> bridge.std__shared_ptr_HybridAutoPlaySpec_ {
     let hybridObject = HybridAutoPlay()
     return { () -> bridge.std__shared_ptr_HybridAutoPlaySpec_ in

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

@@ -18,6 +18,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class EventNa
 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 `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
 // Forward declaration of `SafeAreaInsets` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct SafeAreaInsets; }
 // Forward declaration of `NitroAction` to properly resolve imports.
@@ -44,6 +46,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroBu
 #include "Location.hpp"
 #include <optional>
 #include <NitroModules/Promise.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
 #include "SafeAreaInsets.hpp"
 #include "NitroAction.hpp"
 #include <vector>
@@ -130,6 +134,36 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline bool hasVoiceInputPermission() override {
+      auto __result = _swiftPart.hasVoiceInputPermission();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> requestVoiceInputPermission() override {
+      auto __result = _swiftPart.requestVoiceInputPermission();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText) override {
+      auto __result = _swiftPart.startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void stopVoiceInput() override {
+      auto __result = _swiftPart.stopVoiceInput();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline std::shared_ptr<Promise<void>> setRootTemplate(const std::string& templateId) override {
       auto __result = _swiftPart.setRootTemplate(templateId);
       if (__result.hasError()) [[unlikely]] {
@@ -194,6 +228,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline bool isCarServiceRunning() override {
+      auto __result = _swiftPart.isCarServiceRunning();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     ReactNativeAutoPlay::HybridAutoPlaySpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/Func_void_bool.swift

@@ -8,21 +8,21 @@
 import NitroModules
 
 /**
- * Wraps a Swift `(_ value: Bool) -> Void` as a class.
+ * Wraps a Swift `(_ isPanningInterfaceVisible: Bool) -> 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_bool {
   public typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
 
-  private let closure: (_ value: Bool) -> Void
+  private let closure: (_ isPanningInterfaceVisible: Bool) -> Void
 
-  public init(_ closure: @escaping (_ value: Bool) -> Void) {
+  public init(_ closure: @escaping (_ isPanningInterfaceVisible: Bool) -> Void) {
     self.closure = closure
   }
 
   @inline(__always)
-  public func call(value: Bool) -> Void {
-    self.closure(value)
+  public func call(isPanningInterfaceVisible: Bool) -> Void {
+    self.closure(isPanningInterfaceVisible)
   }
 
   /**

package/nitrogen/generated/ios/swift/{Func_void_VoiceInputResult.swift → Func_void_std__shared_ptr_ArrayBuffer_.swift}

@@ -1,5 +1,5 @@
 ///
-/// Func_void_VoiceInputResult.swift
+/// Func_void_std__shared_ptr_ArrayBuffer_.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -8,20 +8,20 @@
 import NitroModules
 
 /**
- * Wraps a Swift `(_ value: VoiceInputResult) -> Void` as a class.
+ * Wraps a Swift `(_ value: ArrayBuffer) -> 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_VoiceInputResult {
+public final class Func_void_std__shared_ptr_ArrayBuffer_ {
   public typealias bridge = margelo.nitro.swe.iternio.reactnativeautoplay.bridge.swift
 
-  private let closure: (_ value: VoiceInputResult) -> Void
+  private let closure: (_ value: ArrayBuffer) -> Void
 
-  public init(_ closure: @escaping (_ value: VoiceInputResult) -> Void) {
+  public init(_ closure: @escaping (_ value: ArrayBuffer) -> Void) {
     self.closure = closure
   }
 
   @inline(__always)
-  public func call(value: VoiceInputResult) -> Void {
+  public func call(value: ArrayBuffer) -> Void {
     self.closure(value)
   }
 
@@ -35,12 +35,12 @@ public final class Func_void_VoiceInputResult {
   }
 
   /**
-   * Casts an unsafe pointer to a `Func_void_VoiceInputResult`.
-   * The pointer has to be a retained opaque `Unmanaged<Func_void_VoiceInputResult>`.
+   * Casts an unsafe pointer to a `Func_void_std__shared_ptr_ArrayBuffer_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__shared_ptr_ArrayBuffer_>`.
    * This removes one strong reference from the object!
    */
   @inline(__always)
-  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_VoiceInputResult {
-    return Unmanaged<Func_void_VoiceInputResult>.fromOpaque(pointer).takeRetainedValue()
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__shared_ptr_ArrayBuffer_ {
+    return Unmanaged<Func_void_std__shared_ptr_ArrayBuffer_>.fromOpaque(pointer).takeRetainedValue()
   }
 }

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

@@ -16,6 +16,10 @@ public protocol HybridAutoPlaySpec_protocol: HybridObject {
   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 hasVoiceInputPermission() throws -> Bool
+  func requestVoiceInputPermission() throws -> Promise<Bool>
+  func startVoiceInput(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?) throws -> Promise<ArrayBuffer>
+  func stopVoiceInput() throws -> Void
   func setRootTemplate(templateId: String) throws -> Promise<Void>
   func pushTemplate(templateId: String) throws -> Promise<Void>
   func popTemplate(animate: Bool?) throws -> Promise<Void>
@@ -24,6 +28,7 @@ public protocol HybridAutoPlaySpec_protocol: HybridObject {
   func addSafeAreaInsetsListener(moduleName: String, callback: @escaping (_ insets: SafeAreaInsets) -> Void) throws -> () -> Void
   func setTemplateHeaderActions(templateId: String, headerActions: [NitroAction]?) throws -> Promise<Void>
   func isConnected() throws -> Bool
+  func isCarServiceRunning() throws -> Bool
 }
 
 public extension HybridAutoPlaySpec_protocol {

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

@@ -196,6 +196,88 @@ open class HybridAutoPlaySpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func hasVoiceInputPermission() -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.hasVoiceInputPermission()
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func requestVoiceInputPermission() -> bridge.Result_std__shared_ptr_Promise_bool___ {
+    do {
+      let __result = try self.__implementation.requestVoiceInputPermission()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func startVoiceInput(silenceThresholdMs: bridge.std__optional_double_, maxDurationMs: bridge.std__optional_double_, listeningText: bridge.std__optional_std__string_) -> bridge.Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ {
+    do {
+      let __result = try self.__implementation.startVoiceInput(silenceThresholdMs: { () -> Double? in
+        if bridge.has_value_std__optional_double_(silenceThresholdMs) {
+          let __unwrapped = bridge.get_std__optional_double_(silenceThresholdMs)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }(), maxDurationMs: { () -> Double? in
+        if bridge.has_value_std__optional_double_(maxDurationMs) {
+          let __unwrapped = bridge.get_std__optional_double_(maxDurationMs)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }(), listeningText: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(listeningText) {
+          let __unwrapped = bridge.get_std__optional_std__string_(listeningText)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }())
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result.getArrayBuffer()) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func stopVoiceInput() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.stopVoiceInput()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func setRootTemplate(templateId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
@@ -369,4 +451,16 @@ open class HybridAutoPlaySpec_cxx {
       return bridge.create_Result_bool_(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func isCarServiceRunning() -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.isCarServiceRunning()
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/ios/swift/NitroImage.swift

@@ -17,3 +17,16 @@ public indirect enum NitroImage {
   case second(AssetImage)
   case third(RemoteImage)
 }
+
+public extension NitroImage {
+  func asType<T>(_ type: T.Type = T.self) -> T? {
+    switch self {
+      case .first(let value): return value as? T
+      case .second(let value): return value as? T
+      case .third(let value): return value as? T
+    }
+  }
+  func isType<T>(_ type: T.Type = T.self) -> Bool {
+    return self.asType(type) != nil
+  }
+}

package/nitrogen/generated/ios/swift/NitroManeuver.swift

@@ -17,3 +17,16 @@ public indirect enum NitroManeuver {
   case second(NitroMessageManeuver)
   case third(NitroLoadingManeuver)
 }
+
+public extension NitroManeuver {
+  func asType<T>(_ type: T.Type = T.self) -> T? {
+    switch self {
+      case .first(let value): return value as? T
+      case .second(let value): return value as? T
+      case .third(let value): return value as? T
+    }
+  }
+  func isType<T>(_ type: T.Type = T.self) -> Bool {
+    return self.asType(type) != nil
+  }
+}

package/nitrogen/generated/ios/swift/Variant_GlyphImage_AssetImage_RemoteImage.swift

@@ -17,3 +17,16 @@ public indirect enum Variant_GlyphImage_AssetImage_RemoteImage {
   case second(AssetImage)
   case third(RemoteImage)
 }
+
+public extension Variant_GlyphImage_AssetImage_RemoteImage {
+  func asType<T>(_ type: T.Type = T.self) -> T? {
+    switch self {
+      case .first(let value): return value as? T
+      case .second(let value): return value as? T
+      case .third(let value): return value as? T
+    }
+  }
+  func isType<T>(_ type: T.Type = T.self) -> Bool {
+    return self.asType(type) != nil
+  }
+}

package/nitrogen/generated/ios/swift/Variant_PreferredImageLane_ImageLane.swift

@@ -16,3 +16,15 @@ public indirect enum Variant_PreferredImageLane_ImageLane {
   case first(PreferredImageLane)
   case second(ImageLane)
 }
+
+public extension Variant_PreferredImageLane_ImageLane {
+  func asType<T>(_ type: T.Type = T.self) -> T? {
+    switch self {
+      case .first(let value): return value as? T
+      case .second(let value): return value as? T
+    }
+  }
+  func isType<T>(_ type: T.Type = T.self) -> Bool {
+    return self.asType(type) != nil
+  }
+}

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

@@ -17,6 +17,10 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       prototype.registerHybridMethod("addListener", &HybridAutoPlaySpec::addListener);
       prototype.registerHybridMethod("addListenerRenderState", &HybridAutoPlaySpec::addListenerRenderState);
       prototype.registerHybridMethod("addListenerVoiceInput", &HybridAutoPlaySpec::addListenerVoiceInput);
+      prototype.registerHybridMethod("hasVoiceInputPermission", &HybridAutoPlaySpec::hasVoiceInputPermission);
+      prototype.registerHybridMethod("requestVoiceInputPermission", &HybridAutoPlaySpec::requestVoiceInputPermission);
+      prototype.registerHybridMethod("startVoiceInput", &HybridAutoPlaySpec::startVoiceInput);
+      prototype.registerHybridMethod("stopVoiceInput", &HybridAutoPlaySpec::stopVoiceInput);
       prototype.registerHybridMethod("setRootTemplate", &HybridAutoPlaySpec::setRootTemplate);
       prototype.registerHybridMethod("pushTemplate", &HybridAutoPlaySpec::pushTemplate);
       prototype.registerHybridMethod("popTemplate", &HybridAutoPlaySpec::popTemplate);
@@ -25,6 +29,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       prototype.registerHybridMethod("addSafeAreaInsetsListener", &HybridAutoPlaySpec::addSafeAreaInsetsListener);
       prototype.registerHybridMethod("setTemplateHeaderActions", &HybridAutoPlaySpec::setTemplateHeaderActions);
       prototype.registerHybridMethod("isConnected", &HybridAutoPlaySpec::isConnected);
+      prototype.registerHybridMethod("isCarServiceRunning", &HybridAutoPlaySpec::isCarServiceRunning);
     });
   }
 

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

@@ -31,6 +31,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroAction
 #include "Location.hpp"
 #include <optional>
 #include <NitroModules/Promise.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
 #include "SafeAreaInsets.hpp"
 #include "NitroAction.hpp"
 #include <vector>
@@ -69,6 +70,10 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       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 bool hasVoiceInputPermission() = 0;
+      virtual std::shared_ptr<Promise<bool>> requestVoiceInputPermission() = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText) = 0;
+      virtual void stopVoiceInput() = 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;
@@ -77,6 +82,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       virtual std::function<void()> addSafeAreaInsetsListener(const std::string& moduleName, const std::function<void(const SafeAreaInsets& /* insets */)>& callback) = 0;
       virtual std::shared_ptr<Promise<void>> setTemplateHeaderActions(const std::string& templateId, const std::optional<std::vector<NitroAction>>& headerActions) = 0;
       virtual bool isConnected() = 0;
+      virtual bool isCarServiceRunning() = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iternio/react-native-auto-play",
-  "version": "0.4.8",
+  "version": "0.4.11",
   "description": "Android Auto and Apple CarPlay for react-native",
   "main": "lib/index",
   "module": "lib/index",
@@ -61,7 +61,7 @@
     "@types/jest": "^29.5.12",
     "@types/react": "~19.2.0",
     "dpdm": "^4.0.1",
-    "nitrogen": "^0.35.3",
+    "nitrogen": "^0.35.9",
     "typescript": "^5.8.3"
   },
   "peerDependencies": {

package/src/index.ts

@@ -3,12 +3,11 @@ import { NitroModules } from 'react-native-nitro-modules';
 import AutoPlayHeadlessJsTask from './AutoPlayHeadlessJsTask';
 import { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
 import { HybridAutoPlay } from './hybrid/HybridAutoPlay';
-import { HybridVoice } from './hybrid/HybridVoice';
 import type { AndroidAutomotive } from './specs/AndroidAutomotive.nitro';
 
 AutoPlayHeadlessJsTask.registerHeadlessTask(HybridAutoPlay);
 
-export { HybridAndroidAutoTelemetry, HybridAutoPlay, HybridVoice };
+export { HybridAndroidAutoTelemetry, HybridAutoPlay };
 
 export const HybridAndroidAutomotive =
   Platform.OS === 'android'
@@ -55,7 +54,6 @@ export * from './types/SignInMethod';
 export * from './types/Telemetry';
 export * from './types/Text';
 export * from './types/Trip';
-export type { VoiceInputChunk, VoiceInputOptions, VoiceInputResult } from './types/Voice';
 export type {
   AlertPriority,
   NavigationAlert as Alert,

package/src/scenes/CarPlayDashboardScene.ts

@@ -25,6 +25,7 @@ export type CarPlayDashboardEvent = EventName | VisibilityState;
 
 class Dashboard {
   private component: React.ComponentType<RootComponentInitialProps> | null = null;
+  private componentRegistered = false;
   public isConnected = false;
   public readonly id = 'CarPlayDashboard';
 
@@ -47,20 +48,26 @@ class Dashboard {
     }
 
     const { component, isConnected } = this;
-    if (!isConnected || component == null) {
+    if (component == null) {
       return;
     }
 
-    AppRegistry.registerComponent(
-      this.id,
-      () => (props) =>
-        React.createElement(SafeAreaInsetsProvider, {
-          moduleName: this.id,
-          // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
-          children: React.createElement(component, props),
-        })
-    );
-    HybridCarPlayDashboard.initRootView();
+    if (!this.componentRegistered) {
+      AppRegistry.registerComponent(
+        this.id,
+        () => (props) =>
+          React.createElement(SafeAreaInsetsProvider, {
+            moduleName: this.id,
+            // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
+            children: React.createElement(component, props),
+          })
+      );
+      this.componentRegistered = true;
+    }
+
+    if (isConnected) {
+      HybridCarPlayDashboard.initRootView();
+    }
   }
 
   public setComponent(component: React.ComponentType<RootComponentInitialProps>) {

package/src/specs/AutoPlay.nitro.ts

@@ -44,6 +44,43 @@ export interface AutoPlay extends HybridObject<{ android: 'kotlin'; ios: 'swift'
     callback: (coordinates: Location | undefined, query: string | undefined) => void
   ): CleanupCallback;
 
+  /**
+   * Returns true if microphone permission has already been granted.
+   */
+  hasVoiceInputPermission(): boolean;
+
+  /**
+   * Request microphone permission from the user.
+   * On Android: uses the car context when Android Auto is connected, otherwise
+   * falls back to the React Native application context.
+   * On iOS: uses AVAudioApplication (iOS 17+) or AVAudioSession (iOS 15–16).
+   * Returns true if permission was granted, false if denied.
+   */
+  requestVoiceInputPermission(): Promise<boolean>;
+
+  /**
+   * Start an in-app voice recording session.
+   * On Android: acquires audio focus and captures via CarAudioRecord when
+   * Android Auto is connected, otherwise uses standard AudioRecord.
+   * On iOS: presents CPVoiceControlTemplate (when a car is connected) and
+   * captures audio via AVAudioEngine.
+   * Resolves with the complete raw PCM buffer (16 kHz, 16-bit, mono) when
+   * silence is detected, the max duration is reached, or stopVoiceInput() is called.
+   * Rejects if microphone permission has not been granted or recording fails to start.
+   */
+  startVoiceInput(
+    silenceThresholdMs?: number,
+    maxDurationMs?: number,
+    listeningText?: string
+  ): Promise<ArrayBuffer>;
+
+  /**
+   * Stop the active voice recording session early. Causes the Promise returned
+   * by startVoiceInput() to resolve with the audio captured so far.
+   * No-op if no recording is in progress.
+   */
+  stopVoiceInput(): void;
+
   /**
    * sets the specified template as root template, initializes a new stack
    * Promise might contain an error message in case setting root template failed
@@ -92,4 +129,11 @@ export interface AutoPlay extends HybridObject<{ android: 'kotlin'; ios: 'swift'
    * @returns true if AutoPlay is connected, false otherwise.
    */
   isConnected(): boolean;
+
+  /**
+   * Check if the native AutoPlay is currently running.
+   * Use this to distinguish a headless execution triggered by AA / CP
+   * from one triggered by other sources (e.g. notification updates).
+   */
+  isCarServiceRunning(): boolean;
 }