@iternio/react-native-auto-play 0.4.2 → 0.4.3

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 {

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);

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;

package/package.json

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

package/src/hooks/useAndroidAutoTelemetry.ts

@@ -131,14 +131,19 @@ export const useAndroidAutoTelemetry = ({
         automotivePermissionRequest.message,
         automotivePermissionRequest.grantButtonText,
         automotivePermissionRequest.cancelButtonText
-      ).then(({ granted, denied }) => {
-        const isGranted = granted.length === requiredPermissions.length;
-        setPermissionsGranted(isGranted);
-
-        if (!isGranted) {
-          setError(`Android Automotive permissions denied: [${denied.join(',')}]`);
-        }
-      });
+      )
+        .then(({ granted, denied }) => {
+          const isGranted = granted.length === requiredPermissions.length;
+          setPermissionsGranted(isGranted);
+
+          if (!isGranted) {
+            setError(`Android Automotive permissions denied: [${denied.join(',')}]`);
+          }
+        })
+        .catch((e) => {
+          const message = e instanceof Error ? e.message : String(e);
+          setError(message);
+        });
       return;
     }
 

package/src/index.ts

@@ -3,14 +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 { HybridAutoPlay };
-export { HybridVoice };
-export { HybridAndroidAutoTelemetry };
+export { HybridAndroidAutoTelemetry, HybridAutoPlay };
 
 export const HybridAndroidAutomotive =
   Platform.OS === 'android'
@@ -57,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/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

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

@@ -1,95 +0,0 @@
-package com.margelo.nitro.swe.iternio.reactnativeautoplay
-
-import android.content.pm.PackageManager
-import android.os.Build
-import androidx.core.content.ContextCompat
-import com.facebook.react.modules.core.PermissionAwareActivity
-import com.facebook.react.modules.core.PermissionListener
-import com.margelo.nitro.NitroModules
-import com.margelo.nitro.core.Promise
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlin.coroutines.resume
-
-class HybridVoice : HybridVoiceSpec() {
-    @Volatile
-    private var voiceInputManager: VoiceInputManager? = null
-
-    override fun hasVoiceInputPermission(): Boolean {
-        return VoiceInputManager.hasVoiceInputPermission()
-    }
-
-    override fun requestVoiceInputPermission(): Promise<Boolean> {
-        return Promise.async {
-            if (hasVoiceInputPermission()) {
-                return@async true
-            }
-
-            val carContext = AndroidAutoSession.getRootContext()
-
-            if (carContext != null) {
-                suspendCancellableCoroutine { cont ->
-                    carContext.requestPermissions(
-                        listOf(android.Manifest.permission.RECORD_AUDIO)
-                    ) { approved, _ ->
-                        cont.resume(approved.contains(android.Manifest.permission.RECORD_AUDIO))
-                    }
-                }
-            } else {
-                val context = NitroModules.applicationContext ?: return@async false
-                val activity =
-                    context.currentActivity as? PermissionAwareActivity ?: return@async false
-                val code = (Math.random() * 10000).toInt()
-
-                suspendCancellableCoroutine { cont ->
-                    activity.requestPermissions(
-                        arrayOf(android.Manifest.permission.RECORD_AUDIO),
-                        code,
-                        PermissionListener { requestCode, _, grantResults ->
-                            if (requestCode != code) {
-                                return@PermissionListener false
-                            }
-                            cont.resume(
-                                grantResults.isNotEmpty() &&
-                                    grantResults.first() == PackageManager.PERMISSION_GRANTED
-                            )
-                            true
-                        }
-                    )
-                }
-            }
-        }
-    }
-
-    override fun startVoiceInput(
-        silenceThresholdMs: Double?,
-        maxDurationMs: Double?,
-        listeningText: String?,
-        preferSpeechToText: Boolean?,
-        onChunk: ((chunk: VoiceInputChunk) -> Unit)?,
-    ): Promise<VoiceInputResult> {
-        return Promise.async {
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-                throw UnsupportedOperationException("startVoiceInput requires at least API level ${Build.VERSION_CODES.O}")
-            }
-
-            val manager = VoiceInputManager(AndroidAutoSession.getRootContext())
-            voiceInputManager = manager
-
-            try {
-                manager.start(
-                    silenceThresholdMs = silenceThresholdMs?.toLong() ?: 1_500L,
-                    maxDurationMs = maxDurationMs?.toLong() ?: 10_000L,
-                    preferSpeechToText = preferSpeechToText ?: false,
-                    onChunk = onChunk,
-                )
-            } finally {
-                voiceInputManager = null
-                manager.dispose()
-            }
-        }
-    }
-
-    override fun stopVoiceInput() {
-        voiceInputManager?.stop()
-    }
-}

package/ios/hybrid/HybridVoice.swift

