@gmessier/nitro-speech 0.3.2 → 0.4.0

package/ios/Shared/AutoStopper.swift

@@ -0,0 +1,147 @@
+import Foundation
+
+final class AutoStopper {
+    private static let defaultSilenceThresholdMs = 8000.0
+    private static let defaultProgressIntervalMs = 1000.0
+    private static let minProgressIntervalMs = 50.0
+
+    private let lg = Lg(prefix: "AutoStopper", disable: true)
+    
+    private let queue = DispatchQueue(label: "com.margelo.nitrospeech.autostopper")
+
+    private var silenceThresholdMs: Double
+    private var progressIntervalMs: Double
+    private var timeLeftMs: Double
+    private var isStopped = false
+    private var didTimeout = false
+    private var timer: DispatchSourceTimer?
+
+    private let onProgress: (Double) -> Void
+    private let onTimeout: () -> Void
+
+    init(
+        silenceThresholdMs: Double?,
+        progressIntervalMs: Double?,
+        onProgress: @escaping (Double) -> Void,
+        onTimeout: @escaping () -> Void
+    ) {
+        let threshold = Self.clampMs(silenceThresholdMs ?? Self.defaultSilenceThresholdMs)
+        let interval = Self.clampMs(progressIntervalMs ?? Self.defaultProgressIntervalMs)
+        self.silenceThresholdMs = threshold
+        self.progressIntervalMs = interval
+        self.timeLeftMs = threshold
+        self.onProgress = onProgress
+        self.onTimeout = onTimeout
+    }
+
+    deinit {
+        queue.sync {
+            stopLocked()
+            timeLeftMs = 0
+        }
+    }
+
+    func resetTimer(from: String) {
+        queue.async { [weak self] in
+            guard let self, !self.isStopped else { return }
+            lg.log("[resetTimer] from:\(from)")
+            self.didTimeout = false
+            self.timeLeftMs = self.silenceThresholdMs
+            self.startOrRescheduleTimerLocked()
+            if self.timeLeftMs > 0 {
+                self.onProgress(self.timeLeftMs)
+            }
+        }
+    }
+
+    func updateThreshold(_ newThresholdMs: Double, from: String) {
+        queue.async { [weak self] in
+            guard let self, !self.isStopped else { return }
+            lg.log("[updateThreshold] from:\(from) newThresholdMs:\(newThresholdMs)")
+            self.silenceThresholdMs = Self.clampMs(newThresholdMs)
+        }
+    }
+
+    func addMsOnce(_ extraMs: Double, from: String) {
+        queue.async { [weak self] in
+            guard let self, !self.isStopped, extraMs.isFinite else { return }
+            lg.log("[addMsOnce] from:\(from) extraMs:\(extraMs)")
+            self.timeLeftMs += extraMs
+            self.didTimeout = false
+            if self.timeLeftMs > 0, self.timer != nil {
+                self.onProgress(self.timeLeftMs)
+            }
+        }
+    }
+
+    func updateProgressInterval(_ newIntervalMs: Double, from: String) {
+        queue.async { [weak self] in
+            guard let self, !self.isStopped else { return }
+            lg.log("[updateProgressInterval] from:\(from) newIntervalMs:\(newIntervalMs)")
+            self.progressIntervalMs = Self.clampMs(newIntervalMs)
+            if self.timer != nil {
+                self.startOrRescheduleTimerLocked()
+            }
+        }
+    }
+
+    func stop() {
+        queue.async { [weak self] in
+            guard let self else { return }
+            self.stopLocked()
+            self.timeLeftMs = 0
+        }
+    }
+
+    private func startOrRescheduleTimerLocked() {
+        timer?.cancel()
+        timer = nil
+
+        let source = DispatchSource.makeTimerSource(queue: queue)
+        let intervalNs = UInt64(progressIntervalMs * 1_000_000)
+        source.schedule(
+            deadline: .now() + .nanoseconds(Int(intervalNs)),
+            repeating: .nanoseconds(Int(intervalNs))
+        )
+        source.setEventHandler { [weak self] in
+            self?.tickLocked()
+        }
+        timer = source
+        source.resume()
+    }
+
+    private func tickLocked() {
+        guard !isStopped else { return }
+        guard !didTimeout else { return }
+
+        timeLeftMs -= progressIntervalMs
+        if timeLeftMs > 0 {
+            lg.log("[onProgress] timeLeftMs:\(timeLeftMs)")
+            onProgress(timeLeftMs)
+            return
+        }
+
+        timeLeftMs = 0
+        didTimeout = true
+        cancelTimerLocked()
+        lg.log("[onTimeout]")
+        onTimeout()
+    }
+
+    private func stopLocked() {
+        isStopped = true
+        cancelTimerLocked()
+    }
+
+    private func cancelTimerLocked() {
+        timer?.cancel()
+        timer = nil
+    }
+
+    private static func clampMs(_ value: Double) -> Double {
+        if !value.isFinite {
+            return minProgressIntervalMs
+        }
+        return max(minProgressIntervalMs, value)
+    }
+}

