react-native-sherpa-onnx 0.3.8 → 0.4.0

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

@@ -389,5 +389,28 @@ std::vector<LexiconCandidate> FindLexiconCandidates(
     return candidates;
 }
 
+bool Qwen3TokenizerDirHasVocabAndMerges(
+    const std::vector<FileEntry>& files,
+    const std::string& dirRaw
+) {
+    std::string dir = dirRaw;
+    while (!dir.empty() && (dir.back() == '/' || dir.back() == '\\'))
+        dir.pop_back();
+    if (dir.empty()) return false;
+    bool hasVocab = false;
+    bool hasMerges = false;
+    const std::string prefix = dir + "/";
+    for (const auto& e : files) {
+        if (e.path.size() <= prefix.size()) continue;
+        if (e.path.compare(0, prefix.size(), prefix) != 0) continue;
+        std::string rest = e.path.substr(prefix.size());
+        if (rest.find('/') != std::string::npos || rest.find('\\') != std::string::npos) continue;
+        if (e.nameLower == "vocab.json") hasVocab = true;
+        if (e.nameLower == "merges.txt") hasMerges = true;
+    }
+    if (hasVocab && hasMerges) return true;
+    return FileExists(dir + "/vocab.json") && FileExists(dir + "/merges.txt");
+}
+
 } // namespace model_detect
 } // namespace sherpaonnx

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

@@ -88,6 +88,15 @@ std::vector<LexiconCandidate> FindLexiconCandidates(
     const std::string& rootDir
 );
 
+/**
+ * True if `dir` contains vocab.json and merges.txt: listed in `files` (fixture / synthetic trees)
+ * or present on disk. Used for Qwen3-ASR tokenizer directory detection.
+ */
+bool Qwen3TokenizerDirHasVocabAndMerges(
+    const std::vector<FileEntry>& files,
+    const std::string& dir
+);
+
 } // namespace model_detect
 } // namespace sherpaonnx
 

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

