react-native-davoice 1.0.4

package/stt/index.d.ts

@@ -0,0 +1,54 @@
+type SpeechStartEvent = {};
+type SpeechEndEvent = {};
+type SpeechRecognizedEvent = {
+    isFinal: boolean;
+};
+type SpeechErrorEvent = {
+    error: {
+        code?: string;
+        message?: string;
+    };
+};
+type SpeechResultsEvent = {
+    value: string[];
+};
+type SpeechVolumeChangeEvent = {
+    value: number;
+};
+type SpeechEvents = {
+    onSpeechStart?: (e: SpeechStartEvent) => void;
+    onSpeechRecognized?: (e: SpeechRecognizedEvent) => void;
+    onSpeechEnd?: (e: SpeechEndEvent) => void;
+    onSpeechError?: (e: SpeechErrorEvent) => void;
+    onSpeechResults?: (e: SpeechResultsEvent) => void;
+    onSpeechPartialResults?: (e: SpeechResultsEvent) => void;
+    onSpeechVolumeChanged?: (e: SpeechVolumeChangeEvent) => void;
+};
+declare class RCTSTT {
+    private _loaded;
+    private _listeners;
+    private _events;
+    constructor();
+    /** Remove static handlers on the native module (parity with old Voice bridge). */
+    removeAllListeners(): void;
+    /** Destroy/native teardown (parity with old API). */
+    destroy(): Promise<void>;
+    /** Start recognition — mirrors old `.start(locale, options?)` */
+    start(locale: string, options?: Record<string, any>): Promise<void>;
+    stop(): Promise<void>;
+    cancel(): Promise<void>;
+    setLicense(licenseKey: string): Promise<boolean>;
+    isLicenseValid(licenseKey: string): Promise<boolean>;
+    isAvailable(): Promise<0 | 1>;
+    isRecognizing(): Promise<0 | 1>;
+    set onSpeechStart(fn: (e: SpeechStartEvent) => void);
+    set onSpeechRecognized(fn: (e: SpeechRecognizedEvent) => void);
+    set onSpeechEnd(fn: (e: SpeechEndEvent) => void);
+    set onSpeechError(fn: (e: SpeechErrorEvent) => void);
+    set onSpeechResults(fn: (e: SpeechResultsEvent) => void);
+    set onSpeechPartialResults(fn: (e: SpeechResultsEvent) => void);
+    set onSpeechVolumeChanged(fn: (e: SpeechVolumeChangeEvent) => void);
+}
+export type { SpeechEndEvent, SpeechErrorEvent, SpeechEvents, SpeechStartEvent, SpeechRecognizedEvent, SpeechResultsEvent, SpeechVolumeChangeEvent, };
+declare const _default: RCTSTT;
+export default _default;

package/stt/index.ts