package/ios/Shared/HapticImpact.swift

@@ -0,0 +1,24 @@
+import Foundation
+import UIKit
+
+enum HapticImpact {
+    static func trigger(with: HapticFeedbackStyle?) {
+        // Default behavior - medium
+        let style = with ?? HapticFeedbackStyle.medium
+        let hapticStyle: UIImpactFeedbackGenerator.FeedbackStyle? = switch style {
+            case .light:
+                UIImpactFeedbackGenerator.FeedbackStyle.light
+            case .medium:
+                UIImpactFeedbackGenerator.FeedbackStyle.medium
+            case .heavy:
+                UIImpactFeedbackGenerator.FeedbackStyle.heavy
+            case .none:
+                nil
+        }
+        if let hapticStyle {
+            let impactGenerator = UIImpactFeedbackGenerator(style: hapticStyle)
+            impactGenerator.prepare()
+            impactGenerator.impactOccurred()
+        }
+    }
+}

package/ios/Shared/Log.swift

@@ -0,0 +1,41 @@
+import Foundation
+import os.log
+
+enum Log {
+   static let isLogging = false
+   static let subsystem = "com.margelo.nitro.nitrospeech"
+   static let category = "NitroSpeech"
+   static func log(_ text: String) {
+       if isLogging {
+           let tn = Thread.current.isMainThread ? "main" : "bg"
+           Logger(subsystem: subsystem, category: category).info(
+            "[thread]: \(tn) | \(text)"
+           )
+       }
+   }
+}
+
+final class Lg {
+    private let disable: Bool
+    static let isLogging = false
+    static let subsystem = "com.margelo.nitro.nitrospeech"
+    static let category = "NitroSpeech"
+    let prefix: String
+    init(prefix: String, disable: Bool? = false) {
+        self.prefix = prefix
+        self.disable = disable ?? false
+    }
+    var prevMs: Double?
+    func log(_ text: String) {
+        if Self.isLogging && !self.disable {
+            let nowMs = ProcessInfo.processInfo.systemUptime * 1000
+            let diff = Int(round(nowMs - (self.prevMs ?? nowMs)))
+            self.prevMs = nowMs
+            let tn = Thread.current.isMainThread ? "main" : "bg"
+            Logger(
+                subsystem: Self.subsystem,
+                category: Self.category
+            ).info("[thread]: \(tn) | {\(self.prefix)} diff: \(diff) | \(text)")
+        }
+    }
+}

package/ios/Shared/Permissions.swift

@@ -0,0 +1,59 @@
+import Foundation
+import Speech
+import AVFoundation
+
+final class Permissions {
+    private let onGranted: () async -> Void
+    private let onDenied: (() -> Void)?
+    private let onError: ((String) -> Void)?
+    
+    init(
+        onGranted: @escaping () async -> Void,
+        onDenied: (() -> Void)?,
+        onError: ((String) -> Void)?
+    ) {
+        self.onGranted = onGranted
+        self.onDenied = onDenied
+        self.onError = onError
+    }
+    
+    private func requestMicrophonePermission() async {
+        // Request permission to record.
+        if #available(iOS 17.0, *) {
+            if await AVAudioApplication.requestRecordPermission() {
+                await self.onGranted()
+                return
+            }
+            self.onDenied?()
+            return
+        }
+        AVAudioSession.sharedInstance().requestRecordPermission { [weak self] granted in
+            Task { @MainActor in
+                guard let self else { return }
+                if granted {
+                    await self.onGranted()
+                    return
+                }
+                self.onDenied?()
+            }
+        }
+    }
+    
+    func requestAuthorization() {
+        SFSpeechRecognizer.requestAuthorization { authStatus in
+            Task { @MainActor in
+                switch authStatus {
+                    case .authorized:
+                        await self.requestMicrophonePermission()
+                    case .denied, .restricted:
+                        self.onDenied?()
+                    case .notDetermined:
+                        self.onError?("Speech recognition not determined")
+                    @unknown default:
+                        self.onError?("Unknown authorization status")
+                }
+            }
+        }
+    }
+    
+}

package/ios/Shared/Utils.swift

