react-native-sherpa-onnx 0.2.0 → 0.3.0

package/{ios → android/src/main/cpp/jni/model_detect}/sherpa-onnx-model-detect.h

@@ -1,89 +1,122 @@
-#ifndef SHERPA_ONNX_MODEL_DETECT_H
-#define SHERPA_ONNX_MODEL_DETECT_H
-
-#include "sherpa-onnx-common.h"
-#include <optional>
-#include <string>
-#include <vector>
-
-namespace sherpaonnx {
-
-enum class SttModelKind {
-    kUnknown,
-    kTransducer,
-    kParaformer,
-    kNemoCtc,
-    kWenetCtc,
-    kSenseVoice,
-    kZipformerCtc,
-    kWhisper,
-    kFunAsrNano
-};
-
-enum class TtsModelKind {
-    kUnknown,
-    kVits,
-    kMatcha,
-    kKokoro,
-    kKitten,
-    kZipvoice
-};
-
-struct SttModelPaths {
-    std::string encoder;
-    std::string decoder;
-    std::string joiner;
-    std::string paraformerModel;
-    std::string ctcModel;
-    std::string whisperEncoder;
-    std::string whisperDecoder;
-    std::string tokens;
-    std::string funasrEncoderAdaptor;
-    std::string funasrLLM;
-    std::string funasrEmbedding;
-    std::string funasrTokenizer;
-};
-
-struct TtsModelPaths {
-    std::string ttsModel;
-    std::string tokens;
-    std::string lexicon;
-    std::string dataDir;
-    std::string voices;
-    std::string acousticModel;
-    std::string vocoder;
-    std::string encoder;
-    std::string decoder;
-};
-
-struct SttDetectResult {
-    bool ok = false;
-    std::string error;
-    std::vector<DetectedModel> detectedModels;
-    SttModelKind selectedKind = SttModelKind::kUnknown;
-    bool tokensRequired = true;
-    SttModelPaths paths;
-};
-
-struct TtsDetectResult {
-    bool ok = false;
-    std::string error;
-    std::vector<DetectedModel> detectedModels;
-    TtsModelKind selectedKind = TtsModelKind::kUnknown;
-    TtsModelPaths paths;
-};
-
-SttDetectResult DetectSttModel(
-    const std::string& modelDir,
-    const std::optional<bool>& preferInt8,
-    const std::optional<std::string>& modelType
-);
-
-TtsDetectResult DetectTtsModel(
-    const std::string& modelDir,
-    const std::string& modelType
-);
-
-} // namespace sherpaonnx
-
-#endif // SHERPA_ONNX_MODEL_DETECT_H
+#ifndef SHERPA_ONNX_MODEL_DETECT_H
+#define SHERPA_ONNX_MODEL_DETECT_H
+
+#include "sherpa-onnx-common.h"
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace sherpaonnx {
+
+enum class SttModelKind {
+    kUnknown,
+    kTransducer,
+    kNemoTransducer,
+    kParaformer,
+    kNemoCtc,
+    kWenetCtc,
+    kSenseVoice,
+    kZipformerCtc,
+    kWhisper,
+    kFunAsrNano,
+    kFireRedAsr,
+    kMoonshine,
+    kDolphin,
+    kCanary,
+    kOmnilingual,
+    kMedAsr,
+    kTeleSpeechCtc
+};
+
+enum class TtsModelKind {
+    kUnknown,
+    kVits,
+    kMatcha,
+    kKokoro,
+    kKitten,
+    kPocket,
+    kZipvoice
+};
+
+struct SttModelPaths {
+    std::string encoder;
+    std::string decoder;
+    std::string joiner;
+    std::string paraformerModel;
+    std::string ctcModel;
+    std::string whisperEncoder;
+    std::string whisperDecoder;
+    std::string tokens;
+    /** BPE vocabulary for hotwords tokenization (sentencepiece export bpe.vocab). Optional. */
+    std::string bpeVocab;
+    std::string funasrEncoderAdaptor;
+    std::string funasrLLM;
+    std::string funasrEmbedding;
+    std::string funasrTokenizer;
+    // Moonshine
+    std::string moonshinePreprocessor;
+    std::string moonshineEncoder;
+    std::string moonshineUncachedDecoder;
+    std::string moonshineCachedDecoder;
+    // Dolphin, Omnilingual, MedAsr, TeleSpeech (single model each)
+    std::string dolphinModel;
+    std::string omnilingualModel;
+    std::string medasrModel;
+    std::string telespeechCtcModel;
+    // FireRed ASR, Canary (encoder/decoder)
+    std::string fireRedEncoder;
+    std::string fireRedDecoder;
+    std::string canaryEncoder;
+    std::string canaryDecoder;
+};
+
+struct TtsModelPaths {
+    std::string ttsModel;
+    std::string tokens;
+    std::string lexicon;
+    std::string dataDir;
+    std::string voices;
+    std::string acousticModel;
+    std::string vocoder;
+    std::string encoder;
+    std::string decoder;
+    // Pocket TTS
+    std::string lmFlow;
+    std::string lmMain;
+    std::string textConditioner;
+    std::string vocabJson;
+    std::string tokenScoresJson;
+};
+
+struct SttDetectResult {
+    bool ok = false;
+    std::string error;
+    std::vector<DetectedModel> detectedModels;
+    SttModelKind selectedKind = SttModelKind::kUnknown;
+    bool tokensRequired = true;
+    SttModelPaths paths;
+};
+
+struct TtsDetectResult {
+    bool ok = false;
+    std::string error;
+    std::vector<DetectedModel> detectedModels;
+    TtsModelKind selectedKind = TtsModelKind::kUnknown;
+    TtsModelPaths paths;
+};
+
+SttDetectResult DetectSttModel(
+    const std::string& modelDir,
+    const std::optional<bool>& preferInt8,
+    const std::optional<std::string>& modelType,
+    bool debug = false
+);
+
+TtsDetectResult DetectTtsModel(
+    const std::string& modelDir,
+    const std::string& modelType
+);
+
+} // namespace sherpaonnx
+
+#endif // SHERPA_ONNX_MODEL_DETECT_H

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

