@gmessier/nitro-speech 0.4.0 → 0.4.2

package/lib/Recognizer/methods.d.ts

@@ -1,8 +1,10 @@
-import type { SpeechRecognitionConfig } from './types';
-export declare const recognizerStartListening: (params: SpeechRecognitionConfig) => void;
+import type { MutableSpeechRecognitionConfig, SpeechRecognitionConfig } from './types';
+export declare const recognizerPrewarm: (params?: SpeechRecognitionConfig) => Promise<void>;
+export declare const recognizerStartListening: (params?: SpeechRecognitionConfig) => void;
 export declare const recognizerStopListening: () => void;
 export declare const recognizerResetAutoFinishTime: () => void;
 export declare const recognizerAddAutoFinishTime: (additionalTimeMs?: number) => void;
-export declare const recognizerUpdateConfig: (newConfig: SpeechRecognitionConfig, resetAutoFinishTime?: boolean) => void;
+export declare const recognizerUpdateConfig: (newConfig?: MutableSpeechRecognitionConfig, resetAutoFinishTime?: boolean) => void;
 export declare const recognizerGetIsActive: () => boolean;
+export declare const recognizerGetVoiceInputVolume: () => import("./types").VolumeChangeEvent;
 export declare const recognizerGetSupportedLocalesIOS: () => string[];

package/lib/Recognizer/methods.js

@@ -1,4 +1,8 @@
 import { SpeechRecognizer } from './SpeechRecognizer';
