react-native-davoice-tts 1.0.387 → 1.0.389

package/TTSRNBridge.podspec

@@ -2,7 +2,7 @@ require 'json'
 
 Pod::Spec.new do |s|
     s.name         = "TTSRNBridge"
-    s.version      = "1.0.339" # Update to your package version
+    s.version      = "1.0.345" # Update to your package version
     s.summary      = "TTS for React Native."
     s.description  = <<-DESC
                      A React Native module for tts .

package/ios/SpeechBridge/SpeechBridge.m

@@ -22,6 +22,22 @@ static void SBDebugLog(NSString *format, ...)
   va_end(args);
 }
 
+// Stable on-disk location for a downloaded http(s) asset, keyed by URL. Metro asset
+// URLs carry a content hash, so the same URL means the same bytes and the file can be
+// reused across calls and launches instead of re-downloading (e.g. on every wake-word
+// ping sound in a debug build) every time.
+static NSString *SBCachedFilePathForRemoteAsset(NSString *urlString) {
+  NSString *ext = [NSURL URLWithString:urlString].pathExtension;
+  if (ext.length == 0) ext = @"wav";
+  unsigned long long h = 1469598103934665603ULL;  // FNV-1a: deterministic across launches
+  for (NSUInteger i = 0; i < urlString.length; i++) {
+    h ^= (unsigned long long)[urlString characterAtIndex:i];
+    h *= 1099511628211ULL;
+  }
+  NSString *name = [NSString stringWithFormat:@"rn_asset_%016llx.%@", h, ext];
+  return [NSTemporaryDirectory() stringByAppendingPathComponent:name];
+}
+
 static NSData *SB_Base64Decode(NSString *b64) {
   if (!b64 || (id)b64 == [NSNull null]) return nil;
   return [[NSData alloc] initWithBase64EncodedString:b64 options:0];
@@ -137,6 +153,34 @@ static AVAudioPCMBuffer *SB_MakeMonoF32Buffer(NSData *raw,
   return buf;
 }
 
+// The STT/DaVoiceTTS core is main-queue affine: it schedules its own internal
+// polling on the main queue and mutates AVAudioEngine/task state without a lock
+// guarding every access, so every touch of self.stt from this bridge must also
+// stay on main -- mixing threads here races that internal state. -methodQueue
+// below keeps every RCT_EXPORT_METHOD call on main already; this guard exists
+// so a future call site added off that path (a completion handler, a hop to a
+// background queue, etc.) fails loudly instead of silently reintroducing that
+// race. DEBUG asserts at the violating frame; release logs once via NSLog
+// rather than RCTLogError, since RCTLogError is a no-op in a release build
+// with no log function installed (RCTLog.mm gates on RCT_DEBUG || logFunction).
+static void SBReportOffMainQueueSTTAccess(const char *where)
+{
+  NSLog(@"[SpeechBridge] self.stt accessed off the main queue in %s. STT/DaVoiceTTS "
+        @"is main-queue-affine; see -methodQueue.", where);
+}
+
+// dispatch_assert_queue, not [NSThread isMainThread]: a dispatch_sync from main onto
+// another serial queue runs on the main THREAD while off the main QUEUE, which
+// isMainThread would incorrectly pass.
+#if DEBUG
+  #define SBAssertSTTOnMainQueue() dispatch_assert_queue(dispatch_get_main_queue())
+#else
+  #define SBAssertSTTOnMainQueue() \
+    do { \
+      if (![NSThread isMainThread]) { SBReportOffMainQueueSTTAccess(__PRETTY_FUNCTION__); } \
+    } while (0)
+#endif
+
 @interface SpeechBridge () <STTDelegate>
 @property (nonatomic, strong, nullable) STT *stt;
 @property (nonatomic, strong, nullable) DaVoiceTTS *tts;
@@ -152,6 +196,47 @@ static AVAudioPCMBuffer *SB_MakeMonoF32Buffer(NSData *raw,
 
 @implementation SpeechBridge
 
+// Explicit accessors so the main-queue guard covers every read and write of
+// self.stt. Explicit accessors disable autosynthesis, hence the @synthesize.
+@synthesize stt = _stt;
+
+- (STT *)stt
+{
+  SBAssertSTTOnMainQueue();
+  return _stt;
+}
+
+- (void)setStt:(STT *)stt
+{
+  SBAssertSTTOnMainQueue();
+  _stt = stt;
+}
+
+// Single teardown path for the STT instance.
+//
+// Every call site used to be `[self.stt destroySpeech:nil]; self.stt = nil;`, which
+// cleared the ivar only after the teardown call had already started, so other
+// main-queue work could observe a half-destroyed STT through self.stt in between.
+// Clearing the ivar first closes that window; the strong local keeps the instance
+// alive for the duration of the call.
+//
+// The completion is deliberately nil, matching every existing call site. Passing a
+// block that captures the instance would hand its lifetime to the framework: the
+// final release would then happen wherever the framework drops the block, so
+// -[STT dealloc] and the AVAudioEngine teardown inside it could run off the main
+// queue -- the exact affinity violation this file exists to prevent, and it would
+// not trip the guard above, because dealloc does not go through the property.
+- (void)tearDownSTT
+{
+  SBAssertSTTOnMainQueue();
+  STT *dyingSTT = _stt;
+  if (!dyingSTT) { return; }
+  _stt = nil;
+  @try {
+    [dyingSTT destroySpeech:nil];
+  } @catch (__unused id e) {}
+}
+
 RCT_EXPORT_MODULE(SpeechBridge)
 
 // We emit the union of STT + TTS events
@@ -178,15 +263,42 @@ RCT_EXPORT_MODULE(SpeechBridge)
 
 - (void)dealloc
 {
-  // destroy in the safe order: TTS → STT
-  if (_tts) { [_tts destroy]; _tts = nil; }
-  if (_stt) { [_stt destroySpeech:nil]; _stt = nil; }
+  // dealloc is not guaranteed to run on the main queue -- the last release can come
+  // from a bridge invalidation on any thread -- and [DaVoiceTTS destroy] /
+  // [STT destroySpeech:] are the same main-affine calls SBAssertSTTOnMainQueue exists
+  // to keep on main. Exempting dealloc from that rule would put full audio teardown
+  // off main at the one site where it is least recoverable, so hop instead. Only the
+  // locals are captured, never self, so this is safe from inside dealloc; the
+  // destroy order stays TTS then STT.
+  DaVoiceTTS *dyingTTS = _tts;
+  STT *dyingSTT = _stt;
+  _tts = nil;
+  _stt = nil;
+  if (!dyingTTS && !dyingSTT) { return; }
+
+  void (^teardown)(void) = ^{
+    @try { [dyingTTS destroy]; } @catch (__unused id e) {}
+    @try { [dyingSTT destroySpeech:nil]; } @catch (__unused id e) {}
+  };
+  if ([NSThread isMainThread]) {
+    teardown();
+  } else {
+    dispatch_async(dispatch_get_main_queue(), teardown);
+  }
 }
 
 #pragma mark - STTDelegate (forward all events)
 
 - (void)stt:(STT *)stt didEmitEvent:(NSString *)name body:(NSDictionary *)body
 {
+  // Ignore events from an STT we have already torn down. A dying instance stays our
+  // delegate until it deallocs, so without this check a trailing onSpeechStart from
+  // the old instance could latch sttEngineHot while the NEW recognizer (created by a
+  // fresh initAll()/initWithoutModel() racing the old instance's teardown) has not
+  // actually started -- reporting init success to JS before voice input is live.
+  // Compared against the ivar directly, not self.stt: this is invoked from the
+  // framework's own callback thread and must not trip the main-queue guard.
+  if (stt != _stt) { return; }
   // Use the first onSpeechStart as the “engine hot” latch.
   if ([name isEqualToString:@"onSpeechStart"] && !self.sttEngineHot) {
     self.sttEngineHot = YES;
@@ -279,6 +391,16 @@ RCT_EXPORT_MODULE(SpeechBridge)
   };
 }
 
+// Ticks on a private queue, delivers the verdict on main.
+//
+// The tick only reads self.sttEngineHot (atomic) and a clock -- no UIKit, no self.stt
+// -- so it has no reason to occupy the main queue, while timeoutMs defaults to
+// 7200000ms above, meaning an engine that never reports hot would otherwise leave a
+// 50ms main-queue timer running for two hours. The completion is different: it is
+// only ever invoked from initAll()/initWithoutModel(), where it writes
+// self.initializing/self.initialized and resolves/rejects the caller's JS promise, so
+// it is hopped back to main to keep that state single-threaded and to respect
+// SBAssertSTTOnMainQueue on any self.stt access inside a caller's completion.
 - (void)waitForSTTEngineHotWithTimeoutMs:(NSNumber *)timeoutMs
                               completion:(void (^)(BOOL ok))completion
 {
@@ -287,26 +409,39 @@ RCT_EXPORT_MODULE(SpeechBridge)
 
   CFTimeInterval deadline = CACurrentMediaTime() + MAX(0.1, t.doubleValue / 1000.0);
 
+  static dispatch_queue_t pollQueue;
+  static dispatch_once_t pollQueueOnce;
+  dispatch_once(&pollQueueOnce, ^{
+    pollQueue = dispatch_queue_create("com.davoice.SpeechBridge.enginehot", DISPATCH_QUEUE_SERIAL);
+  });
+
+  void (^deliver)(BOOL) = ^(BOOL ok) {
+    dispatch_async(dispatch_get_main_queue(), ^{ completion(ok); });
+  };
+
   __weak typeof(self) weakSelf = self;
   __block void (^poll)(void) = ^{
     __strong typeof(weakSelf) strongSelf = weakSelf;
     if (!strongSelf) {
-      completion(NO);
+      poll = nil;
+      deliver(NO);
       return;
     }
     if (strongSelf.sttEngineHot) {
-      completion(YES);
+      poll = nil;
+      deliver(YES);
       return;
     }
     if (CACurrentMediaTime() >= deadline) {
-      completion(NO);
+      poll = nil;
+      deliver(NO);
       return;
     }
     dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.05 * NSEC_PER_SEC)),
-                   dispatch_get_main_queue(), poll);
+                   pollQueue, poll);
   };
 