@@ -0,0 +1,99 @@
+/**
+ * sherpa-onnx-stt-wrapper.cpp
+ *
+ * Purpose: Converts C++ SttDetectResult to a Java HashMap for nativeDetectSttModel. Contains
+ * STT model kind string mapping and path marshalling. Used by sherpa-onnx-module-jni.cpp.
+ */
+#include "sherpa-onnx-stt-wrapper.h"
+#include "sherpa-onnx-detect-jni-common.h"
+#include "sherpa-onnx-model-detect.h"
+
+namespace sherpaonnx {
+
+namespace {
+
+const char* SttModelKindToString(SttModelKind k) {
+  switch (k) {
+    case SttModelKind::kTransducer: return "transducer";
+    case SttModelKind::kNemoTransducer: return "nemo_transducer";
+    case SttModelKind::kParaformer: return "paraformer";
+    case SttModelKind::kNemoCtc: return "nemo_ctc";
+    case SttModelKind::kWenetCtc: return "wenet_ctc";
+    case SttModelKind::kSenseVoice: return "sense_voice";
+    case SttModelKind::kZipformerCtc: return "zipformer_ctc";
+    case SttModelKind::kWhisper: return "whisper";
+    case SttModelKind::kFunAsrNano: return "funasr_nano";
+    case SttModelKind::kFireRedAsr: return "fire_red_asr";
+    case SttModelKind::kMoonshine: return "moonshine";
+    case SttModelKind::kDolphin: return "dolphin";
+    case SttModelKind::kCanary: return "canary";
+    case SttModelKind::kOmnilingual: return "omnilingual";
+    case SttModelKind::kMedAsr: return "medasr";
+    case SttModelKind::kTeleSpeechCtc: return "telespeech_ctc";
+    default: return "unknown";
+  }
+}
+
+}  // namespace
+
+jobject SttDetectResultToJava(JNIEnv* env, const SttDetectResult& result) {
+  jclass mapClass = env->FindClass("java/util/HashMap");
+  if (!mapClass) return nullptr;
+  jmethodID mapInit = env->GetMethodID(mapClass, "<init>", "()V");
+  jmethodID mapPut = env->GetMethodID(mapClass, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+  if (!mapInit || !mapPut) {
+    env->DeleteLocalRef(mapClass);
+    return nullptr;
+  }
+  jobject map = env->NewObject(mapClass, mapInit);
+  env->DeleteLocalRef(mapClass);
+  if (!map) return nullptr;
+
+  PutBoolean(env, map, mapPut, "success", result.ok);
+  PutString(env, map, mapPut, "error", result.error);
+  PutString(env, map, mapPut, "modelType", SttModelKindToString(result.selectedKind));
+
+  jobject detectedList = BuildDetectedModelsList(env, result.detectedModels);
+  if (detectedList) {
+    env->CallObjectMethod(map, mapPut, env->NewStringUTF("detectedModels"), detectedList);
+    env->DeleteLocalRef(detectedList);
+  }
+
+  jclass hashMapClass = env->FindClass("java/util/HashMap");
+  if (hashMapClass) {
+    jobject pathsMap = env->NewObject(hashMapClass, mapInit);
+    env->DeleteLocalRef(hashMapClass);
+    if (pathsMap) {
+      PutString(env, pathsMap, mapPut, "encoder", result.paths.encoder);
+      PutString(env, pathsMap, mapPut, "decoder", result.paths.decoder);
+      PutString(env, pathsMap, mapPut, "joiner", result.paths.joiner);
+      PutString(env, pathsMap, mapPut, "tokens", result.paths.tokens);
+      PutString(env, pathsMap, mapPut, "paraformerModel", result.paths.paraformerModel);
+      PutString(env, pathsMap, mapPut, "ctcModel", result.paths.ctcModel);
+      PutString(env, pathsMap, mapPut, "whisperEncoder", result.paths.whisperEncoder);
+      PutString(env, pathsMap, mapPut, "whisperDecoder", result.paths.whisperDecoder);
+      PutString(env, pathsMap, mapPut, "funasrEncoderAdaptor", result.paths.funasrEncoderAdaptor);
+      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, "moonshinePreprocessor", result.paths.moonshinePreprocessor);
+      PutString(env, pathsMap, mapPut, "moonshineEncoder", result.paths.moonshineEncoder);
+      PutString(env, pathsMap, mapPut, "moonshineUncachedDecoder", result.paths.moonshineUncachedDecoder);
+      PutString(env, pathsMap, mapPut, "moonshineCachedDecoder", result.paths.moonshineCachedDecoder);
+      PutString(env, pathsMap, mapPut, "dolphinModel", result.paths.dolphinModel);
+      PutString(env, pathsMap, mapPut, "omnilingualModel", result.paths.omnilingualModel);
+      PutString(env, pathsMap, mapPut, "medasrModel", result.paths.medasrModel);
+      PutString(env, pathsMap, mapPut, "telespeechCtcModel", result.paths.telespeechCtcModel);
+      PutString(env, pathsMap, mapPut, "fireRedEncoder", result.paths.fireRedEncoder);
+      PutString(env, pathsMap, mapPut, "fireRedDecoder", result.paths.fireRedDecoder);
+      PutString(env, pathsMap, mapPut, "canaryEncoder", result.paths.canaryEncoder);
+      PutString(env, pathsMap, mapPut, "canaryDecoder", result.paths.canaryDecoder);
+      PutString(env, pathsMap, mapPut, "bpeVocab", result.paths.bpeVocab);
+      env->CallObjectMethod(map, mapPut, env->NewStringUTF("paths"), pathsMap);
+      env->DeleteLocalRef(pathsMap);
+    }
+  }
+  return map;
+}
+
+}  // namespace sherpaonnx

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