@@ -0,0 +1,222 @@
+// stt/index.ts
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+
+// Prefer new names; gracefully fall back to legacy names during migration.
+const STTNative =
+  NativeModules.STT ||
+  NativeModules.RCTSTT ||
+  NativeModules.Voice ||
+  NativeModules.RCTVoice;
+
+if (STTNative) {
+  console.log('STTNative loaded:', Object.keys(STTNative));
+} else {
+  console.error('STT native module is not linked correctly.');
+}
+
+type SpeechStartEvent = { /* keep your shape if you had TS types */ };
+type SpeechEndEvent = {};
+type SpeechRecognizedEvent = { isFinal: boolean };
+type SpeechErrorEvent = { error: { code?: string; message?: string } };
+type SpeechResultsEvent = { value: string[] };
+type SpeechVolumeChangeEvent = { value: number };
+
+type SpeechEvents = {
+  onSpeechStart?: (e: SpeechStartEvent) => void;
+  onSpeechRecognized?: (e: SpeechRecognizedEvent) => void;
+  onSpeechEnd?: (e: SpeechEndEvent) => void;
+  onSpeechError?: (e: SpeechErrorEvent) => void;
+  onSpeechResults?: (e: SpeechResultsEvent) => void;
+  onSpeechPartialResults?: (e: SpeechResultsEvent) => void;
+  onSpeechVolumeChanged?: (e: SpeechVolumeChangeEvent) => void;
+};
+
+const sttEmitter =
+  Platform.OS !== 'web' && STTNative ? new NativeEventEmitter(STTNative) : null;
+
+type SpeechEventName = keyof Required<SpeechEvents>;
+
+class RCTSTT {
+  private _loaded: boolean;
+  private _listeners: Array<{ remove: () => void }> | null;
+  private _events: Required<SpeechEvents>;
+
+  constructor() {
+    this._loaded = false;
+    this._listeners = null;
+    this._events = {
+      onSpeechStart: () => {},
+      onSpeechRecognized: () => {},
+      onSpeechEnd: () => {},
+      onSpeechError: () => {},
+      onSpeechResults: () => {},
+      onSpeechPartialResults: () => {},
+      onSpeechVolumeChanged: () => {},
+    };
+  }
+
+  /** Remove static handlers on the native module (parity with old Voice bridge). */
+  removeAllListeners() {
+    if (!STTNative) return;
+    STTNative.onSpeechStart = undefined;
+    STTNative.onSpeechRecognized = undefined;
+    STTNative.onSpeechEnd = undefined;
+    STTNative.onSpeechError = undefined;
+    STTNative.onSpeechResults = undefined;
+    STTNative.onSpeechPartialResults = undefined;
+    STTNative.onSpeechVolumeChanged = undefined;
+  }
+
+  /** Destroy/native teardown (parity with old API). */
+  destroy(): Promise<void> {
+    if (!this._loaded && !this._listeners) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      if (!STTNative?.destroySpeech) {
+        // Fallback: tolerate older native
+        this._listeners?.forEach(l => l.remove?.());
+        this._listeners = null;
+        resolve();
+        return;
+      }
+      STTNative.destroySpeech((error: string) => {
+        if (error) {
+          reject(new Error(error));
+        } else {
+          this._listeners?.forEach(l => l.remove?.());
+          this._listeners = null;
+          resolve();
+        }
+      });
+    });
+  }
+
+  /** Start recognition — mirrors old `.start(locale, options?)` */
+  start(locale: string, options: Record<string, any> = {}) {
+    if (!this._loaded && !this._listeners && sttEmitter) {
+      this._listeners = (Object.keys(this._events) as SpeechEventName[]).map(
+        (key: SpeechEventName) => sttEmitter.addListener(key, this._events[key]),
+      );
+    }
+    return new Promise<void>((resolve, reject) => {
+      const cb = (error: string) => (error ? reject(new Error(error)) : resolve());
+
+      if (Platform.OS === 'android' && STTNative?.startSpeech) {
+        // Keep Android parity with your previous voice bridge contract
+        STTNative.startSpeech(
+          locale,
+          {
+            EXTRA_LANGUAGE_MODEL: 'LANGUAGE_MODEL_FREE_FORM',
+            EXTRA_MAX_RESULTS: 5,
+            EXTRA_PARTIAL_RESULTS: true,
+            REQUEST_PERMISSIONS_AUTO: true,
+            ...options,
+          },
+          cb,
+        );
+      } else if (STTNative?.startSpeech) {
+        STTNative.startSpeech(locale, cb);
+      } else if (STTNative?.start) {
+        STTNative.start(locale, cb);
+      } else {
+        reject(new Error('STTNative.startSpeech not available'));
+      }
+    });
+  }
+
+  stop(): Promise<void> {
+    if (!this._loaded && !this._listeners) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      if (!STTNative?.stopSpeech) return resolve();
+      STTNative.stopSpeech((error: string) => {
+        error ? reject(new Error(error)) : resolve();
+      });
+    });
+  }
+
+  cancel(): Promise<void> {
+    if (!this._loaded && !this._listeners) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      if (!STTNative?.cancelSpeech) return resolve();
+      STTNative.cancelSpeech((error: string) => {
+        error ? reject(new Error(error)) : resolve();
+      });
+    });
+  }
+
+  setLicense(licenseKey: string): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      if (!STTNative?.setLicense) {
+        reject(new Error('STTNative.setLicense not available'));
+        return;
+      }
+      STTNative.setLicense(licenseKey).then(resolve).catch(reject);
+    });
+  }
+
+  isLicenseValid(licenseKey: string): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      if (!STTNative?.isLicenseValid) {
+        reject(new Error('STTNative.isLicenseValid not available'));
+        return;
+      }
+      STTNative.isLicenseValid(licenseKey).then(resolve).catch(reject);
+    });
+  }
+
+  isAvailable(): Promise<0 | 1> {
+    return new Promise((resolve, reject) => {
+      if (!STTNative?.isSpeechAvailable) {
+        // Best effort fallback
+        resolve(1);
+        return;
+      }
+      STTNative.isSpeechAvailable((isAvailable: 0 | 1, error: string) => {
+        error ? reject(new Error(error)) : resolve(isAvailable);
+      });
+    });
+  }
+
+  isRecognizing(): Promise<0 | 1> {
+    return new Promise(resolve => {
+      if (!STTNative?.isRecognizing) return resolve(0);
+      STTNative.isRecognizing((isRecognizing: 0 | 1) => resolve(isRecognizing));
+    });
+  }
+
+  // Event setters (unchanged names so your app code stays the same)
+  set onSpeechStart(fn: (e: SpeechStartEvent) => void) {
+    this._events.onSpeechStart = fn;
+  }
+  set onSpeechRecognized(fn: (e: SpeechRecognizedEvent) => void) {
+    this._events.onSpeechRecognized = fn;
+  }
+  set onSpeechEnd(fn: (e: SpeechEndEvent) => void) {
+    this._events.onSpeechEnd = fn;
+  }
+  set onSpeechError(fn: (e: SpeechErrorEvent) => void) {
+    this._events.onSpeechError = fn;
+  }
+  set onSpeechResults(fn: (e: SpeechResultsEvent) => void) {
+    this._events.onSpeechResults = fn;
+  }
+  set onSpeechPartialResults(fn: (e: SpeechResultsEvent) => void) {
+    this._events.onSpeechPartialResults = fn;
+  }
+  set onSpeechVolumeChanged(fn: (e: SpeechVolumeChangeEvent) => void) {
+    this._events.onSpeechVolumeChanged = fn;
+  }
+}
+
+export type {
+  SpeechEndEvent,
+  SpeechErrorEvent,
+  SpeechEvents,
+  SpeechStartEvent,
+  SpeechRecognizedEvent,
+  SpeechResultsEvent,
+  SpeechVolumeChangeEvent,
+};
+
+export default new RCTSTT();

