react-native-davoice 1.0.4

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

@@ -0,0 +1,733 @@
+// android/src/main/java/com/davoice/tts/rn/DaVoiceTTSBridge.java
+package com.davoice.tts.rn;
+
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+// ADD
+import android.net.Uri;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Locale;
+import android.util.Base64;
+import android.media.MediaPlayer;
+import android.content.Context;
+
+import android.util.Log;
+import android.content.res.AssetFileDescriptor;
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLConnection;
+
+import com.davoice.tts.DaVoiceTTSInterface;
+import com.davoice.tts.LicenseManager;
+
+
+public class DaVoiceTTSBridge extends ReactContextBaseJavaModule {
+
+    private final DaVoiceTTSInterface tts;
+    private final ReactApplicationContext reactCtx;
+    final String TAG = "TTS";
+
+    public DaVoiceTTSBridge(ReactApplicationContext context) {
+        super(context);
+        this.reactCtx = context;
+        this.tts = new DaVoiceTTSInterface(context);
+    }
+
+    @Override
+    public String getName() { return "DaVoiceTTSBridge"; }
+
+    private void sendEvent(String name, @Nullable WritableMap params) {
+        reactCtx.runOnUiQueueThread(() ->
+            reactCtx
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(name, params)
+        );
+    }
+
+    @ReactMethod
+    public void setLicense(String licenseKey, Promise promise) {
+        try {
+            if (licenseKey == null || licenseKey.trim().isEmpty()) {
+                promise.reject("invalid_args", "Missing licenseKey");
+                return;
+            }
+            promise.resolve(tts.setLicenseKey(licenseKey));
+        } catch (Exception e) {
+            promise.reject("LicenseError", e.getMessage(), e);
+        }
+    }
+
+    @ReactMethod
+    public void isLicenseValid(String licenseKey, Promise promise) {
+        try {
+            if (licenseKey == null || licenseKey.trim().isEmpty()) {
+                promise.reject("invalid_args", "Missing licenseKey");
+                return;
+            }
+            promise.resolve(LicenseManager.isLicenseValid(licenseKey));
+        } catch (Exception e) {
+            promise.reject("LicenseError", e.getMessage(), e);
+        }
+    }
+
+    @ReactMethod
+    public void initTTS(ReadableMap config, Promise promise) {
+        // DEBUG CODE
+        //  try {
+        //     final String fileName = config.getString("model");
+        //     // Basic input debug
+        //     Log.i(TAG, "ASSETDBG model raw input='" + fileName + "'");
+        //     final String pkg = reactCtx.getPackageName();
+        //     Log.i(TAG, "ASSETDBG packageName=" + pkg);
+        //     // RN sometimes passes "assets_xxx" (no extension). Print normalized variants.
+        //     final String[] candidates = new String[] {
+        //         fileName,
+        //         fileName + ".mp3",
+        //         fileName + ".wav",
+        //         fileName + ".dm",
+        //         fileName + ".onnx",
+        //         fileName + ".json",
+        //     };
+        //     Log.i(TAG, "ASSETDBG candidates=" + java.util.Arrays.toString(candidates));
+
+        //     int res =
+        //         reactCtx.getResources().getIdentifier(fileName, "raw", pkg);
+
+        //     if (res != 0) {
+        //         Log.i(TAG, "ASSETDBG res!=0" + res);
+                
+        //         android.content.res.AssetFileDescriptor afd = reactCtx.getResources().openRawResourceFd(res);
+        //         Log.i(TAG, "ASSETDBG res!=0 afd == " + afd);
+        //         afd.close();
+        //     }
+        //     else {
+        //         Log.i(TAG, "ASSETDBG res==0" + res);
+        //     }
+
+        //                 // Now the important part: res/raw identifier lookup (this is what RN-Sound relies on)
+        //     for (String name : candidates) {
+        //         try {
+        //             int resId = reactCtx.getResources().getIdentifier(name, "raw", pkg);
+        //             Log.i(TAG, "ASSETDBG getIdentifier(name='" + name + "', type='raw') => resId=" + resId);
+
+        //             if (resId != 0) {
+        //                 // Print extra details about the resource
+        //                 try {
+        //                     String entry = reactCtx.getResources().getResourceEntryName(resId);
+        //                     String type  = reactCtx.getResources().getResourceTypeName(resId);
+        //                     String full  = reactCtx.getResources().getResourceName(resId);
+        //                     Log.i(TAG, "ASSETDBG resource: entry=" + entry + " type=" + type + " full=" + full);
+        //                 } catch (Exception ignored) {
+        //                     Log.i(TAG, "ASSETDBG resource name lookup failed (non-fatal) resId=" + resId);
+        //                 }
+
+        //                 // Try openRawResourceFd (works for non-compressed raw)
+        //                 try {
+        //                     android.content.res.AssetFileDescriptor afd =
+        //                             reactCtx.getResources().openRawResourceFd(resId);
+
+        //                     if (afd == null) {
+        //                         Log.w(TAG, "ASSETDBG openRawResourceFd returned NULL for resId=" + resId + " (likely compressed) -> will try openRawResource()");
+        //                     } else {
+        //                         Log.i(TAG, "ASSETDBG openRawResourceFd OK resId=" + resId
+        //                                 + " startOffset=" + afd.getStartOffset()
+        //                                 + " length=" + afd.getLength()
+        //                                 + " fdValid=" + (afd.getFileDescriptor() != null));
+        //                         afd.close();
+        //                     }
+        //                 } catch (Exception e) {
+        //                     Log.w(TAG, "ASSETDBG openRawResourceFd FAILED resId=" + resId + " err=" + e.getMessage(), e);
+        //                 }
+
+        //                 // Always try openRawResource() too (works even if compressed)
+        //                 try (java.io.InputStream in = reactCtx.getResources().openRawResource(resId)) {
+        //                     byte[] head = new byte[32];
+        //                     int n = in.read(head);
+        //                     Log.i(TAG, "ASSETDBG openRawResource OK resId=" + resId + " firstBytesRead=" + n);
+        //                 } catch (Exception e) {
+        //                     Log.w(TAG, "ASSETDBG openRawResource FAILED resId=" + resId + " err=" + e.getMessage(), e);
+        //                 }
+        //             }
+        //         } catch (Exception e) {
+        //             Log.w(TAG, "ASSETDBG getIdentifier loop exception name='" + name + "' err=" + e.getMessage(), e);
+        //         }
+        //     }
+        // } catch (Exception e) {
+        //     Log.w(TAG, "ASSETDBG list assets failed: " + e.getMessage());
+        // }
+        try {
+            if (config == null || !config.hasKey("model") || config.isNull("model")) {
+                promise.reject("invalid_config", "Missing required 'model' key");
+                return;
+            }
+            final String modelPathOrURL = config.getString("model");
+            final String modelExt =
+                    (config.hasKey("modelExt") && !config.isNull("modelExt"))
+                            ? config.getString("modelExt") : null;
+
+            // ✅ FIX: keep old behavior for plain asset-relative paths like "model.onnx" or "models/model.onnx"
+            // (i.e. files you manually put under android/app/src/main/assets or any merged asset pack).
+            final String s = (modelPathOrURL == null) ? "" : modelPathOrURL.trim();
+            if (s.isEmpty()) {
+                promise.reject("invalid_config", "Empty 'model'");
+                return;
+            }
+
+            final boolean looksLikePlainAssetPath =
+                    !s.contains("://") &&
+                    !s.startsWith("/") &&
+                    !s.toLowerCase(Locale.US).startsWith("file:") &&
+                    !s.toLowerCase(Locale.US).startsWith("content:") &&
+                    !s.toLowerCase(Locale.US).startsWith("asset:") &&
+                    // ✅ IMPORTANT: RN release resource names are NOT AssetManager assets (res/raw)
+                    !s.startsWith("assets_") && !s.startsWith("src_assets_");
+
+
+            final String modelName;
+            if (looksLikePlainAssetPath) {
+                File f = resolvePlainModelToFile(s, modelExt != null ? modelExt : "onnx");
+                if (f != null) {
+                    modelName = f.getAbsolutePath();   // pass a real filesystem path to the engine
+                } else {
+                    // Last resort: keep old behavior (in case engine itself can open via AssetManager)
+                    modelName = s;
+                }
+            } else {
+                // Use provided extension when RN gave us assets_* (no ext), otherwise fall back safely.
+                final String ext = (modelExt != null && !modelExt.isEmpty()) ? modelExt : "onnx";
+                final File modelFile = resolveToLocalFileForRead(s, ext);
+                if (modelFile == null || !modelFile.exists()) {
+                    promise.reject("model_missing", "Model file missing/unresolvable: " + s);
+                    return;
+                }
+                modelName = modelFile.getAbsolutePath();
+            }
+
+            // fire RN event when the last utterance finishes
+            tts.setOnFinishedSpeakingListenerJava(() -> sendEvent("onFinishedSpeaking", null));
+
+            DaVoiceTTSInterface.Config cfg = new DaVoiceTTSInterface.Config(
+                    modelName,
+                    "en-US",
+                    "phonemes_dir"
+            );
+            boolean ok = tts.initTTS(cfg);
+            if (!ok) {
+                promise.reject("InitFailed", "Engine/TTS init failed");
+                return;
+            }
+            promise.resolve(true);
+        } catch (Exception e) {
+            promise.reject("InitError", e.getMessage(), e);
+        }
+    }
+
+    @ReactMethod
+    public void initTTSPlaybackOnly(Promise promise) {
+        try {
+            // Always wire completion events for JS queueing.
+            tts.setOnFinishedSpeakingListenerJava(() -> sendEvent("onFinishedSpeaking", null));
+
+            boolean ok = true;
+            // Keep backwards compatibility with older TTS AARs that don't have initPlaybackOnly().
+            try {
+                java.lang.reflect.Method m = tts.getClass().getMethod("initPlaybackOnly");
+                Object out = m.invoke(tts);
+                if (out instanceof Boolean) ok = (Boolean) out;
+            } catch (NoSuchMethodException noSuchMethod) {
+                Log.w(TAG, "initTTSPlaybackOnly: initPlaybackOnly() not found on TTS interface; using lazy playback fallback");
+            }
+
+            if (!ok) {
+                promise.reject("InitFailed", "Playback-only TTS init failed");
+                return;
+            }
+            promise.resolve(true);
+        } catch (Exception e) {
+            promise.reject("InitError", e.getMessage(), e);
+        }
+    }
+
+    private @Nullable File tryGetModelsPackAssetsPath(Context ctx) {
+        try {
+            Class<?> factoryClz = Class.forName("com.google.android.play.core.assetpacks.AssetPackManagerFactory");
+            java.lang.reflect.Method getInstance = factoryClz.getMethod("getInstance", Context.class);
+            Object apm = getInstance.invoke(null, ctx.getApplicationContext());
+
+            Class<?> apmClz = Class.forName("com.google.android.play.core.assetpacks.AssetPackManager");
+            java.lang.reflect.Method getPackLocation = apmClz.getMethod("getPackLocation", String.class);
+            Object loc = getPackLocation.invoke(apm, "models_pack");
+            if (loc == null) return null;
+
+            Class<?> locClz = Class.forName("com.google.android.play.core.assetpacks.AssetPackLocation");
+            java.lang.reflect.Method assetsPath = locClz.getMethod("assetsPath");
+            String path = (String) assetsPath.invoke(loc);
+            if (path == null) return null;
+            return new File(path);
+        } catch (Throwable t) {
+            // Play Core not on classpath or not installed -> ignore
+            return null;
+        }
+    }
+
+    /** models_pack → absolute file (if installed), else null */
+    @Nullable
+    private File getFileFromAssetPack(String relative) {
+        try {
+            // assetsPath is the root of the "assets" folder inside the models_pack
+            File assetsRoot = tryGetModelsPackAssetsPath(reactCtx);
+            if (assetsRoot == null) return null; // pack not present → caller will fall back
+
+            // Accept both "model.onnx" and "models/model.onnx"
+            String rel = relative.startsWith("models/") ? relative : ("models/" + relative);
+            File f = new File(assetsRoot, rel);
+            return f.exists() ? f : null;
+        } catch (Throwable t) {
+            Log.w(TAG, "getFileFromAssetPack failed: " + t.getMessage());
+            return null;
+        }
+    }
+
+    /** If in res/raw, copy to cache and return File; else null. */
+    @Nullable
+    private File tryResolveFromResRawToCache(String nameMaybeWithExt, @Nullable String defaultExt) {
+        // Accept "model.onnx" or "model"
+        String rawName = nameMaybeWithExt;
+        if (rawName == null) return null;
+        rawName = rawName.trim();
+        if (rawName.isEmpty()) return null;
+        int dot = rawName.lastIndexOf('.');
+        if (dot > 0) rawName = rawName.substring(0, dot);
+        return copyRawResourceToCache(rawName, defaultExt);
+    }
+
+    /** For plain names, resolve to an absolute File using res/raw or asset-pack. */
+    @Nullable
+    private File resolvePlainModelToFile(String plain, @Nullable String defaultExt) {
+        // 1) res/raw (RN may map bundled assets there in release)
+        File fromRaw = tryResolveFromResRawToCache(plain, defaultExt);
+        if (fromRaw != null && fromRaw.exists()) return fromRaw;
+
+        // 2) fast-follow asset pack
+        File fromPack = getFileFromAssetPack(plain);
+        if (fromPack != null && fromPack.exists()) return fromPack;
+
+        return null;
+    }
+
+    @ReactMethod
+    public void speak(String text, int speakerId, double speed, Promise promise) {
+        try {
+            float s = (float) speed;
+            if (!Float.isFinite(s) || s <= 0.0f) s = 1.0f;
+
+            // ✅ 3 args only
+            tts.speak(text, speakerId, s);
+
+            promise.resolve(null);
+        } catch (Exception e) {
+            promise.reject("SpeakError", e.getMessage(), e);
+        }
+    }
+    private File copyRawResourceToCache(String rawName, @Nullable String defaultExt) {
+        try {
+            String pkg = reactCtx.getPackageName();
+            int resId = reactCtx.getResources().getIdentifier(rawName, "raw", pkg);
+
+            Log.d(TAG, "copyRawResourceToCache: rawName=" + rawName + " pkg=" + pkg + " resId=" + resId);
+
+            if (resId == 0) return null;
+
+            String ext = (defaultExt != null && !defaultExt.isEmpty()) ? defaultExt : "bin";
+            File out = new File(
+                    reactCtx.getCacheDir(),
+                    "rn_raw_" + rawName + "_" + System.currentTimeMillis() + "." + ext
+            );
+
+            try (java.io.InputStream in = reactCtx.getResources().openRawResource(resId);
+                FileOutputStream fos = new FileOutputStream(out)) {
+                byte[] buf = new byte[8192];
+                int len;
+                while ((len = in.read(buf)) != -1) fos.write(buf, 0, len);
+            }
+
+            Log.d(TAG, "copyRawResourceToCache: wrote " + out.getAbsolutePath() + " size=" + out.length());
+            return out;
+        } catch (Exception e) {
+            Log.e(TAG, "copyRawResourceToCache FAILED rawName=" + rawName + " err=" + e.getMessage(), e);
+            return null;
+        }
+    }
+
+    private File tryCopyRawToCacheIfExists(String name, @Nullable String defaultExt) {
+        if (name == null) return null;
+        final String s = name.trim();
+        if (s.isEmpty()) return null;
+
+        // Only reasonable resource entry names (no scheme, no slashes)
+        if (s.contains("://") || s.contains("/") || s.contains("\\") || s.startsWith(".")) return null;
+
+        // IMPORTANT: res/raw entry names have NO extension in Android resources
+        // If caller passed "foo.wav", strip extension for resource lookup.
+        String rawName = s;
+        int dot = rawName.lastIndexOf('.');
+        if (dot > 0) rawName = rawName.substring(0, dot);
+
+        File out = copyRawResourceToCache(rawName, defaultExt);
+        return (out != null && out.exists()) ? out : null;
+    }
+
+    // Resolve pathOrURL -> local readable File (supports http(s), asset:/, file://, plain path)
+    // defaultExt can be "wav", "onnx", etc (used for tmp file naming when extension missing)
+    private File resolveToLocalFileForRead(String pathOrURL, @Nullable String defaultExt) throws Exception {
+        if (pathOrURL == null) return null;
+        final String s = pathOrURL.trim();
+        if (s.isEmpty()) return null;
+
+        // 0) RN bundled assets on Android are usually in res/raw and resolve to a resource entry name
+        // like "assets_*" OR "src_assets_*" (no extension). Try res/raw first.
+        {
+            File out = tryCopyRawToCacheIfExists(s, defaultExt);
+            if (out != null) {
+                Log.i(TAG, "resolveToLocalFileForRead: copied res/raw '" + s + "' -> " + out.getAbsolutePath());
+                return out;
+            }
+        }
+
+        // 0) RN bundled assets resolve to res/raw names like "assets_cashregistersound" (NO extension).
+        // They are NOT APK /assets files. Handle exactly like react-native-sound: Resources.getIdentifier(..., "raw", ...)
+        if (s.startsWith("assets_")) {
+            File out = copyRawResourceToCache(s, defaultExt);
+            if (out != null && out.exists()) {
+                Log.i(TAG, "resolveToLocalFileForRead: copied res/raw '" + s + "' -> " + out.getAbsolutePath());
+                return out;
+            }
+            Log.w(TAG, "resolveToLocalFileForRead: res/raw lookup failed for '" + s + "'");
+            return null;
+        }
+        // 1) http(s) -> download into cache
+        if (isHttpOrHttps(s)) {
+            URL url = new URL(s);
+            String ext = guessExtFromUrl(s, defaultExt);
+            File out = new File(reactCtx.getCacheDir(), "rn_dl_" + System.currentTimeMillis() + (ext != null ? ("." + ext) : ""));
+            try (java.io.InputStream in = url.openStream();
+                 FileOutputStream fos = new FileOutputStream(out)) {
+                byte[] buf = new byte[8192];
+                int len;
+                while ((len = in.read(buf)) != -1) fos.write(buf, 0, len);
+            }
+            return out;
+        }
+        String assetName = null;
+
+        // RN "asset:/" form
+        if (s.startsWith("asset:/") || s.startsWith("asset://")) {
+            assetName = s.replaceFirst("^asset:/+", ""); // handles asset:/ and asset://
+        } else if (s.startsWith("file:")) {
+            // Android asset URL forms
+            // - file:///android_asset/foo.wav   => path "/android_asset/foo.wav", host null
+            // - file://android_asset/foo.wav    => host "android_asset", path "/foo.wav"
+            Uri u = Uri.parse(s);
+            if (u != null) {
+                String host = u.getHost();  // "android_asset" in file://android_asset/...
+                String path = u.getPath();  // "/android_asset/..." OR "/foo.wav"
+                if (path != null) {
+                    if ("android_asset".equalsIgnoreCase(host)) {
+                        // file://android_asset/foo.wav  => path "/foo.wav"
+                        assetName = path.startsWith("/") ? path.substring(1) : path;
+                    } else if (path.startsWith("/android_asset/")) {
+                        // file:///android_asset/foo.wav => path "/android_asset/foo.wav"
+                        assetName = path.substring("/android_asset/".length());
+                    }
+                }
+            }
+        }
+
+        if (assetName != null) {
+            // normalize
+            assetName = Uri.decode(assetName);
+            while (assetName.startsWith("/")) assetName = assetName.substring(1);
+
+            String ext = guessExtFromName(assetName, defaultExt);
+            File out = new File(
+                reactCtx.getCacheDir(),
+                "rn_asset_" + System.currentTimeMillis() + (ext != null ? ("." + ext) : "")
+            );
+
+            try (java.io.InputStream in = reactCtx.getAssets().open(assetName);
+                FileOutputStream fos = new FileOutputStream(out)) {
+                byte[] buf = new byte[8192];
+                int len;
+                while ((len = in.read(buf)) != -1) fos.write(buf, 0, len);
+            }
+            return out;
+        }
+
+        // 3) file:// -> local file path
+        String path = s;
+        if (isFileUrl(s)) {
+            Uri u = Uri.parse(s);
+            path = (u != null) ? u.getPath() : null;
+        }
+        if (path == null) return null;
+        return new File(path);
+    }
+
+    private static String guessExtFromUrl(String url, @Nullable String defaultExt) {
+        try {
+            String p = Uri.parse(url).getPath();
+            return guessExtFromName(p, defaultExt);
+        } catch (Exception ignored) {
+            return defaultExt;
+        }
+    }
+
+    private static String guessExtFromName(@Nullable String name, @Nullable String defaultExt) {
+        if (name == null) return defaultExt;
+        int dot = name.lastIndexOf('.');
+        if (dot >= 0 && dot + 1 < name.length()) {
+            String ext = name.substring(dot + 1);
+            return ext.isEmpty() ? defaultExt : ext;
+        }
+        return defaultExt;
+    }
+
+    @ReactMethod
+    public void stopSpeaking(Promise promise) {
+        try {
+            tts.stopSpeaking();
+            promise.resolve(null);
+        } catch (Exception e) {
+            promise.reject("StopError", e.getMessage(), e);
+        }
+    }
+
+    @ReactMethod
+    public void destroy(Promise promise) {
+        try {
+            // stop & free native resources; after this, JS should create a fresh instance before use
+            tts.destroy();
+            promise.resolve(null);
+        } catch (Exception e) {
+            promise.reject("DestroyError", e.getMessage(), e);
+        }
+    }
+    // ADD
+    private static boolean isHttpOrHttps(String s) {
+        if (s == null) return false;
+        String ls = s.toLowerCase(Locale.US);
+        return ls.startsWith("http://") || ls.startsWith("https://");
+    }
+    // ADD
+    private static boolean isFileUrl(String s) {
+        if (s == null) return false;
+        String ls = s.toLowerCase(Locale.US);
+        return ls.startsWith("file://");
+    }
+    // ADD
+    private static byte[] b64(String base64) throws Exception {
+        return Base64.decode(base64, Base64.DEFAULT);
+    }
+    // ADD
+    private static byte[] intLE(int v) {
+        return new byte[] {
+            (byte)(v & 0xFF),
+            (byte)((v >> 8) & 0xFF),
+            (byte)((v >> 16) & 0xFF),
+            (byte)((v >> 24) & 0xFF)
+        };
+    }
+    // ADD
+    private static byte[] shortLE(short v) {
+        return new byte[] {
+            (byte)(v & 0xFF),
+            (byte)((v >> 8) & 0xFF)
+        };
+    }
+    // ADD
+    private static void writeWavF32(File out, float[] pcm, int sampleRate) throws Exception {
+        int numChannels = 1;
+        int bitsPerSample = 32;
+        int byteRate = sampleRate * numChannels * (bitsPerSample / 8);
+        int subchunk2Size = pcm.length * numChannels * (bitsPerSample / 8);
+        int chunkSize = 36 + subchunk2Size;
+
+        try (FileOutputStream fos = new FileOutputStream(out)) {
+            fos.write(new byte[] { 'R','I','F','F' });
+            fos.write(intLE(chunkSize));
+            fos.write(new byte[] { 'W','A','V','E' });
+
+            fos.write(new byte[] { 'f','m','t',' ' });
+            fos.write(intLE(16));
+            fos.write(shortLE((short) 3)); // IEEE float
+            fos.write(shortLE((short) numChannels));
+            fos.write(intLE(sampleRate));
+            fos.write(intLE(byteRate));
+            fos.write(shortLE((short) (numChannels * (bitsPerSample / 8))));
+            fos.write(shortLE((short) bitsPerSample));
+
+            fos.write(new byte[] { 'd','a','t','a' });
+            fos.write(intLE(subchunk2Size));
+
+            ByteBuffer bb = ByteBuffer.allocate(pcm.length * 4).order(ByteOrder.LITTLE_ENDIAN);
+            for (float v : pcm) bb.putFloat(v);
+            fos.write(bb.array());
+        }
+    }
+    // ADD
+    private static void mixI16InterleavedToMonoF32(short[] src, int channels, float[] dst) {
+        int frames = dst.length, idx = 0;
+        for (int f = 0; f < frames; f++) {
+            int acc = 0;
+            for (int ch = 0; ch < channels; ch++) acc += src[idx++];
+            dst[f] = (acc / (float) channels) / 32768.0f;
+        }
+    }
+    // ADD
+    private static void mixI16PlanarToMonoF32(short[] src, int frames, int channels, float[] dst) {
+        int plane = frames;
+        for (int f = 0; f < frames; f++) {
+            int acc = 0;
+            for (int ch = 0; ch < channels; ch++) acc += src[ch * plane + f];
+            dst[f] = (acc / (float) channels) / 32768.0f;
+        }
+    }
+    // ADD
+    private static void mixF32InterleavedToMono(float[] src, int channels, float[] dst) {
+        int frames = dst.length, idx = 0;
+        for (int f = 0; f < frames; f++) {
+            float acc = 0f;
+            for (int ch = 0; ch < channels; ch++) acc += src[idx++];
+            dst[f] = acc / channels;
+        }
+    }
+    // ADD
+    private static void mixF32PlanarToMono(float[] src, int frames, int channels, float[] dst) {
+        int plane = frames;
+        for (int f = 0; f < frames; f++) {
+            float acc = 0f;
+            for (int ch = 0; ch < channels; ch++) acc += src[ch * plane + f];
+            dst[f] = acc / channels;
+        }
+    }
+    
+    @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 {
+            File f = resolveToLocalFileForRead(pathOrURL, "wav");
+            if (f == null) {
+                promise.reject("bad_path", "Empty/invalid pathOrURL");
+                return;
+            }
+            if (!f.exists()) {
+                promise.reject("file_missing", "WAV file does not exist at path: " + f.getAbsolutePath());
+                return;
+            }
+            Log.d(TAG, "Playing WAV from: " + f.getAbsolutePath());
+            tts.playWav(f, markAsLast);
+            promise.resolve("queued");
+        } catch (Exception e) {
+            Log.e(TAG, "PlayWavError: " + e.getMessage(), e);
+            promise.reject("PlayWavError", e.getMessage(), e);
+        }
+
+    }
+
+    @ReactMethod
+    public void playBuffer(ReadableMap desc, Promise promise) {
+        try {
+            if (desc == null ||
+                !desc.hasKey("base64") || desc.isNull("base64") ||
+                !desc.hasKey("sampleRate") || desc.isNull("sampleRate") ||
+                !desc.hasKey("format") || desc.isNull("format")) {
+                promise.reject("invalid_args", "Missing one of base64/sampleRate/format");
+                return;
+            }
+            final String base64 = desc.getString("base64");
+            final int sampleRate = desc.getInt("sampleRate");
+            final String format = desc.getString("format");
+            final int channels = desc.hasKey("channels") && !desc.isNull("channels") ? desc.getInt("channels") : 1;
+            final boolean interleaved = desc.hasKey("interleaved") && !desc.isNull("interleaved") ? desc.getBoolean("interleaved") : true;
+            final boolean markAsLast = desc.hasKey("markAsLast") && !desc.isNull("markAsLast") ? desc.getBoolean("markAsLast") : true;
+            if (sampleRate <= 0 || channels <= 0) {
+                promise.reject("bad_params", "sampleRate and channels must be > 0");
+                return;
+            }
+
+            final byte[] raw = b64(base64);
+            if (raw == null || raw.length == 0) {
+                promise.reject("bad_base64", "Could not decode base64 payload");
+                return;
+            }
+
+            float[] mono;
+            if ("i16".equalsIgnoreCase(format)) {
+                if (raw.length % 2 != 0) {
+                    promise.reject("bad_buffer", "i16 payload length not multiple of 2");
+                    return;
+                }
+                int frames = (raw.length / 2) / Math.max(1, channels);
+                mono = new float[frames];
+
+                short[] s = new short[raw.length / 2];
+                ByteBuffer bb = ByteBuffer.wrap(raw).order(ByteOrder.LITTLE_ENDIAN);
+                for (int i = 0; i < s.length; i++) s[i] = bb.getShort();
+
+                if (channels == 1) {
+                    for (int i = 0; i < frames; i++) mono[i] = s[i] / 32768.0f;
+                } else if (interleaved) {
+                    mixI16InterleavedToMonoF32(s, channels, mono);
+                } else {
+                    mixI16PlanarToMonoF32(s, frames, channels, mono);
+                }
+            } else if ("f32".equalsIgnoreCase(format)) {
+                if (raw.length % 4 != 0) {
+                    promise.reject("bad_buffer", "f32 payload length not multiple of 4");
+                    return;
+                }
+                int totalFloats = raw.length / 4;
+                float[] f = new float[totalFloats];
+                ByteBuffer bb = ByteBuffer.wrap(raw).order(ByteOrder.LITTLE_ENDIAN);
+                for (int i = 0; i < totalFloats; i++) f[i] = bb.getFloat();
+
+                int frames = totalFloats / Math.max(1, channels);
+                mono = new float[frames];
+
+                if (channels == 1) {
+                    System.arraycopy(f, 0, mono, 0, frames);
+                } else if (interleaved) {
+                    mixF32InterleavedToMono(f, channels, mono);
+                } else {
+                    mixF32PlanarToMono(f, frames, channels, mono);
+                }
+            } else {
+                promise.reject("bad_format", "format must be 'i16' or 'f32'");
+                return;
+            }
+
+            File out = new File(reactCtx.getCacheDir(), "extbuf_" + System.currentTimeMillis() + ".wav");
+            writeWavF32(out, mono, sampleRate);
+
+            tts.playWav(out, markAsLast);
+            promise.resolve("queued");
+        } catch (Exception e) {
+            promise.reject("PlayBufferError", e.getMessage(), e);
+        }
+    }
+
+    // RN event API stubs (required by RN)
+    @ReactMethod public void addListener(String eventName) { /* no-op */ }
+    @ReactMethod public void removeListeners(double count) { /* no-op */ }
+}