react-native-sherpa-onnx 0.2.0 → 0.3.0

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

@@ -1,336 +0,0 @@
-// Include standard library headers first to avoid conflicts with jni.h
-#include <memory>
-#include <optional>
-#include <string>
-
-// Then include JNI headers
-#include <android/log.h>
-#include <jni.h>
-
-// STT wrapper
-#include "sherpa-onnx-stt-wrapper.h"
-
-#define LOG_TAG "SherpaOnnxJNI"
-#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
-#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
-
-using namespace sherpaonnx;
-
-// Global wrapper instance
-static std::unique_ptr<SttWrapper> g_stt_wrapper = nullptr;
-
-extern "C" {
-
-JNIEXPORT jobject JNICALL
-Java_com_sherpaonnx_SherpaOnnxModule_nativeSttInitialize(
-    JNIEnv *env,
-    jobject /* this */,
-    jstring modelDir,
-    jboolean preferInt8,
-    jboolean hasPreferInt8,
-    jstring modelType) {
-    try {
-        if (g_stt_wrapper == nullptr) {
-            g_stt_wrapper = std::make_unique<SttWrapper>();
-        }
-
-        const char *modelDirStr = env->GetStringUTFChars(modelDir, nullptr);
-        if (modelDirStr == nullptr) {
-            LOGE("Failed to get modelDir string from JNI");
-            return nullptr;
-        }
-
-        const char *modelTypeStr = env->GetStringUTFChars(modelType, nullptr);
-        if (modelTypeStr == nullptr) {
-            LOGE("Failed to get modelType string from JNI");
-            env->ReleaseStringUTFChars(modelDir, modelDirStr);
-            return nullptr;
-        }
-
-        std::string modelDirPath(modelDirStr);
-        std::string modelTypePath(modelTypeStr);
-
-        // Convert Java boolean to C++ optional<bool>
-        std::optional<bool> preferInt8Opt;
-        if (hasPreferInt8 == JNI_TRUE) {
-            preferInt8Opt = (preferInt8 == JNI_TRUE);
-        }
-
-        // Convert model type string to optional
-        std::optional<std::string> modelTypeOpt;
-        if (modelTypePath != "auto" && !modelTypePath.empty()) {
-            modelTypeOpt = modelTypePath;
-        }
-
-        SttInitializeResult result = g_stt_wrapper->initialize(modelDirPath, preferInt8Opt, modelTypeOpt);
-        env->ReleaseStringUTFChars(modelDir, modelDirStr);
-        env->ReleaseStringUTFChars(modelType, modelTypeStr);
-
-        LOGI("STT JNI: Initialization result: success=%d, detected models=%zu", result.success, result.detectedModels.size());
-        if (!result.success) {
-            LOGE("STT JNI: Native initialization failed for: %s", modelDirPath.c_str());
-        } else {
-            LOGI("STT JNI: Successfully initialized model at: %s", modelDirPath.c_str());
-        }
-
-        // Create HashMap to return
-        LOGI("STT JNI: Creating HashMap for result");
-        jclass hashMapClass = env->FindClass("java/util/HashMap");
-        if (hashMapClass == nullptr || env->ExceptionCheck()) {
-            LOGE("STT JNI: Failed to find HashMap class");
-            if (env->ExceptionCheck()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-            }
-            return nullptr;
-        }
-
-        jmethodID hashMapConstructor = env->GetMethodID(hashMapClass, "<init>", "()V");
-        if (hashMapConstructor == nullptr || env->ExceptionCheck()) {
-            LOGE("STT JNI: Failed to get HashMap constructor");
-            if (env->ExceptionCheck()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-            }
-            env->DeleteLocalRef(hashMapClass);
-            return nullptr;
-        }
-
-        jmethodID putMethod = env->GetMethodID(hashMapClass, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
-        if (putMethod == nullptr || env->ExceptionCheck()) {
-            LOGE("STT JNI: Failed to get HashMap put method");
-            if (env->ExceptionCheck()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-            }
-            env->DeleteLocalRef(hashMapClass);
-            return nullptr;
-        }
-
-        jobject hashMap = env->NewObject(hashMapClass, hashMapConstructor);
-        if (hashMap == nullptr || env->ExceptionCheck()) {
-            LOGE("STT JNI: Failed to create HashMap object");
-            if (env->ExceptionCheck()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-            }
-            env->DeleteLocalRef(hashMapClass);
-            return nullptr;
-        }
-
-        // Put success boolean
-        LOGI("STT JNI: Adding success field to HashMap");
-        jclass booleanClass = env->FindClass("java/lang/Boolean");
-        if (booleanClass == nullptr || env->ExceptionCheck()) {
-            LOGE("STT JNI: Failed to find Boolean class");
-            if (env->ExceptionCheck()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-            }
-            env->DeleteLocalRef(hashMap);
-            env->DeleteLocalRef(hashMapClass);
-            return nullptr;
-        }
-
-        jmethodID booleanConstructor = env->GetMethodID(booleanClass, "<init>", "(Z)V");
-        if (booleanConstructor == nullptr || env->ExceptionCheck()) {
-            LOGE("STT JNI: Failed to get Boolean constructor");
-            if (env->ExceptionCheck()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-            }
-            env->DeleteLocalRef(booleanClass);
-            env->DeleteLocalRef(hashMap);
-            env->DeleteLocalRef(hashMapClass);
-            return nullptr;
-        }
-
-        jobject successObj = env->NewObject(booleanClass, booleanConstructor, result.success ? JNI_TRUE : JNI_FALSE);
-        jstring successKey = env->NewStringUTF("success");
-        env->CallObjectMethod(hashMap, putMethod, successKey, successObj);
-        if (env->ExceptionCheck()) {
-            LOGE("STT JNI: Exception while putting success field");
-            env->ExceptionDescribe();
-            env->ExceptionClear();
-            env->DeleteLocalRef(successKey);
-            env->DeleteLocalRef(successObj);
-            env->DeleteLocalRef(booleanClass);
-            env->DeleteLocalRef(hashMap);
-            env->DeleteLocalRef(hashMapClass);
-            return nullptr;
-        }
-        env->DeleteLocalRef(successKey);
-        env->DeleteLocalRef(successObj);
-        env->DeleteLocalRef(booleanClass);
-
-        // Put detectedModels array
-        LOGI("STT JNI: Adding detectedModels array (%zu models)", result.detectedModels.size());
-        jclass arrayListClass = env->FindClass("java/util/ArrayList");
-        if (arrayListClass == nullptr || env->ExceptionCheck()) {
-            LOGE("STT JNI: Failed to find ArrayList class");
-            if (env->ExceptionCheck()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-            }
-            env->DeleteLocalRef(hashMap);
-            env->DeleteLocalRef(hashMapClass);
-            return nullptr;
-        }
-
-        jmethodID arrayListConstructor = env->GetMethodID(arrayListClass, "<init>", "()V");
-        if (arrayListConstructor == nullptr || env->ExceptionCheck()) {
-            LOGE("STT JNI: Failed to get ArrayList constructor");
-            if (env->ExceptionCheck()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-            }
-            env->DeleteLocalRef(arrayListClass);
-            env->DeleteLocalRef(hashMap);
-            env->DeleteLocalRef(hashMapClass);
-            return nullptr;
-        }
-
-        jmethodID addMethod = env->GetMethodID(arrayListClass, "add", "(Ljava/lang/Object;)Z");
-        if (addMethod == nullptr || env->ExceptionCheck()) {
-            LOGE("STT JNI: Failed to get ArrayList add method");
-            if (env->ExceptionCheck()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-            }
-            env->DeleteLocalRef(arrayListClass);
-            env->DeleteLocalRef(hashMap);
-            env->DeleteLocalRef(hashMapClass);
-            return nullptr;
-        }
-
-        jobject detectedModelsList = env->NewObject(arrayListClass, arrayListConstructor);
-        if (detectedModelsList == nullptr || env->ExceptionCheck()) {
-            LOGE("STT JNI: Failed to create ArrayList object");
-            if (env->ExceptionCheck()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-            }
-            env->DeleteLocalRef(arrayListClass);
-            env->DeleteLocalRef(hashMap);
-            env->DeleteLocalRef(hashMapClass);
-            return nullptr;
-        }
-
-        for (const auto& model : result.detectedModels) {
-            // Create HashMap for each model with type and modelDir
-            jobject modelMap = env->NewObject(hashMapClass, hashMapConstructor);
-            if (modelMap == nullptr || env->ExceptionCheck()) {
-                LOGE("STT JNI: Failed to create model HashMap");
-                if (env->ExceptionCheck()) {
-                    env->ExceptionDescribe();
-                    env->ExceptionClear();
-                }
-                env->DeleteLocalRef(detectedModelsList);
-                env->DeleteLocalRef(arrayListClass);
-                env->DeleteLocalRef(hashMap);
-                env->DeleteLocalRef(hashMapClass);
-                return nullptr;
-            }
-
-            jstring typeKey = env->NewStringUTF("type");
-            jstring typeValue = env->NewStringUTF(model.type.c_str());
-            env->CallObjectMethod(modelMap, putMethod, typeKey, typeValue);
-            env->DeleteLocalRef(typeKey);
-            env->DeleteLocalRef(typeValue);
-
-            jstring dirKey = env->NewStringUTF("modelDir");
-            jstring dirValue = env->NewStringUTF(model.modelDir.c_str());
-            env->CallObjectMethod(modelMap, putMethod, dirKey, dirValue);
-            env->DeleteLocalRef(dirKey);
-            env->DeleteLocalRef(dirValue);
-
-            env->CallBooleanMethod(detectedModelsList, addMethod, modelMap);
-            env->DeleteLocalRef(modelMap);
-        }
-
-        jstring detectedModelsKey = env->NewStringUTF("detectedModels");
-        env->CallObjectMethod(hashMap, putMethod, detectedModelsKey, detectedModelsList);
-        if (env->ExceptionCheck()) {
-            LOGE("STT JNI: Exception while putting detectedModels field");
-            env->ExceptionDescribe();
-            env->ExceptionClear();
-            env->DeleteLocalRef(detectedModelsKey);
-            env->DeleteLocalRef(detectedModelsList);
-            env->DeleteLocalRef(arrayListClass);
-            env->DeleteLocalRef(hashMap);
-            env->DeleteLocalRef(hashMapClass);
-            return nullptr;
-        }
-        env->DeleteLocalRef(detectedModelsKey);
-        env->DeleteLocalRef(detectedModelsList);
-        env->DeleteLocalRef(arrayListClass);
-        env->DeleteLocalRef(hashMapClass);
-
-        LOGI("STT JNI: Successfully created result HashMap, returning to Java");
-        return hashMap;
-    } catch (const std::exception &e) {
-        LOGE("Exception in nativeInitialize: %s", e.what());
-        if (env->ExceptionCheck()) {
-            env->ExceptionDescribe();
-            env->ExceptionClear();
-        }
-        return nullptr;
-    } catch (...) {
-        LOGE("Unknown exception in nativeInitialize");
-        if (env->ExceptionCheck()) {
-            env->ExceptionDescribe();
-            env->ExceptionClear();
-        }
-        return nullptr;
-    }
-}
-
-JNIEXPORT jstring JNICALL
-Java_com_sherpaonnx_SherpaOnnxModule_nativeSttTranscribe(
-    JNIEnv *env,
-    jobject /* this */,
-    jstring filePath) {
-    try {
-        if (g_stt_wrapper == nullptr || !g_stt_wrapper->isInitialized()) {
-            LOGE("STT JNI: Not initialized. Call initialize() first.");
-            return env->NewStringUTF("");
-        }
-
-        const char *filePathStr = env->GetStringUTFChars(filePath, nullptr);
-        if (filePathStr == nullptr) {
-            LOGE("STT JNI: Failed to get filePath string");
-            return env->NewStringUTF("");
-        }
-
-        std::string result = g_stt_wrapper->transcribeFile(std::string(filePathStr));
-        env->ReleaseStringUTFChars(filePath, filePathStr);
-
-        return env->NewStringUTF(result.c_str());
-    } catch (const std::exception &e) {
-        LOGE("Exception in nativeTranscribeFile: %s", e.what());
-        return env->NewStringUTF("");
-    }
-}
-
-JNIEXPORT void JNICALL
-Java_com_sherpaonnx_SherpaOnnxModule_nativeSttRelease(
-    JNIEnv * /* env */,
-    jobject /* this */) {
-    try {
-        if (g_stt_wrapper != nullptr) {
-            g_stt_wrapper->release();
-            g_stt_wrapper.reset();
-        }
-    } catch (const std::exception &e) {
-        LOGE("Exception in nativeRelease: %s", e.what());
-    }
-}
-
-JNIEXPORT jstring JNICALL
-Java_com_sherpaonnx_SherpaOnnxModule_nativeTestSherpaInit(
-    JNIEnv *env,
-    jobject /* this */) {
-    return env->NewStringUTF("Sherpa ONNX loaded!");
-}
-
-} // extern "C"

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

@@ -1,222 +0,0 @@
-#include "sherpa-onnx-stt-wrapper.h"
-#include "sherpa-onnx-model-detect.h"
-#include <android/log.h>
-#include <algorithm>
-#include <cctype>
-#include <fstream>
-#include <optional>
-#include <sstream>
-#include <sys/stat.h>
-
-// Use filesystem if available (C++17), otherwise fallback
-#if __cplusplus >= 201703L && __has_include(<filesystem>)
-#include <filesystem>
-namespace fs = std::filesystem;
-#elif __has_include(<experimental/filesystem>)
-#include <experimental/filesystem>
-namespace fs = std::experimental::filesystem;
-#else
-// Fallback: use stat/opendir for older compilers
-#include <dirent.h>
-#include <sys/stat.h>
-#endif
-
-// sherpa-onnx headers - use cxx-api which is compatible with libsherpa-onnx-cxx-api.so
-#include "sherpa-onnx/c-api/cxx-api.h"
-
-#define LOG_TAG "SttWrapper"
-#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
-#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
-
-namespace sherpaonnx {
-
-// PIMPL pattern implementation
-class SttWrapper::Impl {
-public:
-    bool initialized = false;
-    std::string modelDir;
-    std::optional<sherpa_onnx::cxx::OfflineRecognizer> recognizer;
-};
-
-SttWrapper::SttWrapper() : pImpl(std::make_unique<Impl>()) {
-    LOGI("SttWrapper created");
-}
-
-SttWrapper::~SttWrapper() {
-    release();
-    LOGI("SttWrapper destroyed");
-}
-
-SttInitializeResult SttWrapper::initialize(
-    const std::string& modelDir,
-    const std::optional<bool>& preferInt8,
-    const std::optional<std::string>& modelType
-) {
-    SttInitializeResult result;
-    result.success = false;
-
-    if (pImpl->initialized) {
-        release();
-    }
-
-    if (modelDir.empty()) {
-        LOGE("Model directory is empty");
-        return result;
-    }
-
-    try {
-        sherpa_onnx::cxx::OfflineRecognizerConfig config;
-        config.feat_config.sample_rate = 16000;
-        config.feat_config.feature_dim = 80;
-
-        auto detect = DetectSttModel(modelDir, preferInt8, modelType);
-        if (!detect.ok) {
-            LOGE("%s", detect.error.c_str());
-            return result;
-        }
-
-        switch (detect.selectedKind) {
-            case SttModelKind::kTransducer:
-                config.model_config.transducer.encoder = detect.paths.encoder;
-                config.model_config.transducer.decoder = detect.paths.decoder;
-                config.model_config.transducer.joiner = detect.paths.joiner;
-                break;
-            case SttModelKind::kParaformer:
-                config.model_config.paraformer.model = detect.paths.paraformerModel;
-                break;
-            case SttModelKind::kNemoCtc:
-                config.model_config.nemo_ctc.model = detect.paths.ctcModel;
-                break;
-            case SttModelKind::kWenetCtc:
-                config.model_config.wenet_ctc.model = detect.paths.ctcModel;
-                break;
-            case SttModelKind::kSenseVoice:
-                config.model_config.sense_voice.model = detect.paths.ctcModel;
-                break;
-            case SttModelKind::kZipformerCtc:
-                config.model_config.zipformer_ctc.model = detect.paths.ctcModel;
-                break;
-            case SttModelKind::kWhisper:
-                config.model_config.whisper.encoder = detect.paths.whisperEncoder;
-                config.model_config.whisper.decoder = detect.paths.whisperDecoder;
-                break;
-            case SttModelKind::kFunAsrNano:
-                config.model_config.funasr_nano.encoder_adaptor = detect.paths.funasrEncoderAdaptor;
-                config.model_config.funasr_nano.llm = detect.paths.funasrLLM;
-                config.model_config.funasr_nano.embedding = detect.paths.funasrEmbedding;
-                config.model_config.funasr_nano.tokenizer = detect.paths.funasrTokenizer;
-                break;
-            case SttModelKind::kUnknown:
-            default:
-                LOGE("No compatible model type detected in %s", modelDir.c_str());
-                return result;
-        }
-
-        if (!detect.paths.tokens.empty()) {
-            config.model_config.tokens = detect.paths.tokens;
-        }
-
-        config.decoding_method = "greedy_search";
-        config.model_config.num_threads = 4;
-        config.model_config.provider = "cpu";
-
-        // Create recognizer
-        // Log configuration details
-        bool isWhisperModel = !config.model_config.whisper.encoder.empty() && !config.model_config.whisper.decoder.empty();
-        if (isWhisperModel) {
-            LOGI("Initializing Whisper model with encoder: %s, decoder: %s", config.model_config.whisper.encoder.c_str(), config.model_config.whisper.decoder.c_str());
-        } else {
-            LOGI("Initializing non-Whisper model");
-        }
-        try {
-            pImpl->recognizer = sherpa_onnx::cxx::OfflineRecognizer::Create(config);
-        } catch (const std::exception& e) {
-            LOGE("Failed to create recognizer: %s", e.what());
-            return result;
-        }
-
-        pImpl->modelDir = modelDir;
-        pImpl->initialized = true;
-
-        // Success - return detected models
-        result.success = true;
-        result.detectedModels = detect.detectedModels;
-        return result;
-    } catch (const std::exception& e) {
-        LOGE("Exception during initialization: %s", e.what());
-        return result;
-    } catch (...) {
-        LOGE("Unknown exception during initialization");
-        return result;
-    }
-}
-
-std::string SttWrapper::transcribeFile(const std::string& filePath) {
-    if (!pImpl->initialized || !pImpl->recognizer.has_value()) {
-        LOGE("Not initialized. Call initialize() first.");
-        return "";
-    }
-
-    try {
-        // Helper function to check if file exists
-        auto fileExists = [](const std::string& path) -> bool {
-#if __cplusplus >= 201703L && __has_include(<filesystem>)
-            return std::filesystem::exists(path);
-#elif __has_include(<experimental/filesystem>)
-            return std::experimental::filesystem::exists(path);
-#else
-            struct stat buffer;
-            return (stat(path.c_str(), &buffer) == 0);
-#endif
-        };
-
-        // Check if file exists
-        if (!fileExists(filePath)) {
-            LOGE("Audio file not found: %s", filePath.c_str());
-            return "";
-        }
-
-        // Read audio file using cxx-api
-        sherpa_onnx::cxx::Wave wave = sherpa_onnx::cxx::ReadWave(filePath);
-
-        if (wave.samples.empty()) {
-            LOGE("Audio file is empty or failed to read: %s", filePath.c_str());
-            return "";
-        }
-
-        // Create a stream
-        auto stream = pImpl->recognizer.value().CreateStream();
-
-        // Feed audio data to the stream (all samples at once for offline recognition)
-        stream.AcceptWaveform(wave.sample_rate, wave.samples.data(), wave.samples.size());
-
-        // Decode the stream
-        pImpl->recognizer.value().Decode(&stream);
-
-        // Get result
-        auto result = pImpl->recognizer.value().GetResult(&stream);
-
-        return result.text;
-    } catch (const std::exception& e) {
-        LOGE("Exception during transcription: %s", e.what());
-        return "";
-    } catch (...) {
-        LOGE("Unknown exception during transcription");
-        return "";
-    }
-}
-
-bool SttWrapper::isInitialized() const {
-    return pImpl->initialized;
-}
-
-void SttWrapper::release() {
-    if (pImpl->initialized) {
-        // OfflineRecognizer uses RAII - destruction happens automatically when optional is reset
-        pImpl->recognizer.reset();
-        pImpl->initialized = false;
-        pImpl->modelDir.clear();
-    }
-}
-
-} // namespace sherpaonnx

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

@@ -1,68 +0,0 @@
-#ifndef SHERPA_ONNX_STT_WRAPPER_H
-#define SHERPA_ONNX_STT_WRAPPER_H
-
-#include "sherpa-onnx-common.h"
-#include <cstdint>
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-namespace sherpaonnx {
-
-/**
- * Result of STT initialization.
- */
-struct SttInitializeResult {
-    bool success;
-    std::vector<DetectedModel> detectedModels;  // List of detected models with type and path
-};
-
-/**
- * Wrapper class for sherpa-onnx OfflineRecognizer (STT).
- * This provides a C++ interface that can be easily called from JNI.
- */
-class SttWrapper {
-public:
-    SttWrapper();
-    ~SttWrapper();
-
-    /**
-     * Initialize sherpa-onnx STT with model directory.
-     * @param modelDir Path to the model directory
-     * @param preferInt8 Optional: true = prefer int8 models, false = prefer regular models, nullopt = try int8 first (default)
-     * @param modelType Optional: explicit model type ("transducer", "paraformer", "nemo_ctc"), nullopt = auto-detect (default)
-     * @return SttInitializeResult with success status and list of detected usable models
-     */
-    SttInitializeResult initialize(
-        const std::string& modelDir,
-        const std::optional<bool>& preferInt8 = std::nullopt,
-        const std::optional<std::string>& modelType = std::nullopt
-    );
-
-    /**
-     * Transcribe an audio file.
-     * @param filePath Path to the audio file (WAV 16kHz mono 16-bit PCM)
-     * @return Transcribed text
-     */
-    std::string transcribeFile(const std::string& filePath);
-
-    /**
-     * Check if the recognizer is initialized.
-     * @return true if initialized, false otherwise
-     */
-    bool isInitialized() const;
-
-    /**
-     * Release resources.
-     */
-    void release();
-
-private:
-    class Impl;
-    std::unique_ptr<Impl> pImpl;
-};
-
-} // namespace sherpaonnx
-
-#endif // SHERPA_ONNX_STT_WRAPPER_H