@@ -1,63 +0,0 @@
-import AVFoundation
-import NitroModules
-import Speech
-
-class HybridVoice: HybridVoiceSpec {
-    private var voiceInputManager: VoiceInputManager?
-
-    func hasVoiceInputPermission() throws -> Bool {
-        let micGranted = AVAudioSession.sharedInstance().recordPermission == .granted
-        let speechGranted = SFSpeechRecognizer.authorizationStatus() == .authorized
-        return micGranted && speechGranted
-    }
-
-    func requestVoiceInputPermission() throws -> Promise<Bool> {
-        return Promise.async {
-            let micGranted = await withCheckedContinuation { cont in
-                AVAudioSession.sharedInstance().requestRecordPermission { granted in
-                    cont.resume(returning: granted)
-                }
-            }
-            guard micGranted else { return false }
-
-            return await withCheckedContinuation { cont in
-                SFSpeechRecognizer.requestAuthorization { status in
-                    cont.resume(returning: status == .authorized)
-                }
-            }
-        }
-    }
-
-    func startVoiceInput(
-        silenceThresholdMs: Double?,
-        maxDurationMs: Double?,
-        listeningText: String?,
-        preferSpeechToText: Bool?,
-        onChunk: ((_ chunk: VoiceInputChunk) -> Void)?
-    ) throws -> Promise<VoiceInputResult> {
-        return Promise.async {
-            let interfaceController = try? await RootModule.withInterfaceController { $0 }
-
-            let manager = VoiceInputManager()
-            self.voiceInputManager = manager
-
-            defer { self.voiceInputManager = nil }
-
-            return try await manager.start(
-                interfaceController: interfaceController,
-                silenceThresholdMs: silenceThresholdMs ?? 1_500,
-                maxDurationMs: maxDurationMs ?? 10_000,
-                listeningText: listeningText ?? "Listening...",
-                preferSpeechToText: preferSpeechToText ?? false,
-                onChunk: onChunk
-            )
-        }
-    }
-
-    func stopVoiceInput() throws {
-        Task { @MainActor in
-            let interfaceController = try? await RootModule.withInterfaceController { $0 }
-            self.voiceInputManager?.stop(interfaceController: interfaceController)
-        }
-    }
-}

package/lib/hybrid/HybridVoice.d.ts

@@ -1,12 +0,0 @@
-import type { VoiceInputOptions, VoiceInputResult } from '../types/Voice';
-type StartVoiceInput = {
-    (options: VoiceInputOptions & Required<Pick<VoiceInputOptions, 'onChunk'>>): Promise<void>;
-    (options?: Omit<VoiceInputOptions, 'onChunk'>): Promise<VoiceInputResult>;
-};
-export declare const HybridVoice: {
-    hasVoiceInputPermission: () => boolean;
-    requestVoiceInputPermission: () => Promise<boolean>;
-    startVoiceInput: StartVoiceInput;
-    stopVoiceInput: () => void;
-};
-export {};

package/lib/hybrid/HybridVoice.js

@@ -1,13 +0,0 @@
-import { NitroModules } from 'react-native-nitro-modules';
-const _native = NitroModules.createHybridObject('Voice');
-const startVoiceInput = (async (options) => {
-    const { onChunk, silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText } = options ?? {};
-    const result = await _native.startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText, onChunk);
-    return onChunk !== undefined ? undefined : result;
-});
-export const HybridVoice = {
-    hasVoiceInputPermission: () => _native.hasVoiceInputPermission(),
-    requestVoiceInputPermission: () => _native.requestVoiceInputPermission(),
-    startVoiceInput,
-    stopVoiceInput: () => _native.stopVoiceInput(),
-};

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

@@ -1,51 +0,0 @@
-import type { HybridObject } from 'react-native-nitro-modules';
-import type { VoiceInputChunk, VoiceInputResult } from '../types/Voice';
-export interface Voice extends HybridObject<{
-    android: 'kotlin';
-    ios: 'swift';
-}> {
-    /**
-     * Returns true if all permissions required for voice input are granted.
-     * On iOS: checks both microphone and speech recognition authorization.
-     * On Android: checks RECORD_AUDIO permission.
-     */
-    hasVoiceInputPermission(): boolean;
-    /**
-     * Request all permissions required for voice input.
-     * On iOS: requests microphone permission then speech recognition authorization.
-     * On Android: requests RECORD_AUDIO via car context when connected, otherwise
-     * via the React Native application context.
-     * Returns true only if all required permissions were granted.
-     */
-    requestVoiceInputPermission(): Promise<boolean>;
-    /**
-     * Start an in-app voice session.
-     *
-     * When preferSpeechToText is true:
-     *   iOS — streams audio buffers into SFSpeechRecognizer during recording;
-     *          onChunk fires with partial transcription results; resolves with
-     *          { transcription } or falls back to { audio } if unavailable.
-     *   Android — checks SpeechRecognizer availability upfront; if available it
-     *              owns the mic and streams partial results via onChunk; if not
-     *              available falls back to PCM recording.
-     *
-     * When preferSpeechToText is false (default):
-     *   Both platforms record raw PCM; onChunk fires with audio chunks;
-     *   resolves with { audio }.
-     *
-     * @param silenceThresholdMs  ms of silence before auto-stop (default 1500)
-     * @param maxDurationMs       hard cap on recording duration (default 10000)
-     * @param listeningText       iOS only — text shown on CPVoiceControlTemplate
-     * @param preferSpeechToText  request STT transcription instead of raw PCM
-     * @param onChunk             optional streaming callback; when set the
-     *                            promise resolves with an empty VoiceInputResult
-     */
-    startVoiceInput(silenceThresholdMs?: number, maxDurationMs?: number, listeningText?: string, preferSpeechToText?: boolean, onChunk?: (chunk: VoiceInputChunk) => void): Promise<VoiceInputResult>;
-    /**
-     * Stop the active voice session early.
-     * For PCM mode: resolves startVoiceInput with audio captured so far.
-     * For STT mode: finalises the recognition request.
-     * No-op if no session is active.
-     */
-    stopVoiceInput(): void;
-}