@@ -0,0 +1,58 @@
+import Foundation
+
+enum Utils {
+    static func repeatingFilter(_ text: String) -> String {
+        var subStrings = text.split { $0.isWhitespace }.map { String($0) }
+        if #available(iOS 16.0, *) {
+            var shift = 0
+            while shift < subStrings.count, !subStrings[shift].contains(/\w+/) {
+                shift += 1
+            }
+            if shift > 0, shift < subStrings.count {
+                subStrings = Array(subStrings.suffix(subStrings.count - shift))
+            }
+        }
+        guard !subStrings.isEmpty else { return text }
+        
+        var joiner = ""
+        if subStrings.count >= 10 {
+            joiner = subStrings.prefix(subStrings.count - 9).joined(separator: " ")
+            subStrings = Array(subStrings.suffix(10))
+        } else {
+            joiner = subStrings.first ?? ""
+        }
+        for i in subStrings.indices {
+            if i == 0 { continue }
+            if #available(iOS 16.0, *), subStrings[i].contains(/\d+/) {
+                joiner += " \(subStrings[i])"
+                continue
+            }
+            if subStrings[i] == subStrings[i - 1] { continue }
+            joiner += " \(subStrings[i])"
+        }
+        return joiner
+    }
+
+    // hash only params that affect transcriber preference
+    static func hashParams(_ params: SpeechRecognitionConfig?) -> String {
+        guard let params else { return "n" }
+        let locale = params.locale ?? "en-US"
+        let addPunctuation = switch params.iosAddPunctuation {
+            case nil: "n"
+            case false: "f"
+            case true: "t"
+        }
+        let preset = switch params.iosPreset {
+            case nil: "n"
+            case .shortform: "s"
+            case .general: "g"
+        }
+        let atypicalSpeech = switch params.iosAtypicalSpeech {
+            case nil: "n"
+            case false: "f"
+            case true: "t"
+        }
+        
+        return [locale, addPunctuation, preset, atypicalSpeech].joined(separator: "|")
+    }
+}

package/lib/NitroSpeech.d.ts

@@ -0,0 +1,2 @@
+import type { NitroSpeech as NitroSpeechSpec } from './specs/NitroSpeech.nitro';
+export declare const NitroSpeech: NitroSpeechSpec;

package/lib/NitroSpeech.js

@@ -0,0 +1,2 @@
+import { NitroModules } from 'react-native-nitro-modules';
+export const NitroSpeech = NitroModules.createHybridObject('NitroSpeech');

package/lib/Recognizer/RecognizerRef.d.ts

@@ -0,0 +1,5 @@
+import type { RecognizerMethods } from './types';
+/**
+ * Safe cross-component reference to the Speech Recognizer methods.
+ */
+export declare const RecognizerRef: RecognizerMethods;

package/lib/Recognizer/RecognizerRef.js

@@ -0,0 +1,13 @@
+import { recognizerAddAutoFinishTime, recognizerGetSupportedLocalesIOS, recognizerGetIsActive, recognizerResetAutoFinishTime, recognizerStartListening, recognizerStopListening, recognizerUpdateConfig, } from './methods';
+/**
+ * Safe cross-component reference to the Speech Recognizer methods.
+ */
+export const RecognizerRef = {
+    startListening: recognizerStartListening,
+    stopListening: recognizerStopListening,
+    resetAutoFinishTime: recognizerResetAutoFinishTime,
+    addAutoFinishTime: recognizerAddAutoFinishTime,
+    updateConfig: recognizerUpdateConfig,
+    getIsActive: recognizerGetIsActive,
+    getSupportedLocalesIOS: recognizerGetSupportedLocalesIOS,
+};

package/lib/Recognizer/SpeechRecognizer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Static Speech Recognizer instance.
+ *
+ * Direct access to the all Speech Recognizer methods and callbacks.
+ *
+ * @note unsafe, might lead to race conditions
+ */
+export declare const SpeechRecognizer: import("./types").RecognizerSpec;

package/lib/Recognizer/SpeechRecognizer.js

@@ -0,0 +1,9 @@
+import { NitroSpeech } from '../NitroSpeech';
+/**
+ * Static Speech Recognizer instance.
+ *
+ * Direct access to the all Speech Recognizer methods and callbacks.
+ *
+ * @note unsafe, might lead to race conditions
+ */
+export const SpeechRecognizer = NitroSpeech.recognizer;

package/lib/Recognizer/methods.d.ts

@@ -0,0 +1,8 @@
+import type { SpeechRecognitionConfig } from './types';
+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 recognizerGetIsActive: () => boolean;
+export declare const recognizerGetSupportedLocalesIOS: () => string[];

package/lib/Recognizer/methods.js