+export const recognizerPrewarm = (params) => {
+    'worklet';
+    return SpeechRecognizer.prewarm(params);
+};
 export const recognizerStartListening = (params) => {
     'worklet';
     SpeechRecognizer.startListening(params);
@@ -23,6 +27,10 @@ export const recognizerGetIsActive = () => {
     'worklet';
     return SpeechRecognizer.getIsActive();
 };
+export const recognizerGetVoiceInputVolume = () => {
+    'worklet';
+    return SpeechRecognizer.getVoiceInputVolume();
+};
 export const recognizerGetSupportedLocalesIOS = () => {
     'worklet';
     return SpeechRecognizer.getSupportedLocalesIOS().sort();

package/lib/Recognizer/types.d.ts

@@ -1,6 +1,6 @@
 import type { Recognizer as RecognizerSpec } from '../specs/Recognizer.nitro';
-import type { SpeechRecognitionConfig } from '../specs/SpeechRecognitionConfig';
+import type { MutableSpeechRecognitionConfig, SpeechRecognitionConfig } from '../specs/SpeechRecognitionConfig';
 import type { VolumeChangeEvent } from '../specs/VolumeChangeEvent';
 type RecognizerCallbacks = Pick<RecognizerSpec, 'onReadyForSpeech' | 'onRecordingStopped' | 'onResult' | 'onAutoFinishProgress' | 'onError' | 'onPermissionDenied' | 'onVolumeChange'>;
-type RecognizerMethods = Pick<RecognizerSpec, 'startListening' | 'stopListening' | 'resetAutoFinishTime' | 'addAutoFinishTime' | 'updateConfig' | 'getIsActive' | 'getSupportedLocalesIOS'>;
-export type { RecognizerSpec, SpeechRecognitionConfig, VolumeChangeEvent, RecognizerCallbacks, RecognizerMethods, };
+type RecognizerMethods = Pick<RecognizerSpec, 'prewarm' | 'startListening' | 'stopListening' | 'resetAutoFinishTime' | 'addAutoFinishTime' | 'updateConfig' | 'getIsActive' | 'getVoiceInputVolume' | 'getSupportedLocalesIOS'>;
+export type { RecognizerSpec, SpeechRecognitionConfig, MutableSpeechRecognitionConfig, VolumeChangeEvent, RecognizerCallbacks, RecognizerMethods, };

package/lib/Recognizer/useRecognizer.js

@@ -1,7 +1,8 @@
 import { useEffect } from 'react';
-import { recognizerResetAutoFinishTime, recognizerAddAutoFinishTime, recognizerUpdateConfig, recognizerGetIsActive, recognizerGetSupportedLocalesIOS, recognizerStartListening, recognizerStopListening, } from './methods';
+import { recognizerResetAutoFinishTime, recognizerAddAutoFinishTime, recognizerUpdateConfig, recognizerGetIsActive, recognizerGetSupportedLocalesIOS, recognizerStartListening, recognizerStopListening, recognizerGetVoiceInputVolume, recognizerPrewarm, } from './methods';
 import { SpeechRecognizer } from './SpeechRecognizer';
 import { speechRecognizerVolumeChangeHandler } from './useVoiceInputVolume';
+import { speechRecognizerActiveStateHandler } from './useRecognizerIsActive';
 /**
  * Safe, lifecycle-aware hook to use the recognizer.
  *
@@ -17,18 +18,12 @@ import { speechRecognizerVolumeChangeHandler } from './useVoiceInputVolume';
  */
 export const useRecognizer = (callbacks, destroyDeps = []) => {
     useEffect(() => {
-        if (callbacks.onVolumeChange) {
-            SpeechRecognizer.onVolumeChange = (event) => {
-                callbacks.onVolumeChange?.(event);
-            };
-        }
-        else {
-            SpeechRecognizer.onVolumeChange = speechRecognizerVolumeChangeHandler;
-        }
         SpeechRecognizer.onReadyForSpeech = () => {
+            speechRecognizerActiveStateHandler(true);
             callbacks.onReadyForSpeech?.();
         };
         SpeechRecognizer.onRecordingStopped = () => {
+            speechRecognizerActiveStateHandler(false);
             callbacks.onRecordingStopped?.();
         };
         SpeechRecognizer.onResult = (resultBatches) => {
@@ -43,6 +38,10 @@ export const useRecognizer = (callbacks, destroyDeps = []) => {
         SpeechRecognizer.onPermissionDenied = () => {
             callbacks.onPermissionDenied?.();
         };
+        SpeechRecognizer.onVolumeChange = (event) => {
+            speechRecognizerVolumeChangeHandler(event);
+            callbacks.onVolumeChange?.(event);
+        };
         return () => {
             SpeechRecognizer.onReadyForSpeech = undefined;
             SpeechRecognizer.onRecordingStopped = undefined;
@@ -60,12 +59,14 @@ export const useRecognizer = (callbacks, destroyDeps = []) => {
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [...destroyDeps]);
     return {
+        prewarm: recognizerPrewarm,
         startListening: recognizerStartListening,
         stopListening: recognizerStopListening,
         resetAutoFinishTime: recognizerResetAutoFinishTime,
         addAutoFinishTime: recognizerAddAutoFinishTime,
         updateConfig: recognizerUpdateConfig,
         getIsActive: recognizerGetIsActive,
+        getVoiceInputVolume: recognizerGetVoiceInputVolume,
         getSupportedLocalesIOS: recognizerGetSupportedLocalesIOS,
     };
 };

package/lib/Recognizer/useRecognizerIsActive.d.ts

@@ -0,0 +1,25 @@
+type OnActiveStateChange = (isActive: boolean) => void;
+/**
+ * Returns true if the speech recognition session is active.
+ */
+export declare const useRecognizerIsActive: () => boolean;
+/**
+ * Direct access to default Speech Recognizer isActive state change handler.
+ *
+ * In case you use static Speech Recognizer:
+ *
+ * ```typescript
+ * import { speechRecognizerActiveStateHandler } from '@gmessier/nitro-speech'
+ *
+ * SpeechRecognizer.onReadyForSpeech = () => {
+ *   speechRecognizerActiveStateHandler(true)
+ * }
+ * SpeechRecognizer.onRecordingStopped = () => {
+ *   speechRecognizerActiveStateHandler(false)
+ * }
+ * ... // setup everything else
+ * SpeechRecognizer.startListening({ locale: 'en-US' })
+ * ```
+ */
+export declare const speechRecognizerActiveStateHandler: OnActiveStateChange;
+export {};

package/lib/Recognizer/useRecognizerIsActive.js

@@ -0,0 +1,40 @@
+import { useSyncExternalStore } from 'react';
+const subscribers = new Set();
+let recognizerIsActive = false;
+const getSnapshot = () => {
+    return recognizerIsActive;
+};
+/**
+ * Returns true if the speech recognition session is active.
+ */
+export const useRecognizerIsActive = () => {
+    return useSyncExternalStore((subscriber) => {
+        subscribers.add(subscriber);
+        return () => subscribers.delete(subscriber);
+    }, getSnapshot);
+};
+/**
+ * Direct access to default Speech Recognizer isActive state change handler.
+ *
+ * In case you use static Speech Recognizer:
+ *
+ * ```typescript
+ * import { speechRecognizerActiveStateHandler } from '@gmessier/nitro-speech'
+ *
+ * SpeechRecognizer.onReadyForSpeech = () => {
+ *   speechRecognizerActiveStateHandler(true)
+ * }
+ * SpeechRecognizer.onRecordingStopped = () => {
+ *   speechRecognizerActiveStateHandler(false)
+ * }
+ * ... // setup everything else
+ * SpeechRecognizer.startListening({ locale: 'en-US' })
+ * ```
+ */
+export const speechRecognizerActiveStateHandler = (isActive) => {
+    if (isActive === recognizerIsActive) {
+        return;
+    }
+    recognizerIsActive = isActive;
+    subscribers.forEach((subscriber) => subscriber?.(isActive));
+};

package/lib/Recognizer/useVoiceInputVolume.d.ts

@@ -1,5 +1,5 @@
 import type { RecognizerSpec, VolumeChangeEvent } from './types';
-type OnVolumeChange = RecognizerSpec['onVolumeChange'];
+type OnVolumeChange = Exclude<RecognizerSpec['onVolumeChange'], undefined>;
 /**
  * Subscription to the voice input volume changes
  *

package/lib/index.d.ts

@@ -1,6 +1,7 @@
-export * from './Recognizer/useRecognizer';
-export * from './Recognizer/useVoiceInputVolume';
-export * from './Recognizer/SpeechRecognizer';
-export * from './Recognizer/RecognizerRef';
-export * from './Recognizer/types';
-export * from './NitroSpeech';
+export { useRecognizer } from './Recognizer/useRecognizer';
+export { useVoiceInputVolume, speechRecognizerVolumeChangeHandler, } from './Recognizer/useVoiceInputVolume';
+export { useRecognizerIsActive, speechRecognizerActiveStateHandler, } from './Recognizer/useRecognizerIsActive';
+export { SpeechRecognizer } from './Recognizer/SpeechRecognizer';
+export { RecognizerRef } from './Recognizer/RecognizerRef';
+export { NitroSpeech } from './NitroSpeech';
+export { type RecognizerSpec, type SpeechRecognitionConfig, type MutableSpeechRecognitionConfig, type VolumeChangeEvent, type RecognizerCallbacks, type RecognizerMethods, } from './Recognizer/types';

package/lib/index.js

@@ -1,6 +1,7 @@
-export * from './Recognizer/useRecognizer';
-export * from './Recognizer/useVoiceInputVolume';
-export * from './Recognizer/SpeechRecognizer';
-export * from './Recognizer/RecognizerRef';
-export * from './Recognizer/types';
-export * from './NitroSpeech';
+export { useRecognizer } from './Recognizer/useRecognizer';
+export { useVoiceInputVolume, speechRecognizerVolumeChangeHandler, } from './Recognizer/useVoiceInputVolume';
+export { useRecognizerIsActive, speechRecognizerActiveStateHandler, } from './Recognizer/useRecognizerIsActive';
+export { SpeechRecognizer } from './Recognizer/SpeechRecognizer';
+export { RecognizerRef } from './Recognizer/RecognizerRef';
+export { NitroSpeech } from './NitroSpeech';
+export {} from './Recognizer/types';

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

@@ -8,9 +8,24 @@ export interface Recognizer extends HybridObject<{
     /**
      * Prepare the speech recognition engine and the model for the given parameters.
      *
-     * Omit the {@linkcode Promise} result if want to run synchronously.
+     * @notes
+     * - Not required, {@linkcode startListening} will prewarm automatically.
+     *
+     * - Omit the {@linkcode Promise} result if you want to run synchronously.
      * {@linkcode startListening} will start and resolve it automatically.
-     * Only `await` if run beforehand and want to react on the success
+     *
+     * - Only `await` if run beforehand and you want to react to the success
+     *
+     * @worklet **Do not** use `await` on Worklet or UI runtimes. It will not work properly.
+     *
+     * You can run it synchronously:
+     * ```typescript
+     *  scheduleOnRuntime(workletRuntime, () => {
+     *    RecognizerRef.prewarm({
+     *      // your config to prepare
+     *    });
+     *  });
+     * ```
      */
     prewarm(defaultParams?: SpeechRecognitionConfig): Promise<void>;
     /**
@@ -24,9 +39,9 @@ export interface Recognizer extends HybridObject<{
      */
     startListening(params?: SpeechRecognitionConfig): void;
     /**
-     * Stops the speech recognition. if not started, does nothing.
+     * Stops the speech recognition. If not started, does nothing.
      *
-     * Not a sync operation for android, delay about 250ms to polish the result.
+     * Not a sync operation for Android, delay about 250ms to polish the result.
      *
      * Use {@linkcode onRecordingStopped} to handle the stop event.
      */
@@ -52,6 +67,10 @@ export interface Recognizer extends HybridObject<{
      * Returns true if the speech recognition is active.
      */
     getIsActive(): boolean;
+    /**
+     * Returns the current voice input volume.
+     */
+    getVoiceInputVolume(): VolumeChangeEvent;
     /**
      * Returns a list of supported locales.
      *
@@ -67,15 +86,13 @@ export interface Recognizer extends HybridObject<{
      */
     onRecordingStopped?: () => void;
     /**
-     * Called each time either a new batch has been added or the last batch has been updated.
+     * Fires each time either a new batch has been added or the last batch has been updated.
      */
     onResult?: (resultBatches: string[]) => void;
     /**
-     * Called every {@linkcode SpeechRecognitionConfig.autoFinishProgressIntervalMs} or 1000ms
+     * Fires every {@linkcode SpeechRecognitionConfig.autoFinishProgressIntervalMs} or 1000ms
      *
      * Time left in milliseconds until the timer stops.
-     *
-     * @note not implemented for Android yet.
      */
     onAutoFinishProgress?: (timeLeftMs: number) => void;
     /**
@@ -87,9 +104,7 @@ export interface Recognizer extends HybridObject<{
      */
     onPermissionDenied?: () => void;
     /**
-     * Called with high and arbitrary frequency (many times per second) while audio recording is active.
-     *
-     * @warning overriding it will disable the built-in `useVoiceInputVolume` hook.
+     * Fires with high and arbitrary frequency (many times per second) while audio recording is active.
      */
     onVolumeChange?: (event: VolumeChangeEvent) => void;
 }

package/nitrogen/generated/android/c++/JHybridRecognizerSpec.cpp

@@ -233,6 +233,11 @@ namespace margelo::nitro::nitrospeech {
     auto __result = method(_javaPart);
     return static_cast<bool>(__result);
   }
+  VolumeChangeEvent JHybridRecognizerSpec::getVoiceInputVolume() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVolumeChangeEvent>()>("getVoiceInputVolume");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
   std::vector<std::string> JHybridRecognizerSpec::getSupportedLocalesIOS() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<jni::JString>>()>("getSupportedLocalesIOS");
     auto __result = method(_javaPart);

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

@@ -74,6 +74,7 @@ namespace margelo::nitro::nitrospeech {
     void addAutoFinishTime(std::optional<double> additionalTimeMs) override;
     void updateConfig(const std::optional<MutableSpeechRecognitionConfig>& newConfig, std::optional<bool> resetAutoFinishTime) override;
     bool getIsActive() override;
+    VolumeChangeEvent getVoiceInputVolume() override;
     std::vector<std::string> getSupportedLocalesIOS() override;
 
   private:

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrospeech/HybridRecognizerSpec.kt

@@ -153,6 +153,10 @@ abstract class HybridRecognizerSpec: HybridObject() {
   @Keep
   abstract fun getIsActive(): Boolean
   
+  @DoNotStrip
+  @Keep
+  abstract fun getVoiceInputVolume(): VolumeChangeEvent
+  
   @DoNotStrip
   @Keep
   abstract fun getSupportedLocalesIOS(): Array<String>

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

@@ -454,6 +454,15 @@ namespace margelo::nitro::nitrospeech::bridge::swift {
     return Result<bool>::withError(error);
   }
   
+  // pragma MARK: Result<VolumeChangeEvent>
+  using Result_VolumeChangeEvent_ = Result<VolumeChangeEvent>;
+  inline Result_VolumeChangeEvent_ create_Result_VolumeChangeEvent_(const VolumeChangeEvent& value) noexcept {
+    return Result<VolumeChangeEvent>::withValue(value);
+  }
+  inline Result_VolumeChangeEvent_ create_Result_VolumeChangeEvent_(const std::exception_ptr& error) noexcept {
+    return Result<VolumeChangeEvent>::withError(error);
+  }
+  
   // pragma MARK: Result<std::vector<std::string>>
   using Result_std__vector_std__string__ = Result<std::vector<std::string>>;
   inline Result_std__vector_std__string__ create_Result_std__vector_std__string__(const std::vector<std::string>& value) noexcept {

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

@@ -178,6 +178,14 @@ namespace margelo::nitro::nitrospeech {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline VolumeChangeEvent getVoiceInputVolume() override {
+      auto __result = _swiftPart.getVoiceInputVolume();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::vector<std::string> getSupportedLocalesIOS() override {
       auto __result = _swiftPart.getSupportedLocalesIOS();
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/HybridRecognizerSpec.swift

@@ -26,6 +26,7 @@ public protocol HybridRecognizerSpec_protocol: HybridObject {
   func addAutoFinishTime(additionalTimeMs: Double?) throws -> Void
   func updateConfig(newConfig: MutableSpeechRecognitionConfig?, resetAutoFinishTime: Bool?) throws -> Void
   func getIsActive() throws -> Bool
+  func getVoiceInputVolume() throws -> VolumeChangeEvent
   func getSupportedLocalesIOS() throws -> [String]
 }
 

package/nitrogen/generated/ios/swift/HybridRecognizerSpec_cxx.swift

@@ -452,6 +452,18 @@ open class HybridRecognizerSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func getVoiceInputVolume() -> bridge.Result_VolumeChangeEvent_ {
+    do {
+      let __result = try self.__implementation.getVoiceInputVolume()
+      let __resultCpp = __result
+      return bridge.create_Result_VolumeChangeEvent_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_VolumeChangeEvent_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func getSupportedLocalesIOS() -> bridge.Result_std__vector_std__string__ {
     do {

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

@@ -35,6 +35,7 @@ namespace margelo::nitro::nitrospeech {
       prototype.registerHybridMethod("addAutoFinishTime", &HybridRecognizerSpec::addAutoFinishTime);
       prototype.registerHybridMethod("updateConfig", &HybridRecognizerSpec::updateConfig);
       prototype.registerHybridMethod("getIsActive", &HybridRecognizerSpec::getIsActive);
+      prototype.registerHybridMethod("getVoiceInputVolume", &HybridRecognizerSpec::getVoiceInputVolume);
       prototype.registerHybridMethod("getSupportedLocalesIOS", &HybridRecognizerSpec::getSupportedLocalesIOS);
     });
   }

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

@@ -80,6 +80,7 @@ namespace margelo::nitro::nitrospeech {
       virtual void addAutoFinishTime(std::optional<double> additionalTimeMs) = 0;
       virtual void updateConfig(const std::optional<MutableSpeechRecognitionConfig>& newConfig, std::optional<bool> resetAutoFinishTime) = 0;
       virtual bool getIsActive() = 0;
+      virtual VolumeChangeEvent getVoiceInputVolume() = 0;
       virtual std::vector<std::string> getSupportedLocalesIOS() = 0;
 
     protected:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmessier/nitro-speech",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "React Native Real-time Speech Recognition Library powered by Nitro Modules",
   "main": "./lib/index.js",
   "module": "./lib/index.js",

package/src/Recognizer/RecognizerRef.ts

@@ -7,17 +7,23 @@ import {
   recognizerStartListening,
   recognizerStopListening,
   recognizerUpdateConfig,
+  recognizerGetVoiceInputVolume,
+  recognizerPrewarm,
 } from './methods'
 
 /**
  * Safe cross-component reference to the Speech Recognizer methods.
+ *
+ * All methods support worklets and UI thread calls
  */
 export const RecognizerRef: RecognizerMethods = {
+  prewarm: recognizerPrewarm,
   startListening: recognizerStartListening,
   stopListening: recognizerStopListening,
   resetAutoFinishTime: recognizerResetAutoFinishTime,
   addAutoFinishTime: recognizerAddAutoFinishTime,
   updateConfig: recognizerUpdateConfig,
   getIsActive: recognizerGetIsActive,
+  getVoiceInputVolume: recognizerGetVoiceInputVolume,
   getSupportedLocalesIOS: recognizerGetSupportedLocalesIOS,
 }

package/src/Recognizer/SpeechRecognizer.ts

@@ -5,6 +5,7 @@ import { NitroSpeech } from '../NitroSpeech'
  *
  * Direct access to the all Speech Recognizer methods and callbacks.
  *
- * @note unsafe, might lead to race conditions
+ * @note Unsafe, might lead to race conditions
+ * @warning Since it reflects the original hybrid object, its API may change in the future.
  */
 export const SpeechRecognizer = NitroSpeech.recognizer

package/src/Recognizer/methods.ts

@@ -1,7 +1,15 @@
 import { SpeechRecognizer } from './SpeechRecognizer'
-import type { SpeechRecognitionConfig } from './types'
+import type {
+  MutableSpeechRecognitionConfig,
+  SpeechRecognitionConfig,
+} from './types'
 
-export const recognizerStartListening = (params: SpeechRecognitionConfig) => {
+export const recognizerPrewarm = (params?: SpeechRecognitionConfig) => {
+  'worklet'
+  return SpeechRecognizer.prewarm(params)
+}
+
+export const recognizerStartListening = (params?: SpeechRecognitionConfig) => {
   'worklet'
   SpeechRecognizer.startListening(params)
 }
@@ -22,7 +30,7 @@ export const recognizerAddAutoFinishTime = (additionalTimeMs?: number) => {
 }
 
 export const recognizerUpdateConfig = (
-  newConfig: SpeechRecognitionConfig,
+  newConfig?: MutableSpeechRecognitionConfig,
   resetAutoFinishTime?: boolean
 ) => {
   'worklet'
@@ -34,6 +42,11 @@ export const recognizerGetIsActive = () => {
   return SpeechRecognizer.getIsActive()
 }
 
+export const recognizerGetVoiceInputVolume = () => {
+  'worklet'
+  return SpeechRecognizer.getVoiceInputVolume()
+}
+
 export const recognizerGetSupportedLocalesIOS = () => {
   'worklet'
   return SpeechRecognizer.getSupportedLocalesIOS().sort()

package/src/Recognizer/types.ts

@@ -1,5 +1,8 @@
 import type { Recognizer as RecognizerSpec } from '../specs/Recognizer.nitro'
-import type { SpeechRecognitionConfig } from '../specs/SpeechRecognitionConfig'
+import type {
+  MutableSpeechRecognitionConfig,
+  SpeechRecognitionConfig,
+} from '../specs/SpeechRecognitionConfig'
 import type { VolumeChangeEvent } from '../specs/VolumeChangeEvent'
 
 type RecognizerCallbacks = Pick<
@@ -15,18 +18,21 @@ type RecognizerCallbacks = Pick<
 
 type RecognizerMethods = Pick<
   RecognizerSpec,
+  | 'prewarm'
   | 'startListening'
   | 'stopListening'
   | 'resetAutoFinishTime'
   | 'addAutoFinishTime'
   | 'updateConfig'
   | 'getIsActive'
+  | 'getVoiceInputVolume'
   | 'getSupportedLocalesIOS'
 >
 
 export type {
   RecognizerSpec,
   SpeechRecognitionConfig,
+  MutableSpeechRecognitionConfig,
   VolumeChangeEvent,
   RecognizerCallbacks,
   RecognizerMethods,

package/src/Recognizer/useRecognizer.ts

@@ -7,10 +7,13 @@ import {
   recognizerGetSupportedLocalesIOS,
   recognizerStartListening,
   recognizerStopListening,
+  recognizerGetVoiceInputVolume,
+  recognizerPrewarm,
 } from './methods'
 import type { RecognizerCallbacks, RecognizerMethods } from './types'
 import { SpeechRecognizer } from './SpeechRecognizer'
 import { speechRecognizerVolumeChangeHandler } from './useVoiceInputVolume'
+import { speechRecognizerActiveStateHandler } from './useRecognizerIsActive'
 
 /**
  * Safe, lifecycle-aware hook to use the recognizer.
@@ -30,17 +33,12 @@ export const useRecognizer = (
   destroyDeps: DependencyList = []
 ): RecognizerMethods => {
   useEffect(() => {
-    if (callbacks.onVolumeChange) {
-      SpeechRecognizer.onVolumeChange = (event) => {
-        callbacks.onVolumeChange?.(event)
-      }
-    } else {
-      SpeechRecognizer.onVolumeChange = speechRecognizerVolumeChangeHandler
-    }
     SpeechRecognizer.onReadyForSpeech = () => {
+      speechRecognizerActiveStateHandler(true)
       callbacks.onReadyForSpeech?.()
     }
     SpeechRecognizer.onRecordingStopped = () => {
+      speechRecognizerActiveStateHandler(false)
       callbacks.onRecordingStopped?.()
     }
     SpeechRecognizer.onResult = (resultBatches: string[]) => {
@@ -55,6 +53,10 @@ export const useRecognizer = (
     SpeechRecognizer.onPermissionDenied = () => {
       callbacks.onPermissionDenied?.()
     }
+    SpeechRecognizer.onVolumeChange = (event) => {
+      speechRecognizerVolumeChangeHandler(event)
+      callbacks.onVolumeChange?.(event)
+    }
     return () => {
       SpeechRecognizer.onReadyForSpeech = undefined
       SpeechRecognizer.onRecordingStopped = undefined
@@ -74,12 +76,14 @@ export const useRecognizer = (
   }, [...destroyDeps])
 
   return {
+    prewarm: recognizerPrewarm,
     startListening: recognizerStartListening,
     stopListening: recognizerStopListening,
     resetAutoFinishTime: recognizerResetAutoFinishTime,
     addAutoFinishTime: recognizerAddAutoFinishTime,
     updateConfig: recognizerUpdateConfig,
     getIsActive: recognizerGetIsActive,
+    getVoiceInputVolume: recognizerGetVoiceInputVolume,
     getSupportedLocalesIOS: recognizerGetSupportedLocalesIOS,
   }
 }

package/src/Recognizer/useRecognizerIsActive.ts

@@ -0,0 +1,49 @@
+import { useSyncExternalStore } from 'react'
+
+type OnActiveStateChange = (isActive: boolean) => void
+
+const subscribers = new Set<OnActiveStateChange>()
+
+let recognizerIsActive = false
+
+const getSnapshot = () => {
+  return recognizerIsActive
+}
+
+/**
+ * Returns true if the speech recognition session is active.
+ */
+export const useRecognizerIsActive = () => {
+  return useSyncExternalStore((subscriber) => {
+    subscribers.add(subscriber)
+    return () => subscribers.delete(subscriber)
+  }, getSnapshot)
+}
+
+/**
+ * Direct access to default Speech Recognizer isActive state change handler.
+ *
+ * In case you use static Speech Recognizer:
+ *
+ * ```typescript
+ * import { speechRecognizerActiveStateHandler } from '@gmessier/nitro-speech'
+ *
+ * SpeechRecognizer.onReadyForSpeech = () => {
+ *   speechRecognizerActiveStateHandler(true)
+ * }
+ * SpeechRecognizer.onRecordingStopped = () => {
+ *   speechRecognizerActiveStateHandler(false)
+ * }
+ * ... // setup everything else
+ * SpeechRecognizer.startListening({ locale: 'en-US' })
+ * ```
+ */
+export const speechRecognizerActiveStateHandler: OnActiveStateChange = (
+  isActive
+) => {
+  if (isActive === recognizerIsActive) {
+    return
+  }
+  recognizerIsActive = isActive
+  subscribers.forEach((subscriber) => subscriber?.(isActive))
+}

package/src/Recognizer/useVoiceInputVolume.ts

@@ -1,7 +1,7 @@
 import { useSyncExternalStore } from 'react'
 import type { RecognizerSpec, VolumeChangeEvent } from './types'
 
-type OnVolumeChange = RecognizerSpec['onVolumeChange']
+type OnVolumeChange = Exclude<RecognizerSpec['onVolumeChange'], undefined>
 
 const subscribers = new Set<OnVolumeChange>()