package/lib/specs/Voice.nitro.js

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

package/lib/types/Voice.d.ts

@@ -1,15 +0,0 @@
-export interface VoiceInputChunk {
-    partial?: string;
-    audio?: ArrayBuffer;
-}
-export interface VoiceInputResult {
-    transcription?: string;
-    audio?: ArrayBuffer;
-}
-export interface VoiceInputOptions {
-    silenceThresholdMs?: number;
-    maxDurationMs?: number;
-    listeningText?: string;
-    preferSpeechToText?: boolean;
-    onChunk?: (chunk: VoiceInputChunk) => void;
-}

package/lib/types/Voice.js

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

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

@@ -1,81 +0,0 @@
-///
-/// JFunc_void_VoiceInputChunk.hpp
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © Marc Rousavy @ Margelo
-///
-
-#pragma once
-
-#include <fbjni/fbjni.h>
-#include <functional>
-
-#include "VoiceInputChunk.hpp"
-#include <functional>
-#include <NitroModules/JNICallable.hpp>
-#include "JVoiceInputChunk.hpp"
-#include <string>
-#include <optional>
-#include <NitroModules/ArrayBuffer.hpp>
-#include <NitroModules/JArrayBuffer.hpp>
-
-namespace margelo::nitro::swe::iternio::reactnativeautoplay {
-
-  using namespace facebook;
-
-  /**
-   * Represents the Java/Kotlin callback `(chunk: VoiceInputChunk) -> Unit`.
-   * This can be passed around between C++ and Java/Kotlin.
-   */
-  struct JFunc_void_VoiceInputChunk: public jni::JavaClass<JFunc_void_VoiceInputChunk> {
-  public:
-    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_VoiceInputChunk;";
-
-  public:
-    /**
-     * Invokes the function this `JFunc_void_VoiceInputChunk` instance holds through JNI.
-     */
-    void invoke(const VoiceInputChunk& chunk) const {
-      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JVoiceInputChunk> /* chunk */)>("invoke");
-      method(self(), JVoiceInputChunk::fromCpp(chunk));
-    }
-  };
-
-  /**
-   * An implementation of Func_void_VoiceInputChunk that is backed by a C++ implementation (using `std::function<...>`)
-   */
-  class JFunc_void_VoiceInputChunk_cxx final: public jni::HybridClass<JFunc_void_VoiceInputChunk_cxx, JFunc_void_VoiceInputChunk> {
-  public:
-    static jni::local_ref<JFunc_void_VoiceInputChunk::javaobject> fromCpp(const std::function<void(const VoiceInputChunk& /* chunk */)>& func) {
-      return JFunc_void_VoiceInputChunk_cxx::newObjectCxxArgs(func);
-    }
-
-  public:
-    /**
-     * Invokes the C++ `std::function<...>` this `JFunc_void_VoiceInputChunk_cxx` instance holds.
-     */
-    void invoke_cxx(jni::alias_ref<JVoiceInputChunk> chunk) {
-      _func(chunk->toCpp());
-    }
-
-  public:
-    [[nodiscard]]
-    inline const std::function<void(const VoiceInputChunk& /* chunk */)>& getFunction() const {
-      return _func;
-    }
-
-  public:
-    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_VoiceInputChunk_cxx;";
-    static void registerNatives() {
-      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_VoiceInputChunk_cxx::invoke_cxx)});
-    }
-
-  private:
-    explicit JFunc_void_VoiceInputChunk_cxx(const std::function<void(const VoiceInputChunk& /* chunk */)>& func): _func(func) { }
-
-  private:
-    friend HybridBase;
-    std::function<void(const VoiceInputChunk& /* chunk */)> _func;
-  };
-
-} // namespace margelo::nitro::swe::iternio::reactnativeautoplay