@@ -0,0 +1,16 @@
+#ifndef SHERPA_ONNX_STT_WRAPPER_H
+#define SHERPA_ONNX_STT_WRAPPER_H
+
+#include <jni.h>
+
+namespace sherpaonnx {
+
+struct SttDetectResult;
+
+// Converts C++ SttDetectResult to a Java HashMap (success, error, modelType, detectedModels, paths).
+// Caller must DeleteLocalRef the returned jobject.
+jobject SttDetectResultToJava(JNIEnv* env, const SttDetectResult& result);
+
+}  // namespace sherpaonnx
+
+#endif  // SHERPA_ONNX_STT_WRAPPER_H

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

@@ -0,0 +1,78 @@
+/**
+ * sherpa-onnx-tts-wrapper.cpp
+ *
+ * Purpose: Converts C++ TtsDetectResult to a Java HashMap for nativeDetectTtsModel. Contains
+ * TTS model kind string mapping and path marshalling. Used by sherpa-onnx-module-jni.cpp.
+ */
+#include "sherpa-onnx-tts-wrapper.h"
+#include "sherpa-onnx-detect-jni-common.h"
+#include "sherpa-onnx-model-detect.h"
+
+namespace sherpaonnx {
+
+namespace {
+
+const char* TtsModelKindToString(TtsModelKind k) {
+  switch (k) {
+    case TtsModelKind::kVits: return "vits";
+    case TtsModelKind::kMatcha: return "matcha";
+    case TtsModelKind::kKokoro: return "kokoro";
+    case TtsModelKind::kKitten: return "kitten";
+    case TtsModelKind::kPocket: return "pocket";
+    case TtsModelKind::kZipvoice: return "zipvoice";
+    default: return "unknown";
+  }
+}
+
+}  // namespace
+
+jobject TtsDetectResultToJava(JNIEnv* env, const TtsDetectResult& result) {
+  jclass mapClass = env->FindClass("java/util/HashMap");
+  if (!mapClass) return nullptr;
+  jmethodID mapInit = env->GetMethodID(mapClass, "<init>", "()V");
+  jmethodID mapPut = env->GetMethodID(mapClass, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+  if (!mapInit || !mapPut) {
+    env->DeleteLocalRef(mapClass);
+    return nullptr;
+  }
+  jobject map = env->NewObject(mapClass, mapInit);
+  env->DeleteLocalRef(mapClass);
+  if (!map) return nullptr;
+
+  PutBoolean(env, map, mapPut, "success", result.ok);
+  PutString(env, map, mapPut, "error", result.error);
+  PutString(env, map, mapPut, "modelType", TtsModelKindToString(result.selectedKind));
+
+  jobject detectedList = BuildDetectedModelsList(env, result.detectedModels);
+  if (detectedList) {
+    env->CallObjectMethod(map, mapPut, env->NewStringUTF("detectedModels"), detectedList);
+    env->DeleteLocalRef(detectedList);
+  }
+
+  jclass hashMapClass = env->FindClass("java/util/HashMap");
+  if (hashMapClass) {
+    jobject pathsMap = env->NewObject(hashMapClass, mapInit);
+    env->DeleteLocalRef(hashMapClass);
+    if (pathsMap) {
+      PutString(env, pathsMap, mapPut, "ttsModel", result.paths.ttsModel);
+      PutString(env, pathsMap, mapPut, "tokens", result.paths.tokens);
+      PutString(env, pathsMap, mapPut, "lexicon", result.paths.lexicon);
+      PutString(env, pathsMap, mapPut, "dataDir", result.paths.dataDir);
+      PutString(env, pathsMap, mapPut, "voices", result.paths.voices);
+      PutString(env, pathsMap, mapPut, "acousticModel", result.paths.acousticModel);
+      PutString(env, pathsMap, mapPut, "vocoder", result.paths.vocoder);
+      PutString(env, pathsMap, mapPut, "encoder", result.paths.encoder);
+      PutString(env, pathsMap, mapPut, "decoder", result.paths.decoder);
+      PutString(env, pathsMap, mapPut, "lmFlow", result.paths.lmFlow);
+      PutString(env, pathsMap, mapPut, "lmMain", result.paths.lmMain);
+      PutString(env, pathsMap, mapPut, "textConditioner", result.paths.textConditioner);
+      PutString(env, pathsMap, mapPut, "vocabJson", result.paths.vocabJson);
+      PutString(env, pathsMap, mapPut, "tokenScoresJson", result.paths.tokenScoresJson);
+      env->CallObjectMethod(map, mapPut, env->NewStringUTF("paths"), pathsMap);
+      env->DeleteLocalRef(pathsMap);
+    }
+  }
+  return map;
+}
+
+}  // namespace sherpaonnx

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

@@ -0,0 +1,16 @@
+#ifndef SHERPA_ONNX_TTS_WRAPPER_H
+#define SHERPA_ONNX_TTS_WRAPPER_H
+
+#include <jni.h>
+
+namespace sherpaonnx {
+
+struct TtsDetectResult;
+
+// Converts C++ TtsDetectResult to a Java HashMap (success, error, modelType, detectedModels, paths).
+// Caller must DeleteLocalRef the returned jobject.
+jobject TtsDetectResultToJava(JNIEnv* env, const TtsDetectResult& result);
+
+}  // namespace sherpaonnx
+
+#endif  // SHERPA_ONNX_TTS_WRAPPER_H

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

@@ -0,0 +1,190 @@
+/**
+ * sherpa-onnx-module-jni.cpp
+ *
+ * Purpose: JNI entry points for SherpaOnnxModule: nativeTestSherpaInit, nativeCanInitQnnHtp,
+ * nativeHasNnapiAccelerator, nativeDetectSttModel, nativeDetectTtsModel. Used by Kotlin to probe
+ * capabilities and get model paths for the Kotlin STT/TTS API.
+ */
+#include <jni.h>
+#include <string>
+#include <optional>
+
+#if defined(__ANDROID__)
+#include <dlfcn.h>
+#include <android/log.h>
+#include <cstdint>
+#endif
+
+#define NNAPI_LOG_TAG "SherpaOnnx"
+
+#include "sherpa-onnx-model-detect.h"
+#include "sherpa-onnx-stt-wrapper.h"
+#include "sherpa-onnx-tts-wrapper.h"
+
+extern "C" {
+
+JNIEXPORT jstring JNICALL
+Java_com_sherpaonnx_SherpaOnnxModule_nativeTestSherpaInit(JNIEnv* env, jobject /* this */) {
+  return env->NewStringUTF("sherpa-onnx native (libsherpaonnx) loaded");
+}
+
+// Check if QNN HTP backend can actually be initialized (QnnBackend_create + free).
+// Uses dlopen/dlsym so we do not need to link against QNN SDK at build time.
+JNIEXPORT jboolean JNICALL
+Java_com_sherpaonnx_SherpaOnnxModule_nativeCanInitQnnHtp(JNIEnv* /* env */, jobject /* this */) {
+#if !defined(__ANDROID__)
+  return JNI_FALSE;
+#else
+  static const char* QNN_LOG_TAG = "SherpaOnnx";
+  void* handle = dlopen("libQnnHtp.so", RTLD_NOW | RTLD_LOCAL);
+  if (!handle) {
+    __android_log_print(ANDROID_LOG_INFO, QNN_LOG_TAG, "QNN: dlopen(libQnnHtp.so) failed: %s", dlerror());
+    return JNI_FALSE;
+  }
+  using CreateFn = int (*)(const char*, const void*, void**);
+  using FreeFn = int (*)(void*);
+  auto create = reinterpret_cast<CreateFn>(dlsym(handle, "QnnBackend_create"));
+  auto free_fn = reinterpret_cast<FreeFn>(dlsym(handle, "QnnBackend_free"));
+  if (!create || !free_fn) {
+    __android_log_print(ANDROID_LOG_INFO, QNN_LOG_TAG, "QNN: dlsym failed: %s", dlerror());
+    dlclose(handle);
+    return JNI_FALSE;
+  }
+  void* backend = nullptr;
+  const int err = create("QnnHtp", nullptr, &backend);
+  __android_log_print(ANDROID_LOG_INFO, QNN_LOG_TAG, "QNN: QnnBackend_create err=%d backend=%p", err, (void*)backend);
+  if (err == 0 && backend) {
+    free_fn(backend);
+  }
+  dlclose(handle);
+  jboolean ok = (err == 0 && backend) ? JNI_TRUE : JNI_FALSE;
+  __android_log_print(ANDROID_LOG_INFO, QNN_LOG_TAG, "QNN: canInit=%s", ok ? "true" : "false");
+  return ok;
+#endif
+}
+
+// NNAPI device enumeration via dlopen so it works regardless of compile-time minSdk (API 29+ at runtime).
+#if defined(__ANDROID__)
+namespace {
+constexpr int ANEURALNETWORKS_NO_ERROR = 0;
+// Must match enum values in Android NDK NeuralNetworks.h: 
+// https://android.googlesource.com/platform/frameworks/ml/+/refs/heads/master/nn/runtime/include/NeuralNetworks.h
+// UNKNOWN= 0, OTHER = 1, CPU = 2, GPU = 3, ACCELERATOR = 4.
+constexpr int32_t ANEURALNETWORKS_DEVICE_GPU = 3;
+constexpr int32_t ANEURALNETWORKS_DEVICE_ACCELERATOR = 4;
+struct ANeuralNetworksDeviceOpaque {};
+using ANeuralNetworksDevice = ANeuralNetworksDeviceOpaque*;
+}  // namespace
+#endif
+
+// Check if the device has an NNAPI accelerator (GPU/DSP/NPU). Requires Android API 29+ at runtime.
+// Loads NNAPI from libandroid.so via dlopen so it works even when the app is built with minSdk < 29.
+JNIEXPORT jboolean JNICALL
+Java_com_sherpaonnx_SherpaOnnxModule_nativeHasNnapiAccelerator(JNIEnv* /* env */, jobject /* this */, jint sdkInt) {
+#if !defined(__ANDROID__)
+  return JNI_FALSE;
+#else
+  __android_log_print(ANDROID_LOG_INFO, NNAPI_LOG_TAG,
+                     "NNAPI hasAccelerator: called (runtime SDK=%d)", sdkInt);
+  if (sdkInt < 29) {
+    __android_log_print(ANDROID_LOG_INFO, NNAPI_LOG_TAG, "NNAPI: SDK %d < 29, returning false", sdkInt);
+    return JNI_FALSE;
+  }
+  // NNAPI symbols can be in libneuralnetworks.so (runtime) or libandroid.so; try both.
+  const char* libs[] = {"libneuralnetworks.so", "libandroid.so"};
+  void* lib = nullptr;
+  for (const char* libName : libs) {
+    lib = dlopen(libName, RTLD_NOW);
+    if (lib) break;
+    __android_log_print(ANDROID_LOG_INFO, NNAPI_LOG_TAG, "NNAPI: dlopen(%s) failed: %s", libName, dlerror());
+  }
+  if (!lib) {
+    return JNI_FALSE;
+  }
+  using GetDeviceCountFn = int (*)(uint32_t*);
+  using GetDeviceFn = int (*)(uint32_t, ANeuralNetworksDevice*);  // out param: ANeuralNetworksDevice*
+  using GetTypeFn = int (*)(ANeuralNetworksDevice, int32_t*);
+  auto getDeviceCount = reinterpret_cast<GetDeviceCountFn>(dlsym(lib, "ANeuralNetworks_getDeviceCount"));
+  auto getDevice = reinterpret_cast<GetDeviceFn>(dlsym(lib, "ANeuralNetworks_getDevice"));
+  auto getType = reinterpret_cast<GetTypeFn>(dlsym(lib, "ANeuralNetworksDevice_getType"));
+  if (!getDeviceCount || !getDevice || !getType) {
+    __android_log_print(ANDROID_LOG_INFO, NNAPI_LOG_TAG, "NNAPI: dlsym failed (getCount=%p getDevice=%p getType=%p): %s",
+                       (void*)getDeviceCount, (void*)getDevice, (void*)getType, dlerror());
+    dlclose(lib);
+    return JNI_FALSE;
+  }
+  uint32_t numDevices = 0;
+  int err = getDeviceCount(&numDevices);
+  __android_log_print(ANDROID_LOG_INFO, NNAPI_LOG_TAG, "NNAPI getDeviceCount: err=%d numDevices=%u", err, numDevices);
+  if (err != ANEURALNETWORKS_NO_ERROR || numDevices == 0) {
+    dlclose(lib);
+    return JNI_FALSE;
+  }
+  jboolean hasAccelerator = JNI_FALSE;
+  for (uint32_t i = 0; i < numDevices; ++i) {
+    ANeuralNetworksDevice device = nullptr;
+    err = getDevice(i, &device);
+    if (err != ANEURALNETWORKS_NO_ERROR || !device) {
+      __android_log_print(ANDROID_LOG_INFO, NNAPI_LOG_TAG,
+                         "NNAPI device[%u] getDevice: err=%d device=%p", i, err, (void*)device);
+      continue;
+    }
+    int32_t type = 0;
+    int typeErr = getType(device, &type);
+    __android_log_print(ANDROID_LOG_INFO, NNAPI_LOG_TAG,
+                       "NNAPI device[%u] getType: err=%d type=%d (1=OTHER 2=CPU 3=GPU 4=ACCELERATOR)", i, typeErr, type);
+    if (typeErr == ANEURALNETWORKS_NO_ERROR &&
+        (type == ANEURALNETWORKS_DEVICE_ACCELERATOR || type == ANEURALNETWORKS_DEVICE_GPU)) {
+      hasAccelerator = JNI_TRUE;
+    }
+  }
+  __android_log_print(ANDROID_LOG_INFO, NNAPI_LOG_TAG, "NNAPI hasAccelerator result=%s", hasAccelerator ? "true" : "false");
+  dlclose(lib);
+  return hasAccelerator;
+#endif
+}
+
+// Detect STT model in directory. Returns HashMap with success, error, detectedModels, modelType, paths.
+JNIEXPORT jobject JNICALL
+Java_com_sherpaonnx_SherpaOnnxModule_nativeDetectSttModel(
+    JNIEnv* env,
+    jobject /* this */,
+    jstring j_model_dir,
+    jboolean j_prefer_int8,
+    jboolean j_has_prefer_int8,
+    jstring j_model_type,
+    jboolean j_debug) {
+  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::optional<bool> prefer_int8;
+  if (j_has_prefer_int8) prefer_int8 = (j_prefer_int8 == JNI_TRUE);
+  std::optional<std::string> model_type_opt;
+  if (model_type_c && model_type_c[0] != '\0') model_type_opt = std::string(model_type_c);
+  env->ReleaseStringUTFChars(j_model_dir, model_dir_c);
+  if (model_type_c) env->ReleaseStringUTFChars(j_model_type, model_type_c);
+
+  sherpaonnx::SttDetectResult result = sherpaonnx::DetectSttModel(
+      model_dir, prefer_int8, model_type_opt, (j_debug == JNI_TRUE));
+  return sherpaonnx::SttDetectResultToJava(env, result);
+}
+
+// Detect TTS model in directory. Returns HashMap with success, error, detectedModels, modelType, paths.
+JNIEXPORT jobject JNICALL
+Java_com_sherpaonnx_SherpaOnnxModule_nativeDetectTtsModel(
+    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::TtsDetectResult result = sherpaonnx::DetectTtsModel(model_dir, model_type);
+  return sherpaonnx::TtsDetectResultToJava(env, result);
+}
+
+}  // extern "C"