react-native-davoice-tts 1.0.345 → 1.0.346

package/speech/index.ts

@@ -35,6 +35,7 @@ function sleep(ms: number) {
 }
 
 let speechOpSeq = 0;
+const PROBABLY_GPT_MISTAKE = false;
 function nextSpeechOpId(prefix: string) {
   speechOpSeq += 1;
   return `${prefix}-${speechOpSeq}-${Date.now()}`;
@@ -157,9 +158,22 @@ class Speech {
   }
 
   private _nativeSpeak(text: string, speakerId: number, s: number) {
-    if (Platform.OS === 'ios' && NativeSpeech?.speak) return (NativeSpeech as any).speak(text, speakerId, s);
-    if (!NativeTTS?.speak) throw new Error('TTS speak not available');
-    return (NativeTTS as any).speak(text, speakerId, s);
+    const nativeTtsSpeak = () => {
+      if (!NativeTTS?.speak) throw new Error('TTS speak not available');
+      if (Platform.OS === 'ios') {
+        if ((NativeTTS as any).speakWithSpeed) return (NativeTTS as any).speakWithSpeed(text, speakerId, s);
+        return (NativeTTS as any).speak(text, speakerId);
+      }
+      return (NativeTTS as any).speak(text, speakerId, s);
+    };
+
+    if (Platform.OS === 'ios') {
+      if (this.iosTtsOnly && NativeTTS?.speak) return nativeTtsSpeak();
+      if (this.hasCompletedFullInit && NativeSpeech?.speak) return (NativeSpeech as any).speak(text, speakerId, s);
+      if (this.hasCompletedTtsInit && NativeTTS?.speak) return nativeTtsSpeak();
+      if (NativeSpeech?.speak) return (NativeSpeech as any).speak(text, speakerId, s);
+    }
+    return nativeTtsSpeak();
   }
 
   private enqueueSttTransition(opId: string, kind: 'pause' | 'unpause', work: () => Promise<void>): Promise<void> {
@@ -209,6 +223,7 @@ class Speech {
   private lastModel: string | null = null;
   private lastOnboardingJsonPath: string | null = null;
   private hasCompletedFullInit = false;
+  private hasCompletedTtsInit = false;
   private iosTtsOnly = false; // when true, use NativeTTS directly on iOS
 
 
@@ -303,9 +318,12 @@ class Speech {
   // if iOS unified + NOT tts-only -> use unified emitter
   if (Platform.OS === 'ios' && NativeSpeech && !this.iosTtsOnly) {
     this.unifiedEmitter = new NativeEventEmitter(NativeSpeech);
+    this.sttEmitter = null;
+    this.ttsEmitter = null;
     // unified handles both STT + TTS events
   } else {
     // fallback: separate emitters
+    this.unifiedEmitter = null;
     if (NativeSTT) this.sttEmitter = new NativeEventEmitter(NativeSTT);
     if (Platform.OS === 'android') this.ttsEmitter = DeviceEventEmitter;
     else if (NativeTTS) this.ttsEmitter = new NativeEventEmitter(NativeTTS);
@@ -414,11 +432,15 @@ class Speech {
     this.lastOnboardingJsonPath = opts.onboardingJsonPath ?? null;
 
     if (Platform.OS === 'ios' && NativeSpeech?.initAll) {
+      if (this.iosTtsOnly) {
+        try { await NativeTTS?.destroy?.(); } catch {}
+        this.hasCompletedTtsInit = false;
+      }
       this.iosTtsOnly = false;                  // full unified mode
-      this.teardownListeners();                 // re-wire listeners for unified
       const r = await NativeSpeech.initAll({ ...opts, model: modelPath });
       this.hasCompletedFullInit = true;
-      this.ensureListeners();
+      this.hasCompletedTtsInit = true;
+      this.rewireListenersForMode();
       return r;
     }
 
@@ -468,6 +490,7 @@ class Speech {
     console.log('[MODELDBG] initAll.modelExt (resolved)=', modelExt);
     await NativeTTS.initTTS({ model: modelPath, modelExt });
     this.hasCompletedFullInit = true;
+    this.hasCompletedTtsInit = true;
   }
 
   async destroyAll() {
@@ -475,10 +498,21 @@ class Speech {
     this.ttsChain = Promise.resolve();
     this.wavChain = Promise.resolve();
 
+    // iOS TTS-only mode: initTTS() used the standalone TTS bridge, so do not
+    // tear down SpeechBridge/STT state that was never started by this path.
+    if (Platform.OS === 'ios' && this.iosTtsOnly && !this.hasCompletedFullInit) {
+      try { await NativeTTS?.destroy?.(); } catch {}
+      this.hasCompletedTtsInit = false;
+      this.iosTtsOnly = false;
+      this.teardownListeners();
+      return 'Destroyed';
+    }
+
     // iOS unified
     if (Platform.OS === 'ios' && NativeSpeech?.destroyAll) {
       const r = await NativeSpeech.destroyAll();
       this.hasCompletedFullInit = false;
+      this.hasCompletedTtsInit = false;
       this.iosTtsOnly = false;
       this.lastLocale = this.lastLocale ?? null;
       this.teardownListeners();
@@ -493,6 +527,7 @@ class Speech {
       });
     } catch {}
     this.hasCompletedFullInit = false;
+    this.hasCompletedTtsInit = false;
     this.teardownListeners();
     return 'Destroyed';
   }
@@ -643,22 +678,21 @@ class Speech {
   // TODO: CHECK THE NATIVE SIDE DOES NOT REALLY AWAITS
   async pauseSpeechRecognition(): Promise<void> {
     this.logCall('pauseSpeechRecognitionLite');
-    const opId = nextSpeechOpId('pause-stt');
     const startedAt = Date.now();
 
     const mod: any = Platform.OS === 'ios' ? NativeSpeech : NativeSTT;
     const fn = mod?.pauseSpeechRecognitionLite;
 
-    await this.enqueueSttTransition(opId, 'pause', async () => {
+    const work = async (opId?: string) => {
       if (!fn) {
         dbg(`pauseSpeechRecognitionLite not available on ${Platform.OS === 'ios' ? 'NativeSpeech' : 'NativeSTT'}`);
         return;
       }
 
       if (Platform.OS === 'ios' && typeof mod?.pauseSpeechRecognitionLiteAsync === 'function') {
-        dbg('[pauseSpeechRecognitionLiteAsync] begin', { opId, timeoutMs: 1500 });
+        dbg('[pauseSpeechRecognitionLiteAsync] begin', { ...(opId ? { opId } : {}), timeoutMs: 1500 });
         const result = await mod.pauseSpeechRecognitionLiteAsync(1500);
-        dbg('[pauseSpeechRecognitionLiteAsync] resolved', { opId, elapsedMs: Date.now() - startedAt, result });
+        dbg('[pauseSpeechRecognitionLiteAsync] resolved', { ...(opId ? { opId } : {}), elapsedMs: Date.now() - startedAt, result });
         if (result?.ok === false) dbgErr('pauseSpeechRecognitionLiteAsync failed', result?.reason);
         return;
       }
@@ -688,7 +722,15 @@ class Speech {
           reject(e as any);
         }
       });
-    });
+    };
+
+    if (PROBABLY_GPT_MISTAKE) {
+      const opId = nextSpeechOpId('pause-stt');
+      await this.enqueueSttTransition(opId, 'pause', () => work(opId));
+      return;
+    }
+
+    await work();
   }
 
   async unPauseSpeechRecognition(
@@ -697,23 +739,22 @@ class Speech {
     timeoutMs: number = 2500,
   ): Promise<void> {
     this.logCall('unPauseSpeechRecognitionLite', { times, preFetchMs });
-    const opId = nextSpeechOpId('unpause-stt');
     const startedAt = Date.now();
 
     const mod: any = Platform.OS === 'ios' ? NativeSpeech : NativeSTT;
     const fn = mod?.unPauseSpeechRecognitionLite;
 
-    await this.enqueueSttTransition(opId, 'unpause', async () => {
+    const work = async (opId?: string) => {
       if (!fn) {
         dbg(`unPauseSpeechRecognitionLite(times) not available on ${Platform.OS === 'ios' ? 'NativeSpeech' : 'NativeSTT'}`);
         return;
       }
 
       if (Platform.OS === 'ios' && typeof mod?.unPauseSpeechRecognitionLiteAsync === 'function') {
-        dbg('[unPauseSpeechRecognitionLiteAsync] begin', { opId, times, preFetchMs, timeoutMs });
+        dbg('[unPauseSpeechRecognitionLiteAsync] begin', { ...(opId ? { opId } : {}), times, preFetchMs, timeoutMs });
         const result = await mod.unPauseSpeechRecognitionLiteAsync(times, preFetchMs, timeoutMs);
         dbg('[unPauseSpeechRecognitionLiteAsync] resolved', {
-          opId,
+          ...(opId ? { opId } : {}),
           times,
           preFetchMs,
           elapsedMs: Date.now() - startedAt,
@@ -763,7 +804,15 @@ class Speech {
           reject(e as any);
         }
       });
-    });
+    };
+
+    if (PROBABLY_GPT_MISTAKE) {
+      const opId = nextSpeechOpId('unpause-stt');
+      await this.enqueueSttTransition(opId, 'unpause', () => work(opId));
+      return;
+    }
+
+    await work();
   }
   /** Pause mic/STT (Android native; iOS unified if present) */
   async pauseMicrophone(): Promise<void> {
@@ -956,9 +1005,23 @@ class Speech {
     //   throw new Error('Use initAll() on iOS unified bridge.');
     // }
     if (!cfg?.model) throw new Error("initTTS: missing 'model'");
+    if (Platform.OS === 'ios' && this.hasCompletedFullInit) {
+      this.iosTtsOnly = false;
+      this.rewireListenersForMode();
+      return 'TTS already initialized by initAll';
+    }
+    if (!NativeTTS?.initTTS) throw new Error('Native TTS module missing initTTS()');
     const modelPath = this.resolveModelToPath(cfg.model);
     this.lastModel = modelPath;
-    return NativeTTS.initTTS({ model: modelPath });
+    const r = await NativeTTS.initTTS({ model: modelPath });
+    this.hasCompletedTtsInit = true;
+    if (Platform.OS === 'ios' && !this.hasCompletedFullInit) {
+      this.iosTtsOnly = true;
+      this.rewireListenersForMode();
+    } else {
+      this.ensureListeners();
+    }
+    return r;
   }
 
   async speak(text: string, speakerId = 0, speed = 1.0) {
@@ -1000,6 +1063,9 @@ class Speech {
 
     // 2) tell native to stop
     try {
+      if (Platform.OS === 'ios' && this.iosTtsOnly && NativeTTS?.stopSpeaking) {
+        return await NativeTTS.stopSpeaking();
+      }
       if (Platform.OS === 'ios' && NativeSpeech?.stopSpeaking) {
         return await NativeSpeech.stopSpeaking();
       }
@@ -1174,7 +1240,7 @@ class Speech {
     if (this.subs.length) return;
 
     // iOS unified: subscribe once on the unified emitter
-    if (Platform.OS === 'ios' && this.unifiedEmitter) {
+    if (Platform.OS === 'ios' && !this.iosTtsOnly && this.unifiedEmitter) {
       const map: Partial<Record<NativeEventName, (...args: any[]) => void>> = {
         onSpeechStart: (e) => this.handlers.onSpeechStart(e),
         onSpeechRecognized: (e) => this.handlers.onSpeechRecognized(e),