react-native-sherpa-onnx 0.3.2 → 0.3.4

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-detect-jni-common.cpp

@@ -83,4 +83,26 @@ jobject BuildDetectedModelsList(JNIEnv* env, const std::vector<DetectedModel>& m
   return list;
 }
 
+jobject BuildStringList(JNIEnv* env, const std::vector<std::string>& strings) {
+  jclass listClass = env->FindClass("java/util/ArrayList");
+  if (!listClass) return nullptr;
+  jmethodID listInit = env->GetMethodID(listClass, "<init>", "()V");
+  jmethodID listAdd = env->GetMethodID(listClass, "add", "(Ljava/lang/Object;)Z");
+  if (!listInit || !listAdd) {
+    env->DeleteLocalRef(listClass);
+    return nullptr;
+  }
+  jobject list = env->NewObject(listClass, listInit);
+  env->DeleteLocalRef(listClass);
+  if (!list) return nullptr;
+  for (const auto& s : strings) {
+    jstring jval = env->NewStringUTF(s.c_str());
+    if (jval) {
+      env->CallBooleanMethod(list, listAdd, jval);
+      env->DeleteLocalRef(jval);
+    }
+  }
+  return list;
+}
+
 }  // namespace sherpaonnx

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-detect-jni-common.h

@@ -14,6 +14,8 @@ namespace sherpaonnx {
 bool PutString(JNIEnv* env, jobject map, jmethodID putId, const char* key, const std::string& value);
 bool PutBoolean(JNIEnv* env, jobject map, jmethodID putId, const char* key, bool value);
 jobject BuildDetectedModelsList(JNIEnv* env, const std::vector<DetectedModel>& models);
+/** Build a Java ArrayList<String> from a vector of strings. Returns null on failure. */
+jobject BuildStringList(JNIEnv* env, const std::vector<std::string>& strings);
 
 }  // namespace sherpaonnx
 

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-model-detect-helper.cpp

@@ -35,8 +35,8 @@ bool ContainsToken(const std::string& value, const std::string& token) {
     return value.find(token) != std::string::npos;
 }
 