@@ -0,0 +1,29 @@
+import { SpeechRecognizer } from './SpeechRecognizer';
+export const recognizerStartListening = (params) => {
+    'worklet';
+    SpeechRecognizer.startListening(params);
+};
+export const recognizerStopListening = () => {
+    'worklet';
+    SpeechRecognizer.stopListening();
+};
+export const recognizerResetAutoFinishTime = () => {
+    'worklet';
+    SpeechRecognizer.resetAutoFinishTime();
+};
+export const recognizerAddAutoFinishTime = (additionalTimeMs) => {
+    'worklet';
+    SpeechRecognizer.addAutoFinishTime(additionalTimeMs);
+};
+export const recognizerUpdateConfig = (newConfig, resetAutoFinishTime) => {
+    'worklet';
+    SpeechRecognizer.updateConfig(newConfig, resetAutoFinishTime);
+};
+export const recognizerGetIsActive = () => {
+    'worklet';
+    return SpeechRecognizer.getIsActive();
+};
+export const recognizerGetSupportedLocalesIOS = () => {
+    'worklet';
+    return SpeechRecognizer.getSupportedLocalesIOS().sort();
+};

package/lib/Recognizer/types.d.ts

@@ -0,0 +1,6 @@
+import type { Recognizer as RecognizerSpec } from '../specs/Recognizer.nitro';
+import type { 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, };

package/lib/Recognizer/types.js

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

package/lib/Recognizer/useRecognizer.d.ts

@@ -0,0 +1,16 @@
+import { type DependencyList } from 'react';
+import type { RecognizerCallbacks, RecognizerMethods } from './types';
+/**
+ * Safe, lifecycle-aware hook to use the recognizer.
+ *
+ * @param callbacks - The callbacks to use for the recognizer.
+ * @param destroyDeps - The additional dependencies to use for the cleanup effect.
+ *
+ * Example: To cleanup when the screen is unfocused.
+ *
+ * ```typescript
+ * const isFocused = useIsFocused()
+ * useRecognizer({ ... }, [isFocused])
+ * ```
+ */
+export declare const useRecognizer: (callbacks: RecognizerCallbacks, destroyDeps?: DependencyList) => RecognizerMethods;

package/lib/Recognizer/useRecognizer.js

