Add examples for Kotlin API (#124)

-package android.content.res
-
-// a dummy class for testing only
-class AssetManager

-../../android/SherpaOnnx/app/src/main/java/com/k2fsa/sherpa/onnx/SherpaOnnx.kt

-../../android/SherpaOnnx/app/src/main/java/com/k2fsa/sherpa/onnx/WaveReader.kt

@@ -8,9 +8,9 @@ on:
       - '.github/workflows/jni.yaml'
       - '.github/workflows/jni.yaml'
       - 'CMakeLists.txt'
       - 'CMakeLists.txt'
       - 'cmake/**'
       - 'cmake/**'
+      - 'kotlin-api-examples/**'
       - 'sherpa-onnx/csrc/*'
       - 'sherpa-onnx/csrc/*'
       - 'sherpa-onnx/jni/*'
       - 'sherpa-onnx/jni/*'
-      - '.github/scripts/test-jni.sh'
   pull_request:
   pull_request:
     branches:
     branches:
       - master
       - master
@@ -18,9 +18,9 @@ on:
       - '.github/workflows/jni.yaml'
       - '.github/workflows/jni.yaml'
       - 'CMakeLists.txt'
       - 'CMakeLists.txt'
       - 'cmake/**'
       - 'cmake/**'
+      - 'kotlin-api-examples/**'
       - 'sherpa-onnx/csrc/*'
       - 'sherpa-onnx/csrc/*'
       - 'sherpa-onnx/jni/*'
       - 'sherpa-onnx/jni/*'
-      - '.github/scripts/test-jni.sh'
 
 
 concurrency:
 concurrency:
   group: jni-${{ github.ref }}
   group: jni-${{ github.ref }}
@@ -56,4 +56,5 @@ jobs:
       - name:  Run JNI test
       - name:  Run JNI test
         shell: bash
         shell: bash
         run: |
         run: |
-          .github/scripts/test-jni.sh
+          cd ./kotlin-api-examples
+          ./run.sh

@@ -55,3 +55,4 @@ sherpa-onnx-zipformer-en-2023-04-01
 run-offline-decode-files.sh
 run-offline-decode-files.sh
 sherpa-onnx-nemo-ctc-en-citrinet-512
 sherpa-onnx-nemo-ctc-en-citrinet-512
 run-offline-decode-files-nemo-ctc.sh
 run-offline-decode-files-nemo-ctc.sh
+*.jar

@@ -51,6 +51,11 @@ if(DEFINED ANDROID_ABI)
   set(SHERPA_ONNX_ENABLE_JNI ON CACHE BOOL "" FORCE)
   set(SHERPA_ONNX_ENABLE_JNI ON CACHE BOOL "" FORCE)
 endif()
 endif()
 
 
+if(SHERPA_ONNX_ENABLE_JNI AND NOT BUILD_SHARED_LIBS)
+  message(STATUS "Set BUILD_SHARED_LIBS to ON since SHERPA_ONNX_ENABLE_JNI is ON")
+  set(BUILD_SHARED_LIBS ON CACHE BOOL "" FORCE)
+endif()
+
 message(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
 message(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
 message(STATUS "CMAKE_INSTALL_PREFIX: ${CMAKE_INSTALL_PREFIX}")
 message(STATUS "CMAKE_INSTALL_PREFIX: ${CMAKE_INSTALL_PREFIX}")
 message(STATUS "BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS}")
 message(STATUS "BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS}")

@@ -38,19 +38,23 @@ data class OnlineRecognizerConfig(
 )
 )
 
 
 class SherpaOnnx(
 class SherpaOnnx(
-    assetManager: AssetManager, var config: OnlineRecognizerConfig
+    assetManager: AssetManager? = null,
+    var config: OnlineRecognizerConfig,
 ) {
 ) {
     private val ptr: Long
     private val ptr: Long
 
 
     init {
     init {
-        ptr = new(assetManager, config)
+        if (assetManager != null) {
+            ptr = new(assetManager, config)
+        } else {
+            ptr = newFromFile(config)
+        }
     }
     }
 
 
     protected fun finalize() {
     protected fun finalize() {
         delete(ptr)
         delete(ptr)
     }
     }
 
 
-
     fun acceptWaveform(samples: FloatArray, sampleRate: Int) =
     fun acceptWaveform(samples: FloatArray, sampleRate: Int) =
         acceptWaveform(ptr, samples, sampleRate)
         acceptWaveform(ptr, samples, sampleRate)
 
 
@@ -70,6 +74,10 @@ class SherpaOnnx(
         config: OnlineRecognizerConfig,
         config: OnlineRecognizerConfig,
     ): Long
     ): Long
 
 
+    private external fun newFromFile(
+        config: OnlineRecognizerConfig,
+    ): Long
+
     private external fun acceptWaveform(ptr: Long, samples: FloatArray, sampleRate: Int)
     private external fun acceptWaveform(ptr: Long, samples: FloatArray, sampleRate: Int)
     private external fun inputFinished(ptr: Long)
     private external fun inputFinished(ptr: Long)
     private external fun getText(ptr: Long): String
     private external fun getText(ptr: Long): String
@@ -86,7 +94,7 @@ class SherpaOnnx(
 }
 }
 
 
 fun getFeatureConfig(sampleRate: Int, featureDim: Int): FeatureConfig {
 fun getFeatureConfig(sampleRate: Int, featureDim: Int): FeatureConfig {
-    return FeatureConfig(sampleRate=sampleRate, featureDim=featureDim)
+    return FeatureConfig(sampleRate = sampleRate, featureDim = featureDim)
 }
 }
 
 
 /*
 /*

@@ -4,10 +4,21 @@ import android.content.res.AssetManager
 
 
 class WaveReader {
 class WaveReader {
     companion object {
     companion object {
-        // Read a mono wave file.
-        // No resampling is made.
-        external fun readWave(
-            assetManager: AssetManager, filename: String, expected_sample_rate: Float = 16000.0f
+        // Read a mono wave file asset
+        // The returned array has two entries:
+        //  - the first entry contains an 1-D float array
+        //  - the second entry is the sample rate
+        external fun readWaveFromAsset(
+            assetManager: AssetManager,
+            filename: String,
+        ): Array<Any>
+
+        // Read a mono wave file from disk
+        // The returned array has two entries:
+        //  - the first entry contains an 1-D float array
+        //  - the second entry is the sample rate
+        external fun readWaveFromFile(
+            filename: String,
         ): Array<Any>
         ): Array<Any>
 
 
         init {
         init {

@@ -8,6 +8,9 @@ fun main() {
         featureDim = 80,
         featureDim = 80,
     )
     )
 
 
+    // please refer to
+    // https://k2-fsa.github.io/sherpa/onnx/pretrained_models/index.html
+    // to dowload pre-trained models
     var modelConfig = OnlineTransducerModelConfig(
     var modelConfig = OnlineTransducerModelConfig(
         encoder = "./sherpa-onnx-streaming-zipformer-en-2023-02-21/encoder-epoch-99-avg-1.onnx",
         encoder = "./sherpa-onnx-streaming-zipformer-en-2023-02-21/encoder-epoch-99-avg-1.onnx",
         decoder = "./sherpa-onnx-streaming-zipformer-en-2023-02-21/decoder-epoch-99-avg-1.onnx",
         decoder = "./sherpa-onnx-streaming-zipformer-en-2023-02-21/decoder-epoch-99-avg-1.onnx",
@@ -29,12 +32,10 @@ fun main() {
     )
     )
 
 
     var model = SherpaOnnx(
     var model = SherpaOnnx(
-        assetManager = AssetManager(),
         config = config,
         config = config,
     )
     )
 
 
-    var objArray = WaveReader.readWave(
-        assetManager = AssetManager(),
+    var objArray = WaveReader.readWaveFromFile(
         filename = "./sherpa-onnx-streaming-zipformer-en-2023-02-21/test_wavs/0.wav",
         filename = "./sherpa-onnx-streaming-zipformer-en-2023-02-21/test_wavs/0.wav",
     )
     )
     var samples : FloatArray = objArray[0] as FloatArray
     var samples : FloatArray = objArray[0] as FloatArray
@@ -45,8 +46,8 @@ fun main() {
       model.decode()
       model.decode()
     }
     }
 
 
-    var tail_paddings = FloatArray((sampleRate * 0.5).toInt()) // 0.5 seconds
-    model.acceptWaveform(tail_paddings, sampleRate=sampleRate)
+    var tailPaddings = FloatArray((sampleRate * 0.5).toInt()) // 0.5 seconds
+    model.acceptWaveform(tailPaddings, sampleRate=sampleRate)
     model.inputFinished()
     model.inputFinished()
     while (model.isReady()) {
     while (model.isReady()) {
       model.decode()
       model.decode()

+../android/SherpaOnnx/app/src/main/java/com/k2fsa/sherpa/onnx/SherpaOnnx.kt

+../android/SherpaOnnx/app/src/main/java/com/k2fsa/sherpa/onnx/WaveReader.kt

+package android.content.res
+
+class AssetManager {}

 #!/usr/bin/env bash
 #!/usr/bin/env bash
+#
+# This scripts shows how to build JNI libs for sherpa-onnx
+# Note: This scripts runs only on Linux and macOS, though sherpa-onnx
+# supports building JNI libs for Windows.
 
 
 set -e
 set -e
 
 
+cd ..
 mkdir -p build
 mkdir -p build
 cd build
 cd build
 
 
@@ -17,17 +22,17 @@ cmake \
 make -j4
 make -j4
 ls -lh lib
 ls -lh lib
 
 
-cd ..
-
 export LD_LIBRARY_PATH=$PWD/build/lib:$LD_LIBRARY_PATH
 export LD_LIBRARY_PATH=$PWD/build/lib:$LD_LIBRARY_PATH
 
 
-cd .github/scripts/
+cd ../kotlin-api-examples
 
 
-git lfs install
-git clone https://huggingface.co/csukuangfj/sherpa-onnx-streaming-zipformer-en-2023-02-21
+if [ ! -f ./sherpa-onnx-streaming-zipformer-en-2023-02-21/tokens.txt ]; then
+  git lfs install
+  git clone https://huggingface.co/csukuangfj/sherpa-onnx-streaming-zipformer-en-2023-02-21
+fi
 
 
-kotlinc-jvm -include-runtime -d main.jar Main.kt WaveReader.kt SherpaOnnx.kt AssetManager.kt
+kotlinc-jvm -include-runtime -d main.jar Main.kt WaveReader.kt SherpaOnnx.kt faked-asset-manager.kt
 
 
 ls -lh main.jar
 ls -lh main.jar
 
 
-java -Djava.library.path=../../build/lib -jar main.jar
+java -Djava.library.path=../build/lib -jar main.jar

@@ -31,18 +31,13 @@ namespace sherpa_onnx {
 
 
 class SherpaOnnx {
 class SherpaOnnx {
  public:
  public:
-  SherpaOnnx(
 #if __ANDROID_API__ >= 9
 #if __ANDROID_API__ >= 9
-      AAssetManager *mgr,
+  SherpaOnnx(AAssetManager *mgr, const OnlineRecognizerConfig &config)
+      : recognizer_(mgr, config), stream_(recognizer_.CreateStream()) {}
 #endif
 #endif
-      const sherpa_onnx::OnlineRecognizerConfig &config)
-      : recognizer_(
-#if __ANDROID_API__ >= 9
-            mgr,
-#endif
-            config),
-        stream_(recognizer_.CreateStream()) {
-  }
+
+  explicit SherpaOnnx(const OnlineRecognizerConfig &config)
+      : recognizer_(config), stream_(recognizer_.CreateStream()) {}
 
 
   void AcceptWaveform(int32_t sample_rate, const float *samples, int32_t n) {
   void AcceptWaveform(int32_t sample_rate, const float *samples, int32_t n) {
     if (input_sample_rate_ == -1) {
     if (input_sample_rate_ == -1) {
@@ -73,8 +68,8 @@ class SherpaOnnx {
   void Decode() const { recognizer_.DecodeStream(stream_.get()); }
   void Decode() const { recognizer_.DecodeStream(stream_.get()); }
 
 
  private:
  private:
-  sherpa_onnx::OnlineRecognizer recognizer_;
-  std::unique_ptr<sherpa_onnx::OnlineStream> stream_;
+  OnlineRecognizer recognizer_;
+  std::unique_ptr<OnlineStream> stream_;
   int32_t input_sample_rate_ = -1;
   int32_t input_sample_rate_ = -1;
 };
 };
 
 
@@ -219,6 +214,16 @@ JNIEXPORT jlong JNICALL Java_com_k2fsa_sherpa_onnx_SherpaOnnx_new(
 }
 }
 
 
 SHERPA_ONNX_EXTERN_C
 SHERPA_ONNX_EXTERN_C
+JNIEXPORT jlong JNICALL Java_com_k2fsa_sherpa_onnx_SherpaOnnx_newFromFile(
+    JNIEnv *env, jobject /*obj*/, jobject _config) {
+  auto config = sherpa_onnx::GetConfig(env, _config);
+  SHERPA_ONNX_LOGE("config:\n%s", config.ToString().c_str());
+  auto model = new sherpa_onnx::SherpaOnnx(config);
+
+  return (jlong)model;
+}
+
+SHERPA_ONNX_EXTERN_C
 JNIEXPORT void JNICALL Java_com_k2fsa_sherpa_onnx_SherpaOnnx_delete(
 JNIEXPORT void JNICALL Java_com_k2fsa_sherpa_onnx_SherpaOnnx_delete(
     JNIEnv *env, jobject /*obj*/, jlong ptr) {
     JNIEnv *env, jobject /*obj*/, jlong ptr) {
   delete reinterpret_cast<sherpa_onnx::SherpaOnnx *>(ptr);
   delete reinterpret_cast<sherpa_onnx::SherpaOnnx *>(ptr);
@@ -289,9 +294,47 @@ static jobject NewInteger(JNIEnv *env, int32_t value) {
   return env->NewObject(cls, constructor, value);
   return env->NewObject(cls, constructor, value);
 }
 }
 
 
+static jobjectArray ReadWaveImpl(JNIEnv *env, std::istream &is,
+                                 const char *p_filename) {
+  bool is_ok = false;
+  int32_t sampling_rate = -1;
+  std::vector<float> samples =
+      sherpa_onnx::ReadWave(is, &sampling_rate, &is_ok);
+
+  if (!is_ok) {
+    SHERPA_ONNX_LOGE("Failed to read %s", p_filename);
+    exit(-1);
+  }
+
+  jfloatArray samples_arr = env->NewFloatArray(samples.size());
+  env->SetFloatArrayRegion(samples_arr, 0, samples.size(), samples.data());
+
+  jobjectArray obj_arr = (jobjectArray)env->NewObjectArray(
+      2, env->FindClass("java/lang/Object"), nullptr);
+
+  env->SetObjectArrayElement(obj_arr, 0, samples_arr);
+  env->SetObjectArrayElement(obj_arr, 1, NewInteger(env, sampling_rate));
+
+  return obj_arr;
+}
+
+SHERPA_ONNX_EXTERN_C
+JNIEXPORT jobjectArray JNICALL
+Java_com_k2fsa_sherpa_onnx_WaveReader_00024Companion_readWaveFromFile(
+    JNIEnv *env, jclass /*cls*/, jstring filename) {
+  const char *p_filename = env->GetStringUTFChars(filename, nullptr);
+  std::ifstream is(p_filename, std::ios::binary);
+
+  auto obj_arr = ReadWaveImpl(env, is, p_filename);
+
+  env->ReleaseStringUTFChars(filename, p_filename);
+
+  return obj_arr;
+}
+
 SHERPA_ONNX_EXTERN_C
 SHERPA_ONNX_EXTERN_C
 JNIEXPORT jobjectArray JNICALL
 JNIEXPORT jobjectArray JNICALL
-Java_com_k2fsa_sherpa_onnx_WaveReader_00024Companion_readWave(
+Java_com_k2fsa_sherpa_onnx_WaveReader_00024Companion_readWaveFromAsset(
     JNIEnv *env, jclass /*cls*/, jobject asset_manager, jstring filename) {
     JNIEnv *env, jclass /*cls*/, jobject asset_manager, jstring filename) {
   const char *p_filename = env->GetStringUTFChars(filename, nullptr);
   const char *p_filename = env->GetStringUTFChars(filename, nullptr);
 #if __ANDROID_API__ >= 9
 #if __ANDROID_API__ >= 9
@@ -308,27 +351,10 @@ Java_com_k2fsa_sherpa_onnx_WaveReader_00024Companion_readWave(
   std::ifstream is(p_filename, std::ios::binary);
   std::ifstream is(p_filename, std::ios::binary);
 #endif
 #endif
 
 
-  bool is_ok = false;
-  int32_t sampling_rate = -1;
-  std::vector<float> samples =
-      sherpa_onnx::ReadWave(is, &sampling_rate, &is_ok);
+  auto obj_arr = ReadWaveImpl(env, is, p_filename);
 
 
   env->ReleaseStringUTFChars(filename, p_filename);
   env->ReleaseStringUTFChars(filename, p_filename);
 
 
-  if (!is_ok) {
-    SHERPA_ONNX_LOGE("Failed to read %s", p_filename);
-    exit(-1);
-  }
-
-  jfloatArray ans = env->NewFloatArray(samples.size());
-  env->SetFloatArrayRegion(ans, 0, samples.size(), samples.data());
-
-  jobjectArray obj_arr = (jobjectArray)env->NewObjectArray(
-      2, env->FindClass("java/lang/Object"), nullptr);
-
-  env->SetObjectArrayElement(obj_arr, 0, ans);
-  env->SetObjectArrayElement(obj_arr, 1, NewInteger(env, sampling_rate));
-
   return obj_arr;
   return obj_arr;
 }
 }
 
 
@@ -340,8 +366,9 @@ JNIEXPORT jobjectArray JNICALL
 Java_com_k2fsa_sherpa_onnx_OnlineRecognizer_readWave(JNIEnv *env,
 Java_com_k2fsa_sherpa_onnx_OnlineRecognizer_readWave(JNIEnv *env,
                                                      jclass /*cls*/,
                                                      jclass /*cls*/,
                                                      jstring filename) {
                                                      jstring filename) {
-  auto data = Java_com_k2fsa_sherpa_onnx_WaveReader_00024Companion_readWave(
-      env, nullptr, nullptr, filename);
+  auto data =
+      Java_com_k2fsa_sherpa_onnx_WaveReader_00024Companion_readWaveFromAsset(
+          env, nullptr, nullptr, filename);
   return data;
   return data;
 }
 }