-  dispatch_async(dispatch_get_main_queue(), poll);
+  dispatch_async(pollQueue, poll);
 }
 
 RCT_EXPORT_METHOD(hasMicPermissions:(RCTPromiseResolveBlock)resolve
@@ -536,8 +671,7 @@ RCT_EXPORT_METHOD(initAll:(NSDictionary *)opts
 
       if (!modelURL) {
         self.initializing = NO;
-        [self.stt destroySpeech:nil];
-        self.stt = nil;
+        [self tearDownSTT];
         reject(@"bad_model", [NSString stringWithFormat:@"Could not resolve model path: %@", modelPath], nil);
         return;
       }
@@ -545,8 +679,7 @@ RCT_EXPORT_METHOD(initAll:(NSDictionary *)opts
       // Verify file exists for local file URLs (skip for bare .dm fallback — native core will search)
       if (!isBareDmName && modelURL.isFileURL && ![[NSFileManager defaultManager] fileExistsAtPath:modelURL.path]) {
         self.initializing = NO;
-        [self.stt destroySpeech:nil];
-        self.stt = nil;
+        [self tearDownSTT];
         reject(@"model_missing", [NSString stringWithFormat:@"Model file missing: %@", modelURL.path], nil);
         return;
       }
@@ -566,8 +699,7 @@ RCT_EXPORT_METHOD(initAll:(NSDictionary *)opts
         if (err || !tts) {
           self.initializing = NO;
           self.sttEngineHot = NO;
-          [self.stt destroySpeech:nil];
-          self.stt = nil;
+          [self tearDownSTT];
           reject(@"tts_init_failed", err.localizedDescription ?: @"TTS init failed", err);
           return;
         }
@@ -611,8 +743,7 @@ RCT_EXPORT_METHOD(initWithoutModel:(NSDictionary *)opts
     NSString *onboardingJsonPath = opts[@"onboardingJsonPath"];
     NSNumber *timeoutMs = opts[@"timeoutMs"];
 
-    @try { [self.stt destroySpeech:nil]; } @catch (__unused id e) {}
-    self.stt = nil;
+    [self tearDownSTT];
 
     [self ensureSTT];
     if (onboardingJsonPath && (id)onboardingJsonPath != [NSNull null] && onboardingJsonPath.length > 0) {
@@ -626,8 +757,7 @@ RCT_EXPORT_METHOD(initWithoutModel:(NSDictionary *)opts
         self.initializing = NO;
         self.initialized = NO;
         self.sttEngineHot = NO;
-        @try { [self.stt destroySpeech:nil]; } @catch (__unused id e) {}
-        self.stt = nil;
+        [self tearDownSTT];
         reject(@"stt_init_timeout", @"STT did not become ready before timeout", nil);
         return;
       }
@@ -802,8 +932,7 @@ RCT_EXPORT_METHOD(destroyAll:(RCTPromiseResolveBlock)resolve
     @try { [self.tts stopSpeaking]; [self.tts destroy]; } @catch (__unused id e) {}
     self.tts = nil;
 
-    @try { [self.stt destroySpeech:nil]; } @catch (__unused id e) {}
-    self.stt = nil;
+    [self tearDownSTT];
 
     self.sttEngineHot = NO;
     self.initialized  = NO;
@@ -828,8 +957,7 @@ RCT_EXPORT_METHOD(destroyWihtouModel:(RCTPromiseResolveBlock)resolve
 
     self.initializing = YES;
 
-    @try { [self.stt destroySpeech:nil]; } @catch (__unused id e) {}
-    self.stt = nil;
+    [self tearDownSTT];
 
     self.sttEngineHot = NO;
     self.initialized = NO;
@@ -934,6 +1062,43 @@ RCT_EXPORT_METHOD(isRecognizing:(RCTResponseSenderBlock)callback)
   if (callback) callback(@[@(running ? 1 : 0)]);
 }
 
+// Read-only diagnostics: captures AVAudioSession + STT/event-delivery state without
+// mutating anything, so it can be polled at any point in the lifecycle to compare a
+// healthy session against a stuck one.
+RCT_EXPORT_METHOD(sttHealthSnapshot:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  AVAudioSession *s = [AVAudioSession sharedInstance];
+  NSMutableArray *inputs = [NSMutableArray array];
+  for (AVAudioSessionPortDescription *p in s.currentRoute.inputs) { [inputs addObject:p.portType]; }
+  NSMutableArray *outputs = [NSMutableArray array];
+  for (AVAudioSessionPortDescription *p in s.currentRoute.outputs) { [outputs addObject:p.portType]; }
+  resolve(@{
+    // didEmitEvent: drops every STT callback when hasListeners is NO, and latches
+    // sttEngineHot before that gate -- so the engine can report itself hot while JS
+    // receives nothing. bridgePtr identifies which SpeechBridge instance is emitting,
+    // to catch the case where JS subscribed to a different instance than the one
+    // holding self.stt.
+    @"hasListeners": @(self.hasListeners),
+    @"sttEngineHot": @(self.sttEngineHot),
+    @"bridgePtr": [NSString stringWithFormat:@"%p", self],
+    @"hasStt": @(self.stt != nil),
+    @"recognizing": @(self.stt ? [self.stt isRecognizing] : NO),
+    @"initialized": @(self.initialized),
+    @"initializing": @(self.initializing),
+    @"category": s.category ?: @"",
+    @"mode": s.mode ?: @"",
+    @"categoryOptions": @(s.categoryOptions),
+    @"inputAvailable": @(s.inputAvailable),
+    @"sampleRate": @(s.sampleRate),
+    @"inputChannels": @(s.inputNumberOfChannels),
+    @"inputLatency": @(s.inputLatency),
+    @"otherAudioPlaying": @(s.isOtherAudioPlaying),
+    @"routeInputs": inputs,
+    @"routeOutputs": outputs,
+  });
+}
+
 RCT_EXPORT_METHOD(setAECEnabled:(BOOL)enabled
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
@@ -997,35 +1162,83 @@ RCT_EXPORT_METHOD(playWav:(NSString *)pathOrURL
     return;
   }
 
-  NSURL *fileURL = nil;
+  // Steps 5 and 6 below (verify + queue on the TTS engine), shared by every branch,
+  // including the http(s) one after its asynchronous download completes.
+  __weak typeof(self) weakSelf = self;
+  void (^playLocalFile)(NSURL *) = ^(NSURL *fileURL) {
+    typeof(self) strongSelf = weakSelf;
+    if (!strongSelf || !strongSelf.tts) {
+      reject(@"no_tts", @"TTS went away before playback", nil);
+      return;
+    }
+    if (!fileURL || ![[NSFileManager defaultManager] fileExistsAtPath:fileURL.path]) {
+      reject(@"file_missing", [NSString stringWithFormat:@"File missing: %@", fileURL.path], nil);
+      return;
+    }
+    SBDebugLog(@"[TTS] Playing file via DaVoiceTTS: %@", fileURL.path);
+    [strongSelf.tts playWav:fileURL markAsLastUtterance:markAsLast.boolValue];
+    resolve(@"queued");
+  };
 
-  // 1️⃣ Handle http(s) URLs — download to temporary file first
+  // 1️⃣ Handle http(s) URLs — download to a cached temporary file first.
+  //
+  // This used to be a synchronous [NSData dataWithContentsOfURL:] on this module's
+  // method queue, which is the main queue (see -methodQueue). In a debug build every
+  // require()'d asset (e.g. a wake-word ping sound) resolves to a Metro dev-server
+  // URL, so each ping blocked the UI for the whole request; on a slow or dropped link
+  // to the Metro host that meant a frozen app for as long as pings kept arriving.
+  // Download off the main queue with a bounded timeout, cache by URL so each asset is
+  // fetched once, then hop back to the method queue to play it.
   if ([pathOrURL hasPrefix:@"http://"] || [pathOrURL hasPrefix:@"https://"]) {
-    SBDebugLog(@"[TTS] Downloading asset from URL: %@", pathOrURL);
     NSURL *remoteURL = [NSURL URLWithString:pathOrURL];
     if (!remoteURL) {
       reject(@"bad_url", @"Invalid remote URL", nil);
       return;
     }
 
-    NSData *data = [NSData dataWithContentsOfURL:remoteURL];
-    if (!data) {
-      reject(@"download_failed", @"Failed to download remote asset", nil);
+    NSString *cachedPath = SBCachedFilePathForRemoteAsset(pathOrURL);
+    if ([[NSFileManager defaultManager] fileExistsAtPath:cachedPath]) {
+      playLocalFile([NSURL fileURLWithPath:cachedPath]);
       return;
     }
 
-    NSString *tempName = [NSString stringWithFormat:@"rn_asset_%f.wav", [[NSDate date] timeIntervalSince1970]];
-    NSString *tempPath = [NSTemporaryDirectory() stringByAppendingPathComponent:tempName];
-    if (![data writeToFile:tempPath atomically:YES]) {
-      reject(@"write_failed", @"Failed to write temporary file", nil);
-      return;
-    }
-    fileURL = [NSURL fileURLWithPath:tempPath];
-    SBDebugLog(@"[TTS] Downloaded to temp file: %@", tempPath);
+    SBDebugLog(@"[TTS] Downloading asset from URL: %@", pathOrURL);
+    dispatch_queue_t methodQueue = [self methodQueue];
+    NSURLSessionConfiguration *config = [NSURLSessionConfiguration ephemeralSessionConfiguration];
+    config.timeoutIntervalForRequest = 8.0;
+    config.timeoutIntervalForResource = 15.0;
+    NSURLSession *session = [NSURLSession sessionWithConfiguration:config];
+    NSURLSessionDataTask *task = [session dataTaskWithURL:remoteURL
+                                        completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
+      [session finishTasksAndInvalidate];
+      NSInteger status = [response isKindOfClass:[NSHTTPURLResponse class]]
+          ? ((NSHTTPURLResponse *)response).statusCode : 200;
+      BOOL downloaded = (error == nil && data.length > 0 && status < 400);
+      BOOL written = downloaded && [data writeToFile:cachedPath atomically:YES];
+      dispatch_async(methodQueue, ^{
+        if (!downloaded) {
+          NSString *why = error.localizedDescription ?: [NSString stringWithFormat:@"HTTP %ld", (long)status];
+          reject(@"download_failed",
+                 [NSString stringWithFormat:@"Failed to download remote asset (%@)", why],
+                 error);
+          return;
+        }
+        if (!written) {
+          reject(@"write_failed", @"Failed to write temporary file", nil);
+          return;
+        }
+        SBDebugLog(@"[TTS] Downloaded to cached file: %@", cachedPath);
+        playLocalFile([NSURL fileURLWithPath:cachedPath]);
+      });
+    }];
+    [task resume];
+    return;
   }
 
+  NSURL *fileURL = nil;
+
   // 2️⃣ Handle bundled asset:/ paths (copied from main bundle)
-  else if ([pathOrURL hasPrefix:@"asset:/"]) {
+  if ([pathOrURL hasPrefix:@"asset:/"]) {
     NSString *assetName = [pathOrURL stringByReplacingOccurrencesOfString:@"asset:/" withString:@""];
     SBDebugLog(@"[TTS] Detected bundled asset: %@", assetName);
     NSString *bundlePath = [[NSBundle mainBundle] pathForResource:[assetName stringByDeletingPathExtension]
@@ -1057,16 +1270,8 @@ RCT_EXPORT_METHOD(playWav:(NSString *)pathOrURL
     fileURL = [NSURL fileURLWithPath:pathOrURL];
   }
 
-  // 5️⃣ Verify existence
-  if (!fileURL || ![[NSFileManager defaultManager] fileExistsAtPath:fileURL.path]) {
-    reject(@"file_missing", [NSString stringWithFormat:@"File missing: %@", fileURL.path], nil);
-    return;
-  }
-
-  // 6️⃣ Play through TTS engine (queued)
-  SBDebugLog(@"[TTS] Playing file via DaVoiceTTS: %@", fileURL.path);
-  [self.tts playWav:fileURL markAsLastUtterance:markAsLast.boolValue];
-  resolve(@"queued");
+  // 5️⃣ + 6️⃣ Verify existence and play through the TTS engine (queued)
+  playLocalFile(fileURL);
 }
 
 /// playBuffer(desc: { base64, sampleRate, channels?, interleaved?, format: "i16" | "f32", markAsLast? })

package/ios/TTSRNBridge/DavoiceTTS.xcframework/Info.plist

@@ -8,32 +8,32 @@
 			<key>BinaryPath</key>
 			<string>DavoiceTTS.framework/DavoiceTTS</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>DavoiceTTS.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>DavoiceTTS.framework/DavoiceTTS</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>DavoiceTTS.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>