-bool IsOnnxFile(const FileEntry& entry) {
-    return EndsWith(entry.nameLower, ".onnx");
+bool IsOnnxOrOrtFile(const FileEntry& entry) {
+    return EndsWith(entry.nameLower, ".onnx") || EndsWith(entry.nameLower, ".ort");
 }
 
 std::string BaseName(const std::string& path) {
@@ -55,7 +55,7 @@ std::string ChooseLargest(
     std::uint64_t bestSize = 0;
 
     for (const auto& entry : files) {
-        if (!IsOnnxFile(entry)) continue;
+        if (!IsOnnxOrOrtFile(entry)) continue;
 
         bool hasExcluded = false;
         for (const auto& token : excludeTokens) {
@@ -212,9 +212,8 @@ std::string ToLower(std::string value) {
     return value;
 }
 
-std::string FindFileByName(const std::string& baseDir, const std::string& fileName, int maxDepth) {
+std::string FindFileByName(const std::vector<FileEntry>& files, const std::string& fileName) {
     std::string target = ToLower(fileName);
-    auto files = ListFilesRecursive(baseDir, maxDepth);
     for (const auto& entry : files) {
         if (entry.nameLower == target) {
             return entry.path;
@@ -223,149 +222,17 @@ std::string FindFileByName(const std::string& baseDir, const std::string& fileNa
     return "";
 }
 
-std::string FindFileEndingWith(const std::string& baseDir, const std::string& suffix, int maxDepth) {
+std::string FindFileEndingWith(const std::vector<FileEntry>& files, const std::string& suffix) {
     std::string targetSuffix = ToLower(suffix);
-    auto files = ListFilesRecursive(baseDir, maxDepth);
-    // 1) exact match (e.g. "tokens.txt")
     for (const auto& entry : files) {
-        if (entry.nameLower == targetSuffix) {
-            return entry.path;
-        }
+        if (entry.nameLower == targetSuffix) return entry.path;
     }
-
-    // 2) true suffix match (preferred over substring to avoid false positives
-    //    like "tokens.txt.bak" or "mytokens.txt.tmp").
     for (const auto& entry : files) {
-        if (EndsWith(entry.nameLower, targetSuffix)) {
+        if (targetSuffix.size() <= entry.nameLower.size() &&
+            std::equal(targetSuffix.rbegin(), targetSuffix.rend(), entry.nameLower.rbegin())) {
             return entry.path;
         }
     }
-
-    // 3) If we are looking for tokens, fallback to inspecting .txt files' contents.
-    //    Heuristic: many token files are plain text with lines like "token <index>".
-    if (targetSuffix.find("tokens") != std::string::npos) {
-        auto IsLikelyTokensFile = [](const std::string& path) -> bool {
-            std::ifstream ifs(path);
-            if (!ifs.is_open()) return false;
-            std::string line;
-            int total = 0;
-            int matched = 0;
-            const int maxLines = 2000;
-
-            while (total < maxLines && std::getline(ifs, line)) {
-                ++total;
-                if (line.empty()) continue;
-                // Trim trailing CR if present
-                if (!line.empty() && line.back() == '\r') line.pop_back();
-
-                // Check if the line ends with an integer index (common token format)
-                size_t sp = line.find_last_of(" \t");
-                if (sp != std::string::npos && sp + 1 < line.size()) {
-                    std::string idx = line.substr(sp + 1);
-                    bool allDigits = !idx.empty();
-                    for (char c : idx) {
-                        if (!std::isdigit(static_cast<unsigned char>(c))) { allDigits = false; break; }
-                    }
-                    if (allDigits) ++matched;
-                }
-            }
-
-            ifs.close();
-            if (total < 2) return false;
-            // Heuristic: at least half of non-empty lines should match the token pattern
-            return matched >= std::max(1, total / 2);
-        };
-
-        for (const auto& entry : files) {
-            if (EndsWith(entry.nameLower, ".txt")) {
-                if (IsLikelyTokensFile(entry.path)) {
-                    return entry.path;
-                }
-            }
-        }
-    }
-    return "";
-}
-
-std::string FindDirectoryByName(const std::string& baseDir, const std::string& dirName, int maxDepth) {
-    std::string target = ToLower(dirName);
-    std::vector<std::string> toVisit = ListDirectories(baseDir);
-    int depth = 0;
-
-    while (!toVisit.empty() && depth <= maxDepth) {
-        std::vector<std::string> next;
-        for (const auto& dir : toVisit) {
-            std::string name = dir;
-#if __cplusplus >= 201703L && __has_include(<filesystem>)
-            try {
-                name = fs::path(dir).filename().string();
-            } catch (const std::exception&) {
-            }
-#elif __has_include(<experimental/filesystem>)
-            try {
-                name = fs::path(dir).filename().string();
-            } catch (const std::exception&) {
-            }
-#else
-            name = BaseName(dir);
-#endif
-            if (ToLower(name) == target) {
-                return dir;
-            }
-            if (depth < maxDepth) {
-                auto nested = ListDirectories(dir);
-                next.insert(next.end(), nested.begin(), nested.end());
-            }
-        }
-        toVisit.swap(next);
-        depth += 1;
-    }
-
-    return "";
-}
-
-std::string ResolveTokenizerDir(const std::string& modelDir) {
-    std::string vocabInMain = modelDir + "/vocab.json";
-    if (FileExists(vocabInMain)) {
-        return modelDir;
-    }
-
-    std::vector<std::string> toVisit = ListDirectories(modelDir);
-    int depth = 0;
-    while (!toVisit.empty() && depth <= 2) {
-        std::vector<std::string> next;
-        for (const auto& dir : toVisit) {
-            std::string dirName = dir;
-#if __cplusplus >= 201703L && __has_include(<filesystem>)
-            try {
-                dirName = fs::path(dir).filename().string();
-            } catch (const std::exception&) {
-            }
-#elif __has_include(<experimental/filesystem>)
-            try {
-                dirName = fs::path(dir).filename().string();
-            } catch (const std::exception&) {
-            }
-#else
-            dirName = BaseName(dir);
-#endif
-            std::string dirNameLower = ToLower(dirName);
-            if (dirNameLower.find("qwen3") != std::string::npos) {
-                std::string vocabPath = dir + "/vocab.json";
-                if (FileExists(vocabPath)) {
-                    return dir;
-                }
-            }
-
-            if (depth < 2) {
-                auto nested = ListDirectories(dir);
-                next.insert(next.end(), nested.begin(), nested.end());
-            }
-        }
-        toVisit.swap(next);
-        depth += 1;
-    }
-
     return "";
 }
 
@@ -377,7 +244,7 @@ std::string FindOnnxByToken(
     std::vector<FileEntry> matches;
     std::string tokenLower = ToLower(token);
     for (const auto& entry : files) {
-        if (!IsOnnxFile(entry)) continue;
+        if (!IsOnnxOrOrtFile(entry)) continue;
         if (ContainsToken(entry.nameLower, tokenLower)) {
             matches.push_back(entry);
         }
@@ -407,6 +274,40 @@ std::string FindOnnxByAnyToken(
     return "";
 }
 
+std::string FindOnnxByAnyTokenExcluding(
+    const std::vector<FileEntry>& files,
+    const std::vector<std::string>& tokens,
+    const std::vector<std::string>& excludeInName,
+    const std::optional<bool>& preferInt8
+) {
+    for (const auto& token : tokens) {
+        std::string tokenLower = ToLower(token);
+        std::vector<FileEntry> matches;
+        for (const auto& entry : files) {
+            if (!IsOnnxOrOrtFile(entry)) continue;
+            if (!ContainsToken(entry.nameLower, tokenLower)) continue;
+            bool excluded = false;
+            for (const auto& ex : excludeInName) {
+                std::string exLower = ToLower(ex);
+                if (ContainsToken(entry.nameLower, exLower)) {
+                    excluded = true;
+                    break;
+                }
+            }
+            if (!excluded) matches.push_back(entry);
+        }
+        if (matches.empty()) continue;
+        std::vector<std::string> emptyTokens;
+        bool wantInt8 = preferInt8.has_value() && preferInt8.value();
+        bool wantNonInt8 = preferInt8.has_value() && !preferInt8.value();
+        std::string chosen = ChooseLargest(matches, emptyTokens, wantInt8, wantNonInt8);
+        if (!chosen.empty()) return chosen;
+        chosen = ChooseLargest(matches, emptyTokens, false, false);
+        if (!chosen.empty()) return chosen;
+    }
+    return "";
+}
+
 std::string FindLargestOnnx(const std::vector<FileEntry>& files) {
     std::vector<std::string> emptyTokens;
     return ChooseLargest(files, emptyTokens, false, false);
@@ -435,5 +336,58 @@ bool ContainsWord(const std::string& haystack, const std::string& word) {
     return false;
 }
 
+std::string FindDirectoryUnderRoot(
+    const std::vector<FileEntry>& files,
+    const std::string& rootDir,
+    const std::string& dirName
+) {
+    if (dirName.empty()) return "";
+    const std::string needle = "/" + dirName + "/";
+    const size_t dirPathLen = 1 + dirName.size();
+    for (const auto& entry : files) {
+        if (entry.path.size() < rootDir.size() + needle.size()) continue;
+        if (entry.path.compare(0, rootDir.size(), rootDir) != 0) continue;
+        size_t pos = entry.path.find(needle, rootDir.size());
+        if (pos != std::string::npos) {
+            return entry.path.substr(0, pos + dirPathLen);
+        }
+    }
+    return "";
+}
+
+std::vector<LexiconCandidate> FindLexiconCandidates(
+    const std::vector<FileEntry>& files,
+    const std::string& rootDir
+) {
+    std::vector<LexiconCandidate> candidates;
+    const size_t rootLen = rootDir.size();
+    for (const auto& entry : files) {
+        if (entry.path.size() <= rootLen) continue;
+        if (rootLen > 0) {
+            if (entry.path.compare(0, rootLen, rootDir) != 0) continue;
+            // Enforce path boundary: if rootDir doesn't end with '/', require '/' after it
+            if (rootDir.back() != '/' && entry.path[rootLen] != '/') continue;
+        }
+        std::string base = BaseName(entry.path);
+        if (base.empty()) continue;
+        std::string baseLower = ToLower(base);
+        if (baseLower == "lexicon.txt") {
+            candidates.push_back({entry.path, "default"});
+        } else if (baseLower.size() > 12 &&
+                   baseLower.compare(0, 8, "lexicon-") == 0 &&
+                   baseLower.compare(baseLower.size() - 4, 4, ".txt") == 0) {
+            std::string languageId = baseLower.substr(8, baseLower.size() - 12);
+            candidates.push_back({entry.path, languageId});
+        }
+    }
+    std::sort(candidates.begin(), candidates.end(), [](const LexiconCandidate& a, const LexiconCandidate& b) {
+        if (a.languageId == b.languageId) return a.path < b.path;
+        if (a.languageId == "default") return true;
+        if (b.languageId == "default") return false;
+        return a.languageId < b.languageId;
+    });
+    return candidates;
+}
+
 } // namespace model_detect
 } // namespace sherpaonnx

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-model-detect-helper.h

@@ -22,11 +22,11 @@ std::vector<std::string> ListDirectories(const std::string& path);
 std::vector<FileEntry> ListFiles(const std::string& path);
 std::vector<FileEntry> ListFilesRecursive(const std::string& path, int maxDepth = 2);
 std::string ToLower(std::string value);
-std::string ResolveTokenizerDir(const std::string& modelDir);
 
-std::string FindFileByName(const std::string& baseDir, const std::string& fileName, int maxDepth = 2);
-std::string FindFileEndingWith(const std::string& baseDir, const std::string& suffix, int maxDepth = 2);
-std::string FindDirectoryByName(const std::string& baseDir, const std::string& dirName, int maxDepth = 2);
+/** Find file in \p files whose name equals \p fileName (case-insensitive). Uses file tree only, no filesystem. */
+std::string FindFileByName(const std::vector<FileEntry>& files, const std::string& fileName);
+/** Find file in \p files whose name equals or ends with \p suffix (e.g. tokens.txt). Case-insensitive. */
+std::string FindFileEndingWith(const std::vector<FileEntry>& files, const std::string& suffix);
 
 std::string FindOnnxByToken(
     const std::vector<FileEntry>& files,
@@ -40,6 +40,14 @@ std::string FindOnnxByAnyToken(
     const std::optional<bool>& preferInt8
 );
 
+/** Like FindOnnxByAnyToken but skips any file whose nameLower contains any of \p excludeInName. */
+std::string FindOnnxByAnyTokenExcluding(
+    const std::vector<FileEntry>& files,
+    const std::vector<std::string>& tokens,
+    const std::vector<std::string>& excludeInName,
+    const std::optional<bool>& preferInt8
+);
+
 std::string FindLargestOnnx(
     const std::vector<FileEntry>& files
 );
@@ -52,6 +60,34 @@ std::string FindLargestOnnxExcludingTokens(
 /** Returns true if \p word appears in \p haystack as a standalone token (surrounded by separators: / - _ . space). */
 bool ContainsWord(const std::string& haystack, const std::string& word);
 
+/**
+ * Find a directory with the given name anywhere under \p rootDir in the file tree.
+ * Searches \p files for any path that starts with \p rootDir and contains "/dirName/".
+ * Returns the full path to that directory (e.g. rootDir/inner/dirName) or empty if not found.
+ * Used e.g. to find espeak-ng-data in modelDir or in modelDir/inner-model-dir/.
+ */
+std::string FindDirectoryUnderRoot(
+    const std::vector<FileEntry>& files,
+    const std::string& rootDir,
+    const std::string& dirName
+);
+
+/** Lexicon file with optional language id for multi-lang TTS (e.g. Kokoro). */
+struct LexiconCandidate {
+    std::string path;       /**< Full path to the lexicon file */
+    std::string languageId; /**< From filename: "default" for lexicon.txt, else e.g. "us-en", "zh" from lexicon-us-en.txt, lexicon-zh.txt */
+};
+
+/**
+ * Find all lexicon files under \p rootDir: exact "lexicon.txt" and any "lexicon-*.txt".
+ * Returns a list of LexiconCandidate (path + languageId), ordered: lexicon.txt first (as "default"),
+ * then lexicon-*.txt alphabetically by language id. Used for multi-language Kokoro/Kitten TTS.
+ */
+std::vector<LexiconCandidate> FindLexiconCandidates(
+    const std::vector<FileEntry>& files,
+    const std::string& rootDir
+);
+
 } // namespace model_detect
 } // namespace sherpaonnx