react-native-sherpa-onnx 0.3.5 → 0.3.7

package/android/src/main/java/com/sherpaonnx/SherpaOnnxArchiveHelper.kt

@@ -1,7 +1,10 @@
 package com.sherpaonnx
 
+import android.content.Context
+import android.util.Log
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
+import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 import java.util.concurrent.atomic.AtomicBoolean
@@ -11,11 +14,12 @@ import java.util.concurrent.atomic.AtomicBoolean
  * This class delegates to C++ native implementation via JNI.
  */
 class SherpaOnnxArchiveHelper {
-  private val cancelRequested = AtomicBoolean(false)
-
   companion object {
-    /** Single-thread executor so extractions run off the React Native bridge thread and do not block listDownloadedModelsByCategory / RNFS. */
-    private val extractExecutor: ExecutorService = Executors.newSingleThreadExecutor()
+    /** Thread pool for extractions – allows up to 2 concurrent extractions while keeping them off the React Native bridge thread. */
+    private val extractExecutor: ExecutorService = Executors.newFixedThreadPool(2)
+
+    /** Per-source-path cancellation flags. Key = absolute source archive path. */
+    private val cancelFlags = ConcurrentHashMap<String, AtomicBoolean>()
 
     init {
       try {
@@ -27,10 +31,24 @@ class SherpaOnnxArchiveHelper {
   }
 
   fun cancelExtractTarBz2() {
-    cancelRequested.set(true)
+    // Cancel ALL ongoing extractions (legacy global cancel)
+    for (flag in cancelFlags.values) flag.set(true)
+    nativeCancelExtract()
+  }
+
+  fun cancelExtractTarZst() {
+    // Cancel ALL ongoing extractions (legacy global cancel)
+    for (flag in cancelFlags.values) flag.set(true)
     nativeCancelExtract()
   }
 
+  /** Cancel a specific extraction identified by its source archive path. */
+  fun cancelExtractBySourcePath(sourcePath: String) {
+    // Only set the per-path flag; do not call nativeCancelExtract() since that is
+    // a global cancel that would also interrupt unrelated concurrent extractions.
+    cancelFlags[sourcePath]?.set(true)
+  }
+
   fun extractTarBz2(
     sourcePath: String,
     targetPath: String,
@@ -48,7 +66,9 @@ class SherpaOnnxArchiveHelper {
     }
 
     try {
-      cancelRequested.set(false)
+      // Register per-path cancel flag
+      val cancelFlag = AtomicBoolean(false)
+      cancelFlags[sourcePath] = cancelFlag
 
       // Create a progress callback object that JNI can call
       val progressCallback = object : Any() {
@@ -58,19 +78,113 @@ class SherpaOnnxArchiveHelper {
       }
 
       // Run extraction on a background thread so the React Native bridge thread is not blocked.
-      // Otherwise listDownloadedModelsByCategory (RNFS) and other native calls would wait until extraction finishes.
+      // The thread pool allows multiple extractions in parallel.
       extractExecutor.execute {
         try {
+          // Check per-path cancel flag before starting the native extraction.
+          if (cancelFlag.get()) {
+            resolveOnce(false, "Cancelled")
+            return@execute
+          }
           nativeExtractTarBz2(sourcePath, targetPath, force, progressCallback, promise)
         } catch (e: Exception) {
           resolveOnce(false, "Archive extraction error: ${e.message}")
+        } finally {
+          cancelFlags.remove(sourcePath)
+        }
+      }
+    } catch (e: Exception) {
+      cancelFlags.remove(sourcePath)
+      resolveOnce(false, "Archive extraction error: ${e.message}")
+    }
+  }
+
+  fun extractTarZst(
+    sourcePath: String,
+    targetPath: String,
+    force: Boolean,
+    promise: Promise,
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit
+  ) {
+    val promiseSettled = AtomicBoolean(false)
+    fun resolveOnce(success: Boolean, reason: String? = null) {
+      if (!promiseSettled.compareAndSet(false, true)) return
+      val result = Arguments.createMap()
+      result.putBoolean("success", success)
+      if (reason != null) result.putString("reason", reason)
+      promise.resolve(result)
+    }
+
+    try {
+      val cancelFlag = AtomicBoolean(false)
+      cancelFlags[sourcePath] = cancelFlag
+
+      val progressCallback = object : Any() {
+        fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
+          onProgress(bytesExtracted, totalBytes, percent)
+        }
+      }
+      extractExecutor.execute {
+        try {
+          // Check per-path cancel flag before starting the native extraction.
+          if (cancelFlag.get()) {
+            resolveOnce(false, "Cancelled")
+            return@execute
+          }
+          nativeExtractTarZst(sourcePath, targetPath, force, progressCallback, promise)
+        } catch (e: Exception) {
+          resolveOnce(false, "Archive extraction error: ${e.message}")
+        } finally {
+          cancelFlags.remove(sourcePath)
         }
       }
     } catch (e: Exception) {
+      cancelFlags.remove(sourcePath)
       resolveOnce(false, "Archive extraction error: ${e.message}")
     }
   }
 
+  fun extractTarZstFromAsset(
+    context: Context,
+    assetPath: String,
+    targetPath: String,
+    force: Boolean,
+    promise: Promise,
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit
+  ) {
+    if (BuildConfig.DEBUG) {
+      Log.i("SherpaOnnx", "extractTarZstFromAsset assetPath=$assetPath targetPath=$targetPath")
+    }
+    val progressCallback = object : Any() {
+      fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
+        onProgress(bytesExtracted, totalBytes, percent)
+      }
+    }
+    extractExecutor.execute {
+      try {
+        context.assets.open(assetPath).use { stream ->
+          nativeExtractTarZstFromStream(stream, targetPath, force, progressCallback, promise)
+        }
+      } catch (e: Exception) {
+        val result = Arguments.createMap()
+        result.putBoolean("success", false)
+        result.putString("reason", e.message ?: "Failed to open asset")
+        promise.resolve(result)
+      }
+    }
+  }
+
+  fun extractTarBz2FromAsset(
+    context: Context,
+    assetPath: String,
+    targetPath: String,
+    force: Boolean,
+    promise: Promise,
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit
+  ) {
+    extractTarZstFromAsset(context, assetPath, targetPath, force, promise, onProgress)
+  }
+
   fun computeFileSha256(filePath: String, promise: Promise) {
     nativeComputeFileSha256(filePath, promise)
   }
@@ -84,6 +198,22 @@ class SherpaOnnxArchiveHelper {
     promise: Promise
   )
 
+  private external fun nativeExtractTarZst(
+    sourcePath: String,
+    targetPath: String,
+    force: Boolean,
+    progressCallback: Any?,
+    promise: Promise
+  )
+
+  private external fun nativeExtractTarZstFromStream(
+    inputStream: java.io.InputStream,
+    targetPath: String,
+    force: Boolean,
+    progressCallback: Any?,
+    promise: Promise
+  )
+
   private external fun nativeCancelExtract()
 
   private external fun nativeComputeFileSha256(

package/android/src/main/java/com/sherpaonnx/SherpaOnnxAssetHelper.kt

@@ -82,10 +82,12 @@ internal class SherpaOnnxAssetHelper(
     try {
       val baseDir = File(path)
       if (!baseDir.exists()) {
-        throw IllegalArgumentException("Path does not exist: $path")
+        promise.resolve(Arguments.createArray())
+        return
       }
       if (!baseDir.isDirectory) {
-        throw IllegalArgumentException("Path is not a directory: $path")
+        promise.resolve(Arguments.createArray())
+        return
       }
 
       val folders = mutableListOf<String>()
@@ -134,11 +136,18 @@ internal class SherpaOnnxAssetHelper(
     try {
       Log.i(logTag, "getAssetPackPath: packName=$packName")
       val assetPackManager = AssetPackManagerFactory.getInstance(context)
-      val location: AssetPackLocation? = assetPackManager.getPackLocation(packName)
+      var location: AssetPackLocation? = assetPackManager.getPackLocation(packName)
       if (location == null) {
-        Log.i(logTag, "getAssetPackPath: location is null for pack '$packName'")
-        promise.resolve(null)
-        return
+        val allLocations = assetPackManager.getPackLocations()
+        location = allLocations?.get(packName)
+        if (allLocations != null) {
+          Log.i(logTag, "getAssetPackPath: getPackLocation was null, getPackLocations keys=${allLocations.keys}")
+        }
+        if (location == null) {
+          Log.i(logTag, "getAssetPackPath: location is null for pack '$packName'")
+          promise.resolve(null)
+          return
+        }
       }
       Log.i(logTag, "getAssetPackPath: storageMethod=${location.packStorageMethod()}, " +
         "assetsPath=${location.assetsPath()}, path=${location.path()}")
@@ -170,6 +179,42 @@ internal class SherpaOnnxAssetHelper(
     }
   }
 
+  /**
+   * Lists asset paths of .tar.zst and .tar.bz2 archives in a PAD pack when stored as APK_ASSETS.
+   * Returns empty array when pack is null or STORAGE_FILES (caller uses path + readDir in that case).
+   * APK_ASSETS: pack content is merged into the app asset root; canonical path is "models"
+   * (pack layout src/main/assets/models/). Same for Play Store and bundletool install-time delivery.
+   */
+  fun listBundledArchiveAssetPaths(packName: String, promise: Promise) {
+    try {
+      val assetPackManager = AssetPackManagerFactory.getInstance(context)
+      var location: AssetPackLocation? = assetPackManager.getPackLocation(packName)
+      if (location == null) {
+        location = assetPackManager.getPackLocations()?.get(packName)
+      }
+      if (location == null) {
+        promise.resolve(Arguments.createArray())
+        return
+      }
+      if (location.packStorageMethod() != AssetPackStorageMethod.STORAGE_FILES) {
+        val assetPrefix = "models"
+        val names = context.assets.list(assetPrefix) ?: emptyArray()
+        val archives = names.filter { it.endsWith(".tar.zst") || it.endsWith(".tar.bz2") }
+        val result = Arguments.createArray()
+        for (name in archives) {
+          result.pushString("$assetPrefix/$name")
+        }
+        Log.i(logTag, "listBundledArchiveAssetPaths: packName=$packName prefix=$assetPrefix count=${result.size()}")
+        promise.resolve(result)
+      } else {
+        promise.resolve(Arguments.createArray())
+      }
+    } catch (e: Exception) {
+      Log.w(logTag, "listBundledArchiveAssetPaths failed: ${e.message}")
+      promise.resolve(Arguments.createArray())
+    }
+  }
+
   private fun resolveAssetPath(assetPath: String): String {
     Log.i(logTag, "resolveAssetPath: assetPath=$assetPath")
     val assetManager = context.assets

package/android/src/main/java/com/sherpaonnx/SherpaOnnxModule.kt

@@ -8,6 +8,7 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.k2fsa.sherpa.onnx.WaveReader
 
 @ReactModule(name = SherpaOnnxModule.NAME)
 class SherpaOnnxModule(reactContext: ReactApplicationContext) :
@@ -303,6 +304,22 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     promise.resolve(null)
   }
 
+  override fun extractTarZst(sourcePath: String, targetPath: String, force: Boolean, promise: Promise) {
+    archiveHelper.extractTarZst(sourcePath, targetPath, force, promise) { bytes, total, percent ->
+      emitExtractTarZstProgress(sourcePath, bytes, total, percent)
+    }
+  }
+
+  override fun cancelExtractTarZst(promise: Promise) {
+    archiveHelper.cancelExtractTarZst()
+    promise.resolve(null)
+  }
+
+  override fun cancelExtractBySourcePath(sourcePath: String, promise: Promise) {
+    archiveHelper.cancelExtractBySourcePath(sourcePath)
+    promise.resolve(null)
+  }
+
   override fun computeFileSha256(filePath: String, promise: Promise) {
     archiveHelper.computeFileSha256(filePath, promise)
   }
@@ -318,6 +335,17 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     eventEmitter.emit("extractTarBz2Progress", payload)
   }
 
+  private fun emitExtractTarZstProgress(sourcePath: String, bytes: Long, totalBytes: Long, percent: Double) {
+    val eventEmitter = reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+    val payload = Arguments.createMap()
+    payload.putString("sourcePath", sourcePath)
+    payload.putDouble("bytes", bytes.toDouble())
+    payload.putDouble("totalBytes", totalBytes.toDouble())
+    payload.putDouble("percent", percent)
+    eventEmitter.emit("extractTarZstProgress", payload)
+  }
+
   /**
    * Resolve asset path - copy from assets to internal storage if needed
    * Preserves the directory structure from assets (e.g., test_wavs/ stays as test_wavs/)
@@ -430,6 +458,7 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     val provider = if (options.hasKey("provider")) options.getString("provider") else null
     val ruleFsts = if (options.hasKey("ruleFsts")) options.getString("ruleFsts") else null
     val ruleFars = if (options.hasKey("ruleFars")) options.getString("ruleFars") else null
+    val dither = if (options.hasKey("dither")) options.getDouble("dither") else null
     val blankPenalty = if (options.hasKey("blankPenalty")) options.getDouble("blankPenalty") else null
     val debug = if (options.hasKey("debug")) options.getBoolean("debug") else null
     val rule1MustContainNonSilence = if (options.hasKey("rule1MustContainNonSilence")) options.getBoolean("rule1MustContainNonSilence") else null
@@ -454,6 +483,7 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
       provider,
       ruleFsts,
       ruleFars,
+      dither,
       blankPenalty,
       debug,
       rule1MustContainNonSilence,
@@ -690,6 +720,72 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  /**
+   * Decode audio to mono float samples (approx. [-1, 1]) and effective sample rate.
+   * Same path/URI handling as [convertAudioToFormat]. WAV may use [WaveReader] when no resample is requested.
+   */
+  override fun decodeAudioFileToFloatSamples(inputPath: String, targetSampleRateHz: Double?, promise: Promise) {
+    var tmpFile: java.io.File? = null
+    try {
+      val targetHz = (targetSampleRateHz ?: 0.0).toInt()
+      if (targetHz < 0) {
+        promise.reject("DECODE_ERROR", "targetSampleRateHz must be >= 0")
+        return
+      }
+      val (pathToUse, tmp) = resolveInputForConvert(inputPath)
+      tmpFile = tmp
+
+      if (pathToUse.endsWith(".wav", ignoreCase = true)) {
+        try {
+          val wave = WaveReader.readWave(pathToUse)
+          val s = wave.samples
+          if (s != null && s.isNotEmpty() && wave.sampleRate > 0 && (targetHz == 0 || targetHz == wave.sampleRate)) {
+            val map = Arguments.createMap()
+            val arr = Arguments.createArray()
+            for (i in s.indices) {
+              arr.pushDouble(s[i].toDouble())
+            }
+            map.putArray("samples", arr)
+            map.putInt("sampleRate", wave.sampleRate)
+            promise.resolve(map)
+            return
+          }
+        } catch (_: Throwable) {
+          // Fall through to FFmpeg/native path (e.g. odd WAV or resample requested).
+        }
+      }
+
+      val result = Companion.nativeDecodeAudioFileToFloatSamples(pathToUse, targetHz)
+      if (result.size == 1 && result[0] is String) {
+        promise.reject("DECODE_ERROR", result[0] as String)
+        return
+      }
+      if (result.size != 2 || result[0] !is FloatArray) {
+        promise.reject("DECODE_ERROR", "Unexpected native decode result")
+        return
+      }
+      val floats = result[0] as FloatArray
+      val rateObj = result.getOrNull(1) as? Number ?: run {
+        promise.reject("DECODE_ERROR", "Unexpected sample rate in native decode result")
+        return
+      }
+      val sr = rateObj.toInt()
+      val map = Arguments.createMap()
+      val arr = Arguments.createArray()
+      for (i in floats.indices) {
+        arr.pushDouble(floats[i].toDouble())
+      }
+      map.putArray("samples", arr)
+      map.putInt("sampleRate", sr)
+      promise.resolve(map)
+    } catch (e: Exception) {
+      android.util.Log.e(NAME, "DECODE_EXCEPTION: ${e.message}", e)
+      promise.reject("DECODE_EXCEPTION", e.message ?: "Failed to decode audio", e)
+    } finally {
+      tmpFile?.delete()
+    }
+  }
+
   // ==================== TTS Methods ====================
 
   /**
@@ -997,6 +1093,63 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     assetHelper.getAssetPackPath(packName, promise)
   }
 
+  override fun listBundledArchiveAssetPaths(packName: String, promise: Promise) {
+    assetHelper.listBundledArchiveAssetPaths(packName, promise)
+  }
+
+  override fun extractTarZstFromAsset(
+    assetPath: String,
+    targetPath: String,
+    force: Boolean,
+    promise: Promise
+  ) {
+    archiveHelper.extractTarZstFromAsset(
+      reactApplicationContext,
+      assetPath,
+      targetPath,
+      force,
+      promise
+    ) { bytes, total, percent ->
+      emitExtractTarZstProgress(assetPath, bytes, total, percent)
+    }
+  }
+
+  override fun extractTarBz2FromAsset(
+    assetPath: String,
+    targetPath: String,
+    force: Boolean,
+    promise: Promise
+  ) {
+    archiveHelper.extractTarBz2FromAsset(
+      reactApplicationContext,
+      assetPath,
+      targetPath,
+      force,
+      promise
+    ) { bytes, total, percent ->
+      emitExtractProgress(assetPath, bytes, total, percent)
+    }
+  }
+
+  override fun readAssetFileAsUtf8(assetPath: String, promise: Promise) {
+    // Validate assetPath to prevent path traversal: reject paths containing
+    // "..", starting with "/" or "\", or containing backslashes.
+    if (assetPath.contains("..") ||
+        assetPath.startsWith("/") ||
+        assetPath.startsWith("\\") ||
+        assetPath.contains("\\")) {
+      promise.reject("ASSET_READ_ERROR", "Invalid asset path: $assetPath")
+      return
+    }
+    try {
+      val content = reactApplicationContext.assets.open(assetPath).bufferedReader().use { it.readText() }
+      promise.resolve(content)
+    } catch (e: Exception) {
+      android.util.Log.e(NAME, "Failed to read asset $assetPath: ${e.message}", e)
+      promise.reject("ASSET_READ_ERROR", "Failed to read asset $assetPath: ${e.message}", e)
+    }
+  }
+
   companion object {
     const val NAME = "SherpaOnnx"
 
@@ -1039,5 +1192,11 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     /** Convert any supported audio file to WAV 16 kHz mono 16-bit PCM. Returns empty string on success, error message otherwise. Requires FFmpeg prebuilts. */
     @JvmStatic
     private external fun nativeConvertAudioToWav16k(inputPath: String, outputPath: String): String
+
+    /**
+     * On success: [FloatArray samples, Integer sampleRate]. On error: [String message].
+     */
+    @JvmStatic
+    private external fun nativeDecodeAudioFileToFloatSamples(inputPath: String, targetSampleRateHz: Int): Array<Any>
   }
 }

package/android/src/main/java/com/sherpaonnx/SherpaOnnxOnlineSttHelper.kt

@@ -132,6 +132,7 @@ internal class SherpaOnnxOnlineSttHelper(
     provider: String?,
     ruleFsts: String?,
     ruleFars: String?,
+    dither: Float?,
     blankPenalty: Float?,
     debug: Boolean?,
     rule1MustContainNonSilence: Boolean?,
@@ -233,7 +234,7 @@ internal class SherpaOnnxOnlineSttHelper(
     }
 
     return OnlineRecognizerConfig(
-      featConfig = FeatureConfig(sampleRate = 16000, featureDim = 80, dither = 0f),
+      featConfig = FeatureConfig(sampleRate = 16000, featureDim = 80, dither = dither ?: 0f),
       modelConfig = modelConfig,
       endpointConfig = endpointConfig,
       enableEndpoint = enableEndpoint,
@@ -260,6 +261,7 @@ internal class SherpaOnnxOnlineSttHelper(
     provider: String?,
     ruleFsts: String?,
     ruleFars: String?,
+    dither: Double?,
     blankPenalty: Double?,
     debug: Boolean?,
     rule1MustContainNonSilence: Boolean?,
@@ -286,6 +288,7 @@ internal class SherpaOnnxOnlineSttHelper(
         provider = provider,
         ruleFsts = ruleFsts,
         ruleFars = ruleFars,
+        dither = dither?.toFloat(),
         blankPenalty = blankPenalty?.toFloat(),
         debug = debug,
         rule1MustContainNonSilence = rule1MustContainNonSilence,