@@ -0,0 +1,71 @@
+import { useEffect } from 'react';
+import { recognizerResetAutoFinishTime, recognizerAddAutoFinishTime, recognizerUpdateConfig, recognizerGetIsActive, recognizerGetSupportedLocalesIOS, recognizerStartListening, recognizerStopListening, } from './methods';
+import { SpeechRecognizer } from './SpeechRecognizer';
+import { speechRecognizerVolumeChangeHandler } from './useVoiceInputVolume';
+/**
+ * Safe, lifecycle-aware hook to use the recognizer.
+ *
+ * @param callbacks - The callbacks to use for the recognizer.
+ * @param destroyDeps - The additional dependencies to use for the cleanup effect.
+ *
+ * Example: To cleanup when the screen is unfocused.
+ *
+ * ```typescript
+ * const isFocused = useIsFocused()
+ * useRecognizer({ ... }, [isFocused])
+ * ```
+ */
+export const useRecognizer = (callbacks, destroyDeps = []) => {
+    useEffect(() => {
+        if (callbacks.onVolumeChange) {
+            SpeechRecognizer.onVolumeChange = (event) => {
+                callbacks.onVolumeChange?.(event);
+            };
+        }
+        else {
+            SpeechRecognizer.onVolumeChange = speechRecognizerVolumeChangeHandler;
+        }
+        SpeechRecognizer.onReadyForSpeech = () => {
+            callbacks.onReadyForSpeech?.();
+        };
+        SpeechRecognizer.onRecordingStopped = () => {
+            callbacks.onRecordingStopped?.();
+        };
+        SpeechRecognizer.onResult = (resultBatches) => {
+            callbacks.onResult?.(resultBatches);
+        };
+        SpeechRecognizer.onAutoFinishProgress = (timeLeftMs) => {
+            callbacks.onAutoFinishProgress?.(timeLeftMs);
+        };
+        SpeechRecognizer.onError = (message) => {
+            callbacks.onError?.(message);
+        };
+        SpeechRecognizer.onPermissionDenied = () => {
+            callbacks.onPermissionDenied?.();
+        };
+        return () => {
+            SpeechRecognizer.onReadyForSpeech = undefined;
+            SpeechRecognizer.onRecordingStopped = undefined;
+            SpeechRecognizer.onResult = undefined;
+            SpeechRecognizer.onAutoFinishProgress = undefined;
+            SpeechRecognizer.onError = undefined;
+            SpeechRecognizer.onPermissionDenied = undefined;
+            SpeechRecognizer.onVolumeChange = undefined;
+        };
+    }, [callbacks]);
+    useEffect(() => {
+        return () => {
+            SpeechRecognizer.stopListening();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [...destroyDeps]);
+    return {
+        startListening: recognizerStartListening,
+        stopListening: recognizerStopListening,
+        resetAutoFinishTime: recognizerResetAutoFinishTime,
+        addAutoFinishTime: recognizerAddAutoFinishTime,
+        updateConfig: recognizerUpdateConfig,
+        getIsActive: recognizerGetIsActive,
+        getSupportedLocalesIOS: recognizerGetSupportedLocalesIOS,
+    };
+};

package/lib/Recognizer/useVoiceInputVolume.d.ts

@@ -0,0 +1,25 @@
+import type { RecognizerSpec, VolumeChangeEvent } from './types';
+type OnVolumeChange = RecognizerSpec['onVolumeChange'];
+/**
+ * Subscription to the voice input volume changes
+ *
+ * Updates with arbitrary frequency (many times per second) while audio recording is active.
+ *
+ * @returns The current voice input volume normalized to a range of 0 to 1.
+ */
+export declare const useVoiceInputVolume: () => VolumeChangeEvent;
+/**
+ * Direct access to default Speech Recognizer volume change handler.
+ *
+ * In case you use static Speech Recognizer:
+ *
+ * ```typescript
+ * import { speechRecognizerVolumeChangeHandler } from '@gmessier/nitro-speech'
+ *
+ * SpeechRecognizer.onVolumeChange = speechRecognizerVolumeChangeHandler
+ * ... // setup everything else
+ * SpeechRecognizer.startListening({ locale: 'en-US' })
+ * ```
+ */
+export declare const speechRecognizerVolumeChangeHandler: OnVolumeChange;
+export {};

package/lib/Recognizer/useVoiceInputVolume.js

@@ -0,0 +1,52 @@
+import { useSyncExternalStore } from 'react';
+const subscribers = new Set();
+let current = {
+    smoothedVolume: 0,
+    rawVolume: 0,
+    db: undefined,
+};
+let snapshot = { ...current };
+const getSnapshot = () => {
+    if (snapshot.smoothedVolume === current.smoothedVolume &&
+        snapshot.rawVolume === current.rawVolume &&
+        snapshot.db === current.db) {
+        return snapshot;
+    }
+    snapshot = { ...current };
+    return snapshot;
+};
+/**
+ * Subscription to the voice input volume changes
+ *
+ * Updates with arbitrary frequency (many times per second) while audio recording is active.
+ *
+ * @returns The current voice input volume normalized to a range of 0 to 1.
+ */
+export const useVoiceInputVolume = () => {
+    return useSyncExternalStore((subscriber) => {
+        subscribers.add(subscriber);
+        return () => subscribers.delete(subscriber);
+    }, getSnapshot);
+};
+/**
+ * Direct access to default Speech Recognizer volume change handler.
+ *
+ * In case you use static Speech Recognizer:
+ *
+ * ```typescript
+ * import { speechRecognizerVolumeChangeHandler } from '@gmessier/nitro-speech'
+ *
+ * SpeechRecognizer.onVolumeChange = speechRecognizerVolumeChangeHandler
+ * ... // setup everything else
+ * SpeechRecognizer.startListening({ locale: 'en-US' })
+ * ```
+ */
+export const speechRecognizerVolumeChangeHandler = (event) => {
+    if (event.smoothedVolume === current.smoothedVolume &&
+        event.rawVolume === current.rawVolume &&
+        event.db === current.db) {
+        return;
+    }
+    current = event;
+    subscribers.forEach((subscriber) => subscriber?.(event));
+};

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Recognizer/useRecognizer';
+export * from './Recognizer/useVoiceInputVolume';
+export * from './Recognizer/SpeechRecognizer';
+export * from './Recognizer/RecognizerRef';
+export * from './Recognizer/types';
+export * from './NitroSpeech';

package/lib/index.js

@@ -0,0 +1,6 @@
+export * from './Recognizer/useRecognizer';
+export * from './Recognizer/useVoiceInputVolume';
+export * from './Recognizer/SpeechRecognizer';
+export * from './Recognizer/RecognizerRef';
+export * from './Recognizer/types';
+export * from './NitroSpeech';

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

@@ -0,0 +1,8 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { Recognizer } from './Recognizer.nitro';
+export interface NitroSpeech extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    recognizer: Recognizer;
+}

package/lib/specs/NitroSpeech.nitro.js

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