react-native-davoice-tts 1.0.221 → 1.0.223

package/TTSRNBridge.podspec

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

package/android/libs/com/davoice/tts/1.0.0/tts-1.0.0.aar.md5

@@ -1 +1 @@
-9d2393d89488225501c6523df0501188  tts-1.0.0.aar
+b6f649e4214247f6227a360f42a39d24  tts-1.0.0.aar

package/android/libs/com/davoice/tts/1.0.0/tts-1.0.0.aar.sha1

@@ -1 +1 @@
-d8c0705f0b2d412b01a39af75eff947192920ce7  tts-1.0.0.aar
+cb0eb9b0e301262eeee35378d269f5716fcfe679  tts-1.0.0.aar

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

@@ -9,6 +9,14 @@ 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 com.davoice.tts.DaVoiceTTSInterface;
 
@@ -92,6 +100,215 @@ public class DaVoiceTTSBridge extends ReactContextBaseJavaModule {
             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;
+        }
+    }
+// ADD
+@ReactMethod
+public void playWav(String pathOrURL, boolean markAsLast, Promise promise) {
+    try {
+        if (isHttpOrHttps(pathOrURL)) {
+            promise.reject("unsupported_url", "Remote URLs not supported. Download to a local file first.");
+            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 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 */ }