@@ -61,6 +61,7 @@ static const char* KindToName(SttModelKind k) {
         case SttModelKind::kZipformerCtc: return "zipformer_ctc";
         case SttModelKind::kWhisper: return "whisper";
         case SttModelKind::kFunAsrNano: return "funasr_nano";
+        case SttModelKind::kQwen3Asr: return "qwen3_asr";
         case SttModelKind::kFireRedAsr: return "fire_red_asr";
         case SttModelKind::kMoonshine: return "moonshine";
         case SttModelKind::kMoonshineV2: return "moonshine_v2";
@@ -88,6 +89,7 @@ SttModelKind ParseSttModelType(const std::string& modelType) {
     if (modelType == "zipformer_ctc" || modelType == "ctc") return SttModelKind::kZipformerCtc;
     if (modelType == "whisper") return SttModelKind::kWhisper;
     if (modelType == "funasr_nano") return SttModelKind::kFunAsrNano;
+    if (modelType == "qwen3_asr") return SttModelKind::kQwen3Asr;
     if (modelType == "fire_red_asr") return SttModelKind::kFireRedAsr;
     if (modelType == "moonshine") return SttModelKind::kMoonshine;
     if (modelType == "moonshine_v2") return SttModelKind::kMoonshineV2;
@@ -126,6 +128,8 @@ static bool CapabilitySupportsKind(
             return cap.hasWhisper;
         case SttModelKind::kFunAsrNano:
             return cap.hasFunAsrNano;
+        case SttModelKind::kQwen3Asr:
+            return cap.hasQwen3Asr;
         case SttModelKind::kFireRedAsr:
             return cap.hasFireRedAsr;
         case SttModelKind::kMoonshine:
@@ -189,6 +193,8 @@ static std::vector<SttModelKind> GetKindsFromDirName(const std::string& modelDir
         add(SttModelKind::kTransducer);
         add(SttModelKind::kZipformerCtc);
     }
+    if (lower.find("qwen3-asr") != std::string::npos || lower.find("qwen3_asr") != std::string::npos)
+        add(SttModelKind::kQwen3Asr);
     if (lower.find("funasr") != std::string::npos)
         add(SttModelKind::kFunAsrNano);
     if (lower.find("canary") != std::string::npos)
@@ -249,6 +255,19 @@ static SttCandidatePaths GatherSttCandidatePaths(
                 p.funasrTokenizerDir = vocabInSubdir.substr(0, lastSlash);
         }
     }
+    p.qwen3ConvFrontend = FindOnnxByAnyToken(files, {"conv_frontend"}, preferInt8);
+    {
+        for (const auto& entry : files) {
+            if (entry.nameLower != "tokenizer_config.json") continue;
+            size_t slash = entry.path.find_last_of("/\\");
+            if (slash == std::string::npos) continue;
+            std::string dir = entry.path.substr(0, slash);
+            if (Qwen3TokenizerDirHasVocabAndMerges(files, dir)) {
+                p.qwen3TokenizerDir = dir;
+                break;
+            }
+        }
+    }
     p.moonshinePreprocessor = FindOnnxByAnyToken(files, {"preprocess", "preprocessor"}, preferInt8);
     p.moonshineEncoder = FindOnnxByAnyToken(files, {"encode", "encoder_model"}, preferInt8);
     p.moonshineUncachedDecoder = FindOnnxByAnyToken(files, {"uncached_decode", "uncached"}, preferInt8);
@@ -258,7 +277,8 @@ static SttCandidatePaths GatherSttCandidatePaths(
     static const std::vector<std::string> modelExcludes = {
         "encoder", "decoder", "joiner", "vocoder", "acoustic", "embedding", "llm",
         "encoder_adaptor", "encoder-adaptor", "encoder_model", "decoder_model",
-        "merged_decoder", "decoder_model_merged", "preprocess", "encode", "uncached", "cached"
+        "merged_decoder", "decoder_model_merged", "preprocess", "encode", "uncached", "cached",
+        "conv_frontend"
     };
     p.paraformerModel = FindOnnxByAnyToken(files, {"model"}, preferInt8);
     if (!p.paraformerModel.empty()) {
@@ -302,6 +322,7 @@ static SttPathHints GetSttPathHints(const std::string& modelDir) {
     h.isLikelyWenetCtc = lower.find("wenet") != std::string::npos;
     h.isLikelySenseVoice = lower.find("sense") != std::string::npos || lower.find("sensevoice") != std::string::npos;
     h.isLikelyFunAsrNano = lower.find("funasr") != std::string::npos || lower.find("funasr-nano") != std::string::npos;
+    h.isLikelyQwen3Asr = lower.find("qwen3-asr") != std::string::npos || lower.find("qwen3_asr") != std::string::npos;
     h.isLikelyZipformer = lower.find("zipformer") != std::string::npos;
     h.isLikelyMoonshine = lower.find("moonshine") != std::string::npos;
     h.isLikelyDolphin = lower.find("dolphin") != std::string::npos;
@@ -404,7 +425,9 @@ static SttCapabilities ComputeSttCapabilities(const SttCandidatePaths& paths, co
     c.hasTransducer = !paths.encoder.empty() && !paths.decoder.empty() && !paths.joiner.empty();
     bool hasWhisperEnc = !paths.encoder.empty();
     bool hasWhisperDec = !paths.decoder.empty();
-    c.hasWhisper = hasWhisperEnc && hasWhisperDec && paths.joiner.empty();
+    bool hasQwen3Tok = !paths.qwen3TokenizerDir.empty();
+    c.hasQwen3Asr = !paths.qwen3ConvFrontend.empty() && hasWhisperEnc && hasWhisperDec && hasQwen3Tok;
+    c.hasWhisper = hasWhisperEnc && hasWhisperDec && paths.joiner.empty() && !c.hasQwen3Asr;
     bool hasFunAsrTok = !paths.funasrTokenizerDir.empty();
     c.hasFunAsrNano = !paths.funasrEncoderAdaptor.empty() && !paths.funasrLLM.empty() &&
                       !paths.funasrEmbedding.empty() && hasFunAsrTok;
@@ -446,6 +469,7 @@ static void CollectDetectedModels(
         out.push_back({"paraformer", modelDir});
     }
     if (cap.hasWhisper) out.push_back({"whisper", modelDir});
+    if (cap.hasQwen3Asr) out.push_back({"qwen3_asr", modelDir});
     if (cap.hasFunAsrNano) out.push_back({"funasr_nano", modelDir});
     if (cap.hasMoonshine) out.push_back({"moonshine", modelDir});
     if (cap.hasMoonshineV2) out.push_back({"moonshine_v2", modelDir});
@@ -507,6 +531,10 @@ static SttModelKind ResolveSttKind(
             outError = "FunASR Nano model requested but required files not found in " + modelDir;
             return SttModelKind::kUnknown;
         }
+        if (selected == SttModelKind::kQwen3Asr && !cap.hasQwen3Asr) {
+            outError = "Qwen3-ASR model requested but conv_frontend/encoder/decoder/tokenizer not found in " + modelDir;
+            return SttModelKind::kUnknown;
+        }
         if (selected == SttModelKind::kMoonshine && !cap.hasMoonshine) {
             outError = "Moonshine v1 model requested but preprocess/encode/uncached_decode/cached_decode not found in " + modelDir;
             return SttModelKind::kUnknown;
@@ -573,7 +601,9 @@ static SttModelKind ResolveSttKind(
     if (!paths.paraformerModel.empty()) return SttModelKind::kParaformer;
     if (cap.hasCanary) return SttModelKind::kCanary;
     if (cap.hasFireRedAsr) return SttModelKind::kFireRedAsr;
+    if (cap.hasQwen3Asr && hints.isLikelyQwen3Asr) return SttModelKind::kQwen3Asr;
     if (cap.hasWhisper) return SttModelKind::kWhisper;
+    if (cap.hasQwen3Asr) return SttModelKind::kQwen3Asr;
     if (cap.hasFunAsrNano) return SttModelKind::kFunAsrNano;
     if (cap.hasMoonshineV2) return SttModelKind::kMoonshineV2;
     if (cap.hasDolphin) return SttModelKind::kDolphin;
@@ -618,6 +648,12 @@ static void ApplyPathsForSttKind(SttModelKind kind, const SttCandidatePaths& can
             resultPaths.funasrEmbedding = candidate.funasrEmbedding;
             resultPaths.funasrTokenizer = candidate.funasrTokenizerDir;
             break;
+        case SttModelKind::kQwen3Asr:
+            resultPaths.qwen3ConvFrontend = candidate.qwen3ConvFrontend;
+            resultPaths.qwen3Encoder = candidate.encoder;
+            resultPaths.qwen3Decoder = candidate.decoder;
+            resultPaths.qwen3Tokenizer = candidate.qwen3TokenizerDir;
+            break;
         case SttModelKind::kMoonshine:
             resultPaths.moonshinePreprocessor = candidate.moonshinePreprocessor;
             resultPaths.moonshineEncoder = candidate.moonshineEncoder;
@@ -711,13 +747,13 @@ SttDetectResult DetectSttModel(
             EmptyOrPath(candidate.encoder), EmptyOrPath(candidate.decoder));
         LOGI("DetectSttModel: funasr encoderAdaptor=%s llm=%s embedding=%s tokenizerDir=%s",
             EmptyOrPath(candidate.funasrEncoderAdaptor), EmptyOrPath(candidate.funasrLLM), EmptyOrPath(candidate.funasrEmbedding), EmptyOrPath(candidate.funasrTokenizerDir));
-        LOGI("DetectSttModel: hasTransducer=%d hasWhisper=%d hasMoonshine=%d hasMoonshineV2=%d hasParaformer=%d hasFunAsrNano=%d hasDolphin=%d hasFireRedAsr=%d hasFireRedCtc=%d hasCanary=%d hasOmnilingual=%d hasMedAsr=%d hasTeleSpeechCtc=%d hasToneCtc=%d",
+        LOGI("DetectSttModel: hasTransducer=%d hasWhisper=%d hasMoonshine=%d hasMoonshineV2=%d hasParaformer=%d hasFunAsrNano=%d hasQwen3Asr=%d hasDolphin=%d hasFireRedAsr=%d hasFireRedCtc=%d hasCanary=%d hasOmnilingual=%d hasMedAsr=%d hasTeleSpeechCtc=%d hasToneCtc=%d",
             (int)cap.hasTransducer, (int)cap.hasWhisper, (int)cap.hasMoonshine, (int)cap.hasMoonshineV2,
-            (int)cap.hasParaformer, (int)cap.hasFunAsrNano, (int)cap.hasDolphin, (int)cap.hasFireRedAsr, (int)cap.hasFireRedCtc,
+            (int)cap.hasParaformer, (int)cap.hasFunAsrNano, (int)cap.hasQwen3Asr, (int)cap.hasDolphin, (int)cap.hasFireRedAsr, (int)cap.hasFireRedCtc,
             (int)cap.hasCanary, (int)cap.hasOmnilingual, (int)cap.hasMedAsr, (int)cap.hasTeleSpeechCtc, (int)cap.hasToneCtc);
-        LOGI("DetectSttModel: hints isLikelyNemo=%d isLikelyTdt=%d isLikelyWenetCtc=%d isLikelySenseVoice=%d isLikelyFunAsrNano=%d isLikelyZipformer=%d isLikelyMoonshine=%d isLikelyDolphin=%d isLikelyFireRedAsr=%d isLikelyCanary=%d isLikelyOmnilingual=%d isLikelyMedAsr=%d isLikelyTeleSpeech=%d isLikelyToneCtc=%d isLikelyParaformer=%d isLikelyVad=%d isLikelyTdnn=%d",
+        LOGI("DetectSttModel: hints isLikelyNemo=%d isLikelyTdt=%d isLikelyWenetCtc=%d isLikelySenseVoice=%d isLikelyFunAsrNano=%d isLikelyQwen3Asr=%d isLikelyZipformer=%d isLikelyMoonshine=%d isLikelyDolphin=%d isLikelyFireRedAsr=%d isLikelyCanary=%d isLikelyOmnilingual=%d isLikelyMedAsr=%d isLikelyTeleSpeech=%d isLikelyToneCtc=%d isLikelyParaformer=%d isLikelyVad=%d isLikelyTdnn=%d",
              (int)hints.isLikelyNemo, (int)hints.isLikelyTdt, (int)hints.isLikelyWenetCtc, (int)hints.isLikelySenseVoice,
-             (int)hints.isLikelyFunAsrNano, (int)hints.isLikelyZipformer, (int)hints.isLikelyMoonshine, (int)hints.isLikelyDolphin,
+             (int)hints.isLikelyFunAsrNano, (int)hints.isLikelyQwen3Asr, (int)hints.isLikelyZipformer, (int)hints.isLikelyMoonshine, (int)hints.isLikelyDolphin,
              (int)hints.isLikelyFireRedAsr, (int)hints.isLikelyCanary, (int)hints.isLikelyOmnilingual, (int)hints.isLikelyMedAsr,
              (int)hints.isLikelyTeleSpeech, (int)hints.isLikelyToneCtc, (int)hints.isLikelyParaformer, (int)hints.isLikelyVad, (int)hints.isLikelyTdnn);
     }
@@ -747,7 +783,8 @@ SttDetectResult DetectSttModel(
     }
 
     LOGI("DetectSttModel: selected kind=%d (%s)", static_cast<int>(result.selectedKind), KindToName(result.selectedKind));
-    result.tokensRequired = (result.selectedKind != SttModelKind::kFunAsrNano);
+    result.tokensRequired = (result.selectedKind != SttModelKind::kFunAsrNano &&
+                             result.selectedKind != SttModelKind::kQwen3Asr);
     ApplyPathsForSttKind(result.selectedKind, candidate, result.paths);
 
     if (!candidate.tokens.empty() && FileExists(candidate.tokens)) {
@@ -808,6 +845,11 @@ SttDetectResult DetectSttModel(
                  EmptyOrPath(result.paths.funasrEncoderAdaptor), EmptyOrPath(result.paths.funasrLLM),
                  EmptyOrPath(result.paths.funasrEmbedding), EmptyOrPath(result.paths.funasrTokenizer));
             break;
+        case SttModelKind::kQwen3Asr:
+            LOGI("DetectSttModel: paths set qwen3_asr conv=%s encoder=%s decoder=%s tokenizer=%s",
+                 EmptyOrPath(result.paths.qwen3ConvFrontend), EmptyOrPath(result.paths.qwen3Encoder),
+                 EmptyOrPath(result.paths.qwen3Decoder), EmptyOrPath(result.paths.qwen3Tokenizer));
+            break;
         default:
             break;
     }
@@ -854,7 +896,8 @@ SttDetectResult DetectSttModelFromFileList(
         return result;
     }
 
-    result.tokensRequired = (result.selectedKind != SttModelKind::kFunAsrNano);
+    result.tokensRequired = (result.selectedKind != SttModelKind::kFunAsrNano &&
+                             result.selectedKind != SttModelKind::kQwen3Asr);
     ApplyPathsForSttKind(result.selectedKind, candidate, result.paths);
 
     result.paths.tokens = candidate.tokens;

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

@@ -20,6 +20,7 @@ enum class SttModelKind {
     kZipformerCtc,
     kWhisper,
     kFunAsrNano,
+    kQwen3Asr,
     kFireRedAsr,
     kMoonshine,
     kMoonshineV2,
@@ -42,6 +43,12 @@ enum class TtsModelKind {
     kSupertonic
 };
 
+enum class EnhancementModelKind {
+    kUnknown,
+    kGtcrn,
+    kDpdfNet
+};
+
 struct SttModelPaths {
     std::string encoder;
     std::string decoder;
@@ -57,6 +64,11 @@ struct SttModelPaths {
     std::string funasrLLM;
     std::string funasrEmbedding;
     std::string funasrTokenizer;
+    /** Qwen3-ASR: conv_frontend + encoder + decoder + tokenizer directory. */
+    std::string qwen3ConvFrontend;
+    std::string qwen3Encoder;
+    std::string qwen3Decoder;
+    std::string qwen3Tokenizer;
     // Moonshine
     std::string moonshinePreprocessor;
     std::string moonshineEncoder;
@@ -89,6 +101,8 @@ struct SttCandidatePaths {
     std::string funasrLLM;
     std::string funasrEmbedding;
     std::string funasrTokenizerDir;
+    std::string qwen3ConvFrontend;
+    std::string qwen3TokenizerDir;
     std::string moonshinePreprocessor;
     std::string moonshineEncoder;
     std::string moonshineUncachedDecoder;
@@ -104,6 +118,7 @@ struct SttPathHints {
     bool isLikelyWenetCtc = false;
     bool isLikelySenseVoice = false;
     bool isLikelyFunAsrNano = false;
+    bool isLikelyQwen3Asr = false;
     bool isLikelyZipformer = false;
     bool isLikelyMoonshine = false;
     bool isLikelyDolphin = false;
@@ -128,6 +143,7 @@ struct SttCapabilities {
     bool hasMoonshineV2 = false;
     bool hasParaformer = false;
     bool hasFunAsrNano = false;
+    bool hasQwen3Asr = false;
     bool hasDolphin = false;
     bool hasFireRedAsr = false;
     /** True when dir name suggests Fire Red but only a single CTC/paraformer model (no encoder/decoder). Use zipformer_ctc. */
@@ -164,6 +180,10 @@ struct TtsModelPaths {
     std::string voiceStyle;
 };
 
+struct EnhancementModelPaths {
+    std::string model;
+};
+
 struct SttDetectResult {
     bool ok = false;
     std::string error;
@@ -185,6 +205,14 @@ struct TtsDetectResult {
     std::vector<std::string> lexiconLanguageCandidates;
 };
 
+struct EnhancementDetectResult {
+    bool ok = false;
+    std::string error;
+    std::vector<DetectedModel> detectedModels;
+    EnhancementModelKind selectedKind = EnhancementModelKind::kUnknown;
+    EnhancementModelPaths paths;
+};
+
 SttDetectResult DetectSttModel(
     const std::string& modelDir,
     const std::optional<bool>& preferInt8,
@@ -218,6 +246,19 @@ TtsDetectResult DetectTtsModelFromFileList(
     const std::string& modelType = "auto"
 );
 
+EnhancementDetectResult DetectEnhancementModel(
+    const std::string& modelDir,
+    const std::string& modelType
+);
+
+/** Test-only: Like DetectEnhancementModel but takes a pre-built file list; no filesystem access.
+ *  Only used by the host-side C++ test suite (test/cpp/model_detect_test.cpp). */
+EnhancementDetectResult DetectEnhancementModelFromFileList(
+    const std::vector<model_detect::FileEntry>& files,
+    const std::string& modelDir,
+    const std::string& modelType = "auto"
+);
+
 } // namespace sherpaonnx
 
 #endif // SHERPA_ONNX_MODEL_DETECT_H

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-stt-wrapper.cpp

@@ -23,6 +23,7 @@ const char* SttModelKindToString(SttModelKind k) {
     case SttModelKind::kZipformerCtc: return "zipformer_ctc";
     case SttModelKind::kWhisper: return "whisper";
     case SttModelKind::kFunAsrNano: return "funasr_nano";
+    case SttModelKind::kQwen3Asr: return "qwen3_asr";
     case SttModelKind::kFireRedAsr: return "fire_red_asr";
     case SttModelKind::kMoonshine: return "moonshine";
     case SttModelKind::kMoonshineV2: return "moonshine_v2";
@@ -79,6 +80,10 @@ jobject SttDetectResultToJava(JNIEnv* env, const SttDetectResult& result) {
       PutString(env, pathsMap, mapPut, "funasrLLM", result.paths.funasrLLM);
       PutString(env, pathsMap, mapPut, "funasrEmbedding", result.paths.funasrEmbedding);
       PutString(env, pathsMap, mapPut, "funasrTokenizer", result.paths.funasrTokenizer);
+      PutString(env, pathsMap, mapPut, "qwen3ConvFrontend", result.paths.qwen3ConvFrontend);
+      PutString(env, pathsMap, mapPut, "qwen3Encoder", result.paths.qwen3Encoder);
+      PutString(env, pathsMap, mapPut, "qwen3Decoder", result.paths.qwen3Decoder);
+      PutString(env, pathsMap, mapPut, "qwen3Tokenizer", result.paths.qwen3Tokenizer);
       PutString(env, pathsMap, mapPut, "moonshinePreprocessor", result.paths.moonshinePreprocessor);
       PutString(env, pathsMap, mapPut, "moonshineEncoder", result.paths.moonshineEncoder);
       PutString(env, pathsMap, mapPut, "moonshineUncachedDecoder", result.paths.moonshineUncachedDecoder);

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-validate-enhancement.cpp

@@ -0,0 +1,68 @@
+#include "sherpa-onnx-validate-enhancement.h"
+
+#include <cstddef>
+
+namespace sherpaonnx {
+namespace {
+
+static const EnhancementFieldRequirement kGenericReqs[] = {
+    {"model", &EnhancementModelPaths::model, true},
+};
+
+static const EnhancementFieldRequirement* GetRequirements(
+    EnhancementModelKind kind,
+    size_t& count
+) {
+    switch (kind) {
+        case EnhancementModelKind::kGtcrn:
+        case EnhancementModelKind::kDpdfNet:
+            count = std::size(kGenericReqs);
+            return kGenericReqs;
+        default:
+            count = 0;
+            return nullptr;
+    }
+}
+
+static const char* EnhancementKindToName(EnhancementModelKind kind) {
+    switch (kind) {
+        case EnhancementModelKind::kGtcrn:
+            return "GTCRN";
+        case EnhancementModelKind::kDpdfNet:
+            return "DPDFNet";
+        default:
+            return "Unknown";
+    }
+}
+
+} // namespace
+
+EnhancementValidationResult ValidateEnhancementPaths(
+    EnhancementModelKind kind,
+    const EnhancementModelPaths& paths,
+    const std::string& modelDir
+) {
+    EnhancementValidationResult result;
+    size_t count = 0;
+    const auto* reqs = GetRequirements(kind, count);
+    if (!reqs) return result;
+
+    for (size_t i = 0; i < count; ++i) {
+        if (reqs[i].required && (paths.*(reqs[i].field)).empty()) {
+            result.missingRequired.push_back(reqs[i].fieldName);
+        }
+    }
+
+    if (!result.missingRequired.empty()) {
+        result.ok = false;
+        result.error = std::string("Enhancement ") + EnhancementKindToName(kind) +
+                       ": missing required files in " + modelDir + ": ";
+        for (size_t i = 0; i < result.missingRequired.size(); ++i) {
+            if (i > 0) result.error += ", ";
+            result.error += result.missingRequired[i];
+        }
+    }
+    return result;
+}
+
+} // namespace sherpaonnx

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-validate-enhancement.h

@@ -0,0 +1,30 @@
+#ifndef SHERPA_ONNX_VALIDATE_ENHANCEMENT_H
+#define SHERPA_ONNX_VALIDATE_ENHANCEMENT_H
+
+#include "sherpa-onnx-model-detect.h"
+#include <string>
+#include <vector>
+
+namespace sherpaonnx {
+
+struct EnhancementFieldRequirement {
+    const char* fieldName;
+    std::string EnhancementModelPaths::* field;
+    bool required;
+};
+
+struct EnhancementValidationResult {
+    bool ok = true;
+    std::vector<std::string> missingRequired;
+    std::string error;
+};
+
+EnhancementValidationResult ValidateEnhancementPaths(
+    EnhancementModelKind kind,
+    const EnhancementModelPaths& paths,
+    const std::string& modelDir
+);
+
+} // namespace sherpaonnx
+
+#endif // SHERPA_ONNX_VALIDATE_ENHANCEMENT_H

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-validate-stt.cpp

@@ -52,6 +52,13 @@ static const SttFieldRequirement kFunAsrNanoReqs[] = {
     {"funasrTokenizer",      &SttModelPaths::funasrTokenizer,      true},
 };
 
+static const SttFieldRequirement kQwen3AsrReqs[] = {
+    {"qwen3ConvFrontend", &SttModelPaths::qwen3ConvFrontend, true},
+    {"qwen3Encoder",      &SttModelPaths::qwen3Encoder,      true},
+    {"qwen3Decoder",      &SttModelPaths::qwen3Decoder,      true},
+    {"qwen3Tokenizer",    &SttModelPaths::qwen3Tokenizer,    true},
+};
+
 static const SttFieldRequirement kMoonshineReqs[] = {
     {"moonshinePreprocessor",    &SttModelPaths::moonshinePreprocessor,    true},
     {"moonshineEncoder",         &SttModelPaths::moonshineEncoder,         true},
@@ -120,6 +127,9 @@ static const SttFieldRequirement* GetRequirements(SttModelKind kind, size_t& cou
         case SttModelKind::kFunAsrNano:
             count = std::size(kFunAsrNanoReqs);
             return kFunAsrNanoReqs;
+        case SttModelKind::kQwen3Asr:
+            count = std::size(kQwen3AsrReqs);
+            return kQwen3AsrReqs;
         case SttModelKind::kMoonshine:
             count = std::size(kMoonshineReqs);
             return kMoonshineReqs;
@@ -161,6 +171,7 @@ static const char* SttKindToName(SttModelKind k) {
         case SttModelKind::kZipformerCtc:  return "Zipformer CTC";
         case SttModelKind::kWhisper:       return "Whisper";
         case SttModelKind::kFunAsrNano:    return "FunASR Nano";
+        case SttModelKind::kQwen3Asr:      return "Qwen3 ASR";
         case SttModelKind::kFireRedAsr:    return "Fire Red ASR";
         case SttModelKind::kMoonshine:     return "Moonshine";
         case SttModelKind::kMoonshineV2:   return "Moonshine v2";

package/android/src/main/cpp/jni/module/sherpa-onnx-module-jni.cpp

@@ -20,6 +20,7 @@
 #include "sherpa-onnx-model-detect.h"
 #include "sherpa-onnx-stt-wrapper.h"
 #include "sherpa-onnx-tts-wrapper.h"
+#include "sherpa-onnx-enhancement-wrapper.h"
 
 extern "C" {
 
@@ -187,4 +188,24 @@ Java_com_sherpaonnx_SherpaOnnxModule_nativeDetectTtsModel(
   return sherpaonnx::TtsDetectResultToJava(env, result);
 }
 
+// Detect enhancement model in directory. Returns HashMap with success, error, detectedModels, modelType, paths.
+JNIEXPORT jobject JNICALL
+Java_com_sherpaonnx_SherpaOnnxModule_nativeDetectEnhancementModel(
+    JNIEnv* env,
+    jobject /* this */,
+    jstring j_model_dir,
+    jstring j_model_type) {
+  const char* model_dir_c = env->GetStringUTFChars(j_model_dir, nullptr);
+  const char* model_type_c =
+      j_model_type ? env->GetStringUTFChars(j_model_type, nullptr) : nullptr;
+  std::string model_dir(model_dir_c ? model_dir_c : "");
+  std::string model_type(model_type_c ? model_type_c : "auto");
+  env->ReleaseStringUTFChars(j_model_dir, model_dir_c);
+  if (model_type_c) env->ReleaseStringUTFChars(j_model_type, model_type_c);
+
+  sherpaonnx::EnhancementDetectResult result =
+      sherpaonnx::DetectEnhancementModel(model_dir, model_type);
+  return sherpaonnx::EnhancementDetectResultToJava(env, result);
+}
+
 }  // extern "C"