react-native-davoice-tts 1.0.232 → 1.0.234

package/TTSRNBridge.podspec

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

package/android/src/main/java/com/davoice/tts/rn/DaVoiceTTSBridge.java

@@ -17,6 +17,12 @@ import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.Locale;
 import android.util.Base64;
+import android.media.MediaPlayer;
+
+import android.util.Log;
+import android.content.res.AssetFileDescriptor;
+import java.io.IOException;
+
 
 import com.davoice.tts.DaVoiceTTSInterface;
 
@@ -24,6 +30,7 @@ public class DaVoiceTTSBridge extends ReactContextBaseJavaModule {
 
     private final DaVoiceTTSInterface tts;
     private final ReactApplicationContext reactCtx;
+    final String TAG = "TTS";
 
     public DaVoiceTTSBridge(ReactApplicationContext context) {
         super(context);
@@ -198,36 +205,127 @@ public class DaVoiceTTSBridge extends ReactContextBaseJavaModule {
             dst[f] = acc / channels;
         }
     }
-// ADD
-@ReactMethod
-public void playWav(String pathOrURL, boolean markAsLast, Promise promise) {
-    try {
+
+    // @ReactMethod
+    // public void playWav(String pathOrURL, boolean markAsLast, Promise promise) {
+    //     Log.d(TAG, "playWav() called with: " + pathOrURL + " | markAsLast=" + markAsLast);
+    //     try {
+    //         if (isHttpOrHttps(pathOrURL)) {
+    //             promise.reject("unsupported_url", "Remote URLs not supported. Download to a local file first.");
+    //             return;
+    //         }
+
+    //                 // --- NEW: handle require() assets from RN ---
+    //         if (pathOrURL.startsWith("asset:/")) {
+    //             Log.e(TAG, "Rejected remote URL: " + pathOrURL);
+    //             String assetName = pathOrURL.replace("asset:/", "");
+    //             Log.d(TAG, "Detected bundled asset: " + assetName);
+    //             try (AssetFileDescriptor afd = getReactApplicationContext().getAssets().openFd(assetName)) {
+    //                 tts.playWav(afd, markAsLast);  // overload that accepts AssetFileDescriptor
+    //                 promise.resolve("queued");
+    //                 return;
+    //             } catch (IOException e) {
+    //                 promise.reject("asset_load_failed", "Unable to open bundled asset: " + e.getMessage(), e);
+    //                 return;
+    //             }
+    //         }
+
+    //         String path = pathOrURL;
+    //         if (isFileUrl(pathOrURL)) {
+    //             Uri u = Uri.parse(pathOrURL);
+    //             File f = new File(u.getPath());
+    //             path = f.getAbsolutePath();
+    //         }
+    //         if (path == null) {
+    //             promise.reject("bad_path", "Invalid file URL");
+    //             return;
+    //         }
+    //         File f = new File(path);
+    //         if (!f.exists()) {
+    //             promise.reject("file_missing", "WAV file does not exist at path");
+    //             return;
+    //         }
+    //         tts.playWav(f, markAsLast);
+    //         promise.resolve("queued");
+    //     } catch (Exception e) {
+    //         promise.reject("PlayWavError", e.getMessage(), e);
+    //     }
+    // }
+    // ADD
+    
+    @ReactMethod
+    public void playWav(String pathOrURL, boolean markAsLast, Promise promise) {
+        final String TAG = "TTS";
+        Log.d(TAG, "playWav() called with: " + pathOrURL + " | markAsLast=" + markAsLast);
+        // 1️⃣ Handle RN dev server URLs (http://localhost:8081/...) by downloading them to cache first
+        try {
         if (isHttpOrHttps(pathOrURL)) {
-            promise.reject("unsupported_url", "Remote URLs not supported. Download to a local file first.");
+            Log.w(TAG, "Downloading asset from dev server: " + pathOrURL);
+                java.net.URL url = new java.net.URL(pathOrURL);
+                java.io.InputStream in = url.openStream();
+                File out = new File(reactCtx.getCacheDir(), "rn_asset_" + System.currentTimeMillis() + ".wav");
+                try (FileOutputStream fos = new FileOutputStream(out)) {
+                    byte[] buf = new byte[8192];
+                    int len;
+                    while ((len = in.read(buf)) != -1) fos.write(buf, 0, len);
+                }
+                in.close();
+                Log.d(TAG, "Downloaded asset to: " + out.getAbsolutePath());
+                tts.playWav(out, markAsLast);
+                promise.resolve("queued");
+                return;
+        }
+
+        // 2️⃣ Handle require() assets (resolved as "asset:/...") via Android asset manager
+        if (pathOrURL.startsWith("asset:/")) {
+            String assetName = pathOrURL.replace("asset:/", "");
+            Log.d(TAG, "Detected bundled asset: " + assetName);
+            File tmp = new File(reactCtx.getCacheDir(), "asset_" + System.currentTimeMillis() + ".wav");
+            try (java.io.InputStream in = reactCtx.getAssets().open(assetName);
+                 FileOutputStream out = new FileOutputStream(tmp)) {
+                byte[] buf = new byte[8192];
+                int len;
+                while ((len = in.read(buf)) != -1) out.write(buf, 0, len);
+            }
+            Log.d(TAG, "Copied asset to: " + tmp.getAbsolutePath());
+            tts.playWav(tmp, markAsLast);
+            promise.resolve("queued");
             return;
         }
+
+        // --- file:// handling ---
         String path = pathOrURL;
         if (isFileUrl(pathOrURL)) {
             Uri u = Uri.parse(pathOrURL);
             File f = new File(u.getPath());
             path = f.getAbsolutePath();
+            Log.d(TAG, "Resolved file:// URL to path: " + path);
         }
+
         if (path == null) {
+            Log.e(TAG, "Invalid or null path provided");
             promise.reject("bad_path", "Invalid file URL");
             return;
         }
+
         File f = new File(path);
         if (!f.exists()) {
+            Log.e(TAG, "File does not exist at path: " + path);
             promise.reject("file_missing", "WAV file does not exist at path");
             return;
         }
+
+        Log.d(TAG, "Playing WAV from path: " + path + " (exists=" + f.exists() + ")");
         tts.playWav(f, markAsLast);
+        Log.d(TAG, "Queued playback successfully for: " + path);
         promise.resolve("queued");
+
     } catch (Exception e) {
+        Log.e(TAG, "PlayWavError: " + e.getMessage(), e);
         promise.reject("PlayWavError", e.getMessage(), e);
     }
 }
-    // ADD
+
     @ReactMethod
     public void playBuffer(ReadableMap desc, Promise promise) {
         try {

package/ios/SpeechBridge/SpeechBridge.m

@@ -332,27 +332,85 @@ RCT_EXPORT_METHOD(playWav:(NSString *)pathOrURL
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
-  if (!self.tts) { reject(@"no_tts", @"Call initAll first", nil); return; }
+  if (!self.tts) {
+    reject(@"no_tts", @"Call initAll first", nil);
+    return;
+  }
+
+  if (pathOrURL == nil || pathOrURL.length == 0) {
+    reject(@"bad_path", @"Empty pathOrURL", nil);
+    return;
+  }
 
-  NSURL *url = nil;
-  if ([pathOrURL hasPrefix:@"http://"] || [pathOrURL hasPrefix:@"https://"] || [pathOrURL hasPrefix:@"file://"]) {
-    url = [NSURL URLWithString:pathOrURL];
-    if (url.isFileURL == NO) {
-      // For remote URLs: you’d normally download first. Keep it simple: reject.
-      reject(@"unsupported_url", @"Remote URLs not supported. Download to a file path first.", nil);
+  NSURL *fileURL = nil;
+
+  // 1️⃣ Handle http(s) URLs — download to temporary file first
+  if ([pathOrURL hasPrefix:@"http://"] || [pathOrURL hasPrefix:@"https://"]) {
+    NSLog(@"[TTS] Downloading asset from URL: %@", pathOrURL);
+    NSURL *remoteURL = [NSURL URLWithString:pathOrURL];
+    if (!remoteURL) {
+      reject(@"bad_url", @"Invalid remote URL", nil);
       return;
     }
-  } else {
-    url = [NSURL fileURLWithPath:pathOrURL];
+
+    NSData *data = [NSData dataWithContentsOfURL:remoteURL];
+    if (!data) {
+      reject(@"download_failed", @"Failed to download remote asset", nil);
+      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];
+    NSLog(@"[TTS] Downloaded to temp file: %@", tempPath);
+  }
+
+  // 2️⃣ Handle bundled asset:/ paths (copied from main bundle)
+  else if ([pathOrURL hasPrefix:@"asset:/"]) {
+    NSString *assetName = [pathOrURL stringByReplacingOccurrencesOfString:@"asset:/" withString:@""];
+    NSLog(@"[TTS] Detected bundled asset: %@", assetName);
+    NSString *bundlePath = [[NSBundle mainBundle] pathForResource:[assetName stringByDeletingPathExtension]
+                                                           ofType:[assetName pathExtension]];
+    if (!bundlePath) {
+      reject(@"asset_missing", [NSString stringWithFormat:@"Asset not found in bundle: %@", assetName], nil);
+      return;
+    }
+    // Copy to temp file so we have a writable/accessible URL
+    NSString *tempName = [NSString stringWithFormat:@"asset_%f.wav", [[NSDate date] timeIntervalSince1970]];
+    NSString *tempPath = [NSTemporaryDirectory() stringByAppendingPathComponent:tempName];
+    NSError *copyError = nil;
+    [[NSFileManager defaultManager] copyItemAtPath:bundlePath toPath:tempPath error:&copyError];
+    if (copyError) {
+      reject(@"asset_copy_failed", copyError.localizedDescription, copyError);
+      return;
+    }
+    fileURL = [NSURL fileURLWithPath:tempPath];
+    NSLog(@"[TTS] Copied bundled asset to temp: %@", tempPath);
+  }
+
+  // 3️⃣ Handle file:// URLs
+  else if ([pathOrURL hasPrefix:@"file://"]) {
+    fileURL = [NSURL URLWithString:pathOrURL];
+  }
+
+  // 4️⃣ Otherwise assume direct local path
+  else {
+    fileURL = [NSURL fileURLWithPath:pathOrURL];
   }
 
-  if (![[NSFileManager defaultManager] fileExistsAtPath:url.path]) {
-    reject(@"file_missing", @"WAV file does not exist at path", nil);
+  // 5️⃣ Verify existence
+  if (!fileURL || ![[NSFileManager defaultManager] fileExistsAtPath:fileURL.path]) {
+    reject(@"file_missing", [NSString stringWithFormat:@"File missing: %@", fileURL.path], nil);
     return;
   }
 
-  // Pass through to DaVoiceTTS (which routes via AEC graph/queue)
-  [self.tts playWav:url markAsLastUtterance:markAsLast.boolValue];
+  // 6️⃣ Play through TTS engine (queued)
+  NSLog(@"[TTS] Playing file via DaVoiceTTS: %@", fileURL.path);
+  [self.tts playWav:fileURL markAsLastUtterance:markAsLast.boolValue];
   resolve(@"queued");
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-davoice-tts",
-    "version": "1.0.232",
+    "version": "1.0.234",
     "description": "tts library for React Native",
     "main": "tts/index.js",
     "types": "tts/index.d.ts",

package/speech/index.ts

@@ -408,18 +408,40 @@ private rewireListenersForMode() {
 
   // --- NEW: TTS passthroughs for external audio ---
   /** Queue a WAV file (local path, file:// URL, or require() asset). */
-  async playWav(pathOrURL: string | number, markAsLast = true) {
+  async playWav(pathOrURL: any, markAsLast = true) {
     // NEW: resolve require() assets to actual file path/URI
+    console.log('[Speech.playWav] called with:', pathOrURL, '| type:', typeof pathOrURL);
+    const resolveAssetSource = require('react-native/Libraries/Image/resolveAssetSource').default;
+
     const asset = resolveAssetSource(pathOrURL);
-    const realPath = asset?.uri ?? pathOrURL; // fallback keeps string path intact
+    console.log('[Speech.playWav] resolveAssetSource ->', asset);
+
+    let realPath = asset?.uri ?? pathOrURL; // fallback keeps string path intact
+    console.log('[Speech.playWav] resolved realPath:', realPath);
+
+      // ✅ Coerce to string explicitly
+    if (typeof realPath !== 'string') {
+      realPath = String(realPath);
+      console.log('[Speech.playWav] converted ?? realPath:', realPath);
+    }
+    
+    console.log('[Speech.playWav] before checking ios realPath:', realPath);
 
     // Prefer unified iOS bridge if present
     if (Platform.OS === 'ios' && NativeSpeech?.playWav) {
       return NativeSpeech.playWav(realPath, markAsLast);
     }
+    console.log('[Speech.playWav] after checking ios realPath:', realPath);
+    console.log('[Speech.playWav] after checking ios realPath:', typeof(realPath));
 
     // Fallback: direct TTS bridge (Android + iOS fallback)
-    if (!NativeTTS?.playWav) throw new Error('playWav not available on this platform.');
+    if (!NativeTTS?.playWav) {
+      console.log('[Speech.playWav] NativeTTS:', NativeTTS);
+      if (NativeTTS)
+        console.log('[Speech.playWav] NativeTTS.playWav :', NativeTTS.playWav);
+      throw new Error('playWav not available on this platform.');
+    }
+    console.log('[Speech.playWav] calling NativeTTS.playWav with type of realPath:', typeof(realPath));
     return NativeTTS.playWav(realPath, markAsLast);
   }