package/tts/DaVoiceTTSBridge.d.ts

@@ -0,0 +1,18 @@
+export class DaVoiceTTSInstance {
+    constructor(instanceId?: string);
+    instanceId: string;
+    _emitter: NativeEventEmitter | null;
+    _subs: any[];
+    initTTS(modelOrConfig: any): Promise<any>;
+    setLicense(licenseKey: any): Promise<any>;
+    isLicenseValid(licenseKey: any): Promise<any>;
+    speak(text: any, speakerId?: number): Promise<any>;
+    stopSpeaking(): Promise<any>;
+    destroy(): Promise<any>;
+    /**
+     * Subscribe to “finished speaking the last WAV of the latest synthesize_top call”.
+     * Returns an unsubscribe function.
+     */
+    onFinishedSpeaking(callback: any): () => void;
+}
+import { NativeEventEmitter } from 'react-native';

package/tts/DaVoiceTTSBridge.js

@@ -0,0 +1,71 @@
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+
+const { DaVoiceTTSBridge } = NativeModules;
+
+if (DaVoiceTTSBridge) {
+  console.log('DaVoiceTTSBridge is loaded:', DaVoiceTTSBridge);
+} else {
+  console.error('DaVoiceTTSBridge is not linked correctly.');
+}
+
+export class DaVoiceTTSInstance {
+  instanceId; // optional future use
+
+  constructor(instanceId = 'default') {
+    this.instanceId = instanceId;
+    this._emitter = DaVoiceTTSBridge ? new NativeEventEmitter(DaVoiceTTSBridge) : null;
+    this._subs = [];
+  }
+
+  async initTTS(modelOrConfig) {
+    const config =
+      typeof modelOrConfig === 'string'
+        ? { model: modelOrConfig }
+        : modelOrConfig || {};
+    if (!config.model) {
+      throw new Error("initTTS: missing 'model' (expected string path or { model: string })");
+    }
+    return await DaVoiceTTSBridge.initTTS(modelOrConfig);
+  }
+
+  async setLicense(licenseKey) {
+    return await DaVoiceTTSBridge.setLicense(licenseKey);
+  }
+
+  async isLicenseValid(licenseKey) {
+    return await DaVoiceTTSBridge.isLicenseValid(licenseKey);
+  }
+
+  async speak(text, speakerId = 0) {
+    return await DaVoiceTTSBridge.speak(text, speakerId);
+  }
+
+  async stopSpeaking() {
+    return await DaVoiceTTSBridge.stopSpeaking();
+  }
+
+  async destroy() {
+    const res = await DaVoiceTTSBridge.destroy();
+    // Clean up JS listeners on destroy (good hygiene)
+    this._subs.forEach(s => {
+      try { s.remove(); } catch {}
+    });
+    this._subs = [];
+    return res;
+  }
+  /**
+   * Subscribe to “finished speaking the last WAV of the latest synthesize_top call”.
+   * Returns an unsubscribe function.
+   */
+  onFinishedSpeaking(callback) {
+    if (!this._emitter) {
+      throw new Error('NativeEventEmitter not available (bridge missing).');
+    }
+    const sub = this._emitter.addListener('onFinishedSpeaking', callback);
+    this._subs.push(sub);
+    return () => {
+      try { sub.remove(); } catch {}
+      this._subs = this._subs.filter(s => s !== sub);
+    };
+  }
+}

package/tts/index.d.ts

@@ -0,0 +1,3 @@
+export { DaVoiceTTSInstance };
+export default DaVoiceTTSInstance;
+import { DaVoiceTTSInstance } from './DaVoiceTTSBridge';

package/tts/index.js

@@ -0,0 +1,4 @@
+import { DaVoiceTTSInstance } from './DaVoiceTTSBridge';
+
+export { DaVoiceTTSInstance };
+export default DaVoiceTTSInstance;