chore: import upstream snapshot with attribution

android/README.md

@@ -0,0 +1,3 @@
+Vosk library for Android
+
+See for details https://alphacephei.com/vosk/android

android/build.gradle

@@ -0,0 +1,53 @@
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.13.0'
+        classpath 'com.vanniktech:gradle-maven-publish-plugin:0.34.0'
+    }
+}
+
+allprojects {
+    version = '0.3.75'
+}
+
+subprojects {
+
+    apply plugin: 'com.android.library'
+    apply plugin: 'com.vanniktech.maven.publish'
+
+    repositories {
+        google()
+        mavenCentral()
+    }
+
+    mavenPublishing {
+        publishToMavenCentral()
+        signAllPublications()
+    }
+
+    mavenPublishing {
+        pom {
+            url = 'http://www.alphacephei.com.com/vosk/'
+            licenses {
+                license {
+                    name = 'The Apache License, Version 2.0'
+                    url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+                }
+            }
+            developers {
+                developer {
+                    id = 'com.alphacephei'
+                    name = 'Alpha Cephei Inc'
+                    email = 'contact@alphacephei.com'
+                }
+            }
+            scm {
+                connection = 'scm:git:git://github.com/alphacep/vosk-api.git'
+                url = 'https://github.com/alphacep/vosk-api/'
+            }
+        }
+    }
+}

android/lib/build-vosk.sh

@@ -0,0 +1,140 @@
+#!/bin/bash
+
+# Copyright 2019-2021 Alpha Cephei Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+if [ "x$ANDROID_NDK_HOME" == "x" ]; then
+    echo "ANDROID_NDK_HOME environment variable is undefined, define it with local.properties or with export"
+    exit 1
+fi
+
+if [ ! -d "$ANDROID_NDK_HOME" ]; then
+    echo "ANDROID_NDK_HOME ($ANDROID_NDK_HOME) is missing. Make sure you have ndk installed"
+    exit 1
+fi
+
+set -x
+
+OS_NAME=`echo $(uname -s) | tr '[:upper:]' '[:lower:]'`
+ANDROID_TOOLCHAIN_PATH=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/${OS_NAME}-x86_64
+WORKDIR_BASE=`pwd`/build
+PATH=$ANDROID_TOOLCHAIN_PATH/bin:$PATH
+OPENFST_VERSION=1.8.0
+
+for arch in armeabi-v7a arm64-v8a x86_64 x86; do
+
+WORKDIR=${WORKDIR_BASE}/kaldi_${arch}
+
+case $arch in
+    armeabi-v7a)
+          BLAS_ARCH=ARMV7
+          HOST=arm-linux-androideabi
+          AR=llvm-ar
+          RANLIB=llvm-ranlib
+          CC=armv7a-linux-androideabi21-clang
+          CXX=armv7a-linux-androideabi21-clang++
+          ARCHFLAGS="-mfloat-abi=softfp -mfpu=neon"
+          PAGESIZE_LDFLAGS=""
+          ;;
+    arm64-v8a)
+          BLAS_ARCH=ARMV8
+          HOST=aarch64-linux-android
+          AR=llvm-ar
+          RANLIB=llvm-ranlib
+          CC=aarch64-linux-android21-clang
+          CXX=aarch64-linux-android21-clang++
+          ARCHFLAGS=""
+          # Ensure compatibility with 16KiB page size devices
+          PAGESIZE_LDFLAGS="-Wl,-z,common-page-size=4096 -Wl,-z,max-page-size=16384"
+          ;;
+    x86_64)
+          BLAS_ARCH=ATOM
+          HOST=x86_64-linux-android
+          AR=llvm-ar
+          RANLIB=llvm-ranlib
+          CC=x86_64-linux-android21-clang
+          CXX=x86_64-linux-android21-clang++
+          ARCHFLAGS=""
+          PAGESIZE_LDFLAGS=""
+          ;;
+    x86)
+          BLAS_ARCH=ATOM
+          HOST=i686-linux-android
+          AR=llvm-ar
+          RANLIB=llvm-ranlib
+          CC=i686-linux-android21-clang
+          CXX=i686-linux-android21-clang++
+          ARCHFLAGS=""
+          PAGESIZE_LDFLAGS=""
+          ;;
+esac
+
+mkdir -p $WORKDIR/local/lib
+
+# openblas first
+cd $WORKDIR
+git clone -b v0.3.20 --single-branch https://github.com/xianyi/OpenBLAS
+make -C OpenBLAS TARGET=$BLAS_ARCH ONLY_CBLAS=1 AR=$AR CC=$CC HOSTCC=gcc ARM_SOFTFP_ABI=1 USE_THREAD=0 NUM_THREADS=1 -j 8
+make -C OpenBLAS install PREFIX=$WORKDIR/local
+
+# CLAPACK
+cd $WORKDIR
+git clone -b v3.2.1  --single-branch https://github.com/alphacep/clapack
+mkdir -p clapack/BUILD && cd clapack/BUILD
+cmake -DCMAKE_C_FLAGS="$ARCHFLAGS" -DCMAKE_C_COMPILER_TARGET=$HOST \
+    -DCMAKE_C_COMPILER=$CC -DCMAKE_SYSTEM_NAME=Generic -DCMAKE_AR=$ANDROID_TOOLCHAIN_PATH/bin/$AR \
+    -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY \
+    -DCMAKE_CROSSCOMPILING=True ..
+make -j 8 -C F2CLIBS/libf2c
+make -j 8 -C BLAS/SRC
+make -j 8 -C SRC
+find . -name "*.a" | xargs cp -t $WORKDIR/local/lib
+
+# tools directory --> we'll only compile OpenFST
+cd $WORKDIR
+git clone https://github.com/alphacep/openfst
+cd openfst
+autoreconf -i
+CXX=$CXX CXXFLAGS="$ARCHFLAGS -O3 -DFST_NO_DYNAMIC_LINKING" ./configure --prefix=${WORKDIR}/local \
+    --enable-shared --enable-static --with-pic --disable-bin \
+    --enable-lookahead-fsts --enable-ngram-fsts --host=$HOST --build=x86-linux-gnu
+make -j 8
+make install
+
+# Kaldi itself
+cd $WORKDIR
+git clone -b vosk-android --single-branch https://github.com/alphacep/kaldi
+cd $WORKDIR/kaldi/src
+CXX=$CXX AR=$AR RANLIB=$RANLIB CXXFLAGS="$ARCHFLAGS -O3 -DFST_NO_DYNAMIC_LINKING" ./configure --use-cuda=no \
+    --mathlib=OPENBLAS_CLAPACK --shared \
+    --android-incdir=${ANDROID_TOOLCHAIN_PATH}/sysroot/usr/include \
+    --host=$HOST --openblas-root=${WORKDIR}/local \
+    --fst-root=${WORKDIR}/local --fst-version=${OPENFST_VERSION}
+make -j 8 depend
+cd $WORKDIR/kaldi/src
+make -j 8 online2 rnnlm
+
+# Vosk-api
+cd $WORKDIR
+mkdir -p $WORKDIR/vosk
+make -j 8 -C ${WORKDIR_BASE}/../../../src \
+    OUTDIR=$WORKDIR/vosk \
+    KALDI_ROOT=${WORKDIR}/kaldi \
+    OPENFST_ROOT=${WORKDIR}/local \
+    OPENBLAS_ROOT=${WORKDIR}/local \
+    CXX=$CXX \
+    EXTRA_LDFLAGS="-llog -static-libstdc++ -Wl,-soname,libvosk.so ${PAGESIZE_LDFLAGS}"
+cp $WORKDIR/vosk/libvosk.so $WORKDIR/../../src/main/jniLibs/$arch/libvosk.so
+
+done

android/lib/build.gradle

@@ -0,0 +1,39 @@
+def archiveName = "vosk-android"
+def pomName = "Vosk Android"
+def pomDescription = "Vosk speech recognition library for Android"
+
+android {
+    namespace 'org.vosk'
+    compileSdkVersion 36
+    defaultConfig {
+        minSdkVersion 21
+        targetSdkVersion 36
+        versionCode 10
+        versionName = version
+        archivesBaseName = archiveName
+        ndkVersion = "28.2.13676358"
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+task buildVosk(type: Exec) {
+    commandLine './build-vosk.sh'
+    environment ANDROID_NDK_HOME: android.getNdkDirectory()
+}
+
+dependencies {
+    api 'net.java.dev.jna:jna:5.18.1@aar'
+}
+
+//preBuild.dependsOn buildVosk
+
+mavenPublishing {
+    coordinates("com.alphacephei", archiveName, version)
+    pom {
+        name = pomName
+        description = pomDescription
+    }
+}

android/lib/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest>
+</manifest>

android/lib/src/main/java/org/vosk/LibVosk.java

@@ -0,0 +1,82 @@
+package org.vosk;
+
+import com.sun.jna.Native;
+import com.sun.jna.Library;
+import com.sun.jna.Platform;
+import com.sun.jna.Pointer;
+import java.io.File;
+import java.io.InputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+
+public class LibVosk {
+
+    static {
+        Native.register(LibVosk.class, "vosk");
+    }
+
+    public static native void vosk_set_log_level(int level);
+
+    public static native Pointer vosk_model_new(String path);
+
+    public static native void vosk_model_free(Pointer model);
+
+    public static native Pointer vosk_spk_model_new(String path);
+
+    public static native void vosk_spk_model_free(Pointer model);
+
+    public static native Pointer vosk_recognizer_new(Model model, float sample_rate);
+
+    public static native Pointer vosk_recognizer_new_spk(Pointer model, float sample_rate, Pointer spk_model);
+
+    public static native Pointer vosk_recognizer_new_grm(Pointer model, float sample_rate, String grammar);
+
+    public static native void vosk_recognizer_set_max_alternatives(Pointer recognizer, int max_alternatives);
+
+    public static native void vosk_recognizer_set_words(Pointer recognizer, boolean words);
+
+    public static native void vosk_recognizer_set_partial_words(Pointer recognizer, boolean partial_words);
+
+    public static native void vosk_recognizer_set_spk_model(Pointer recognizer, Pointer spk_model);
+
+    public static native boolean vosk_recognizer_accept_waveform(Pointer recognizer, byte[] data, int len);
+
+    public static native boolean vosk_recognizer_accept_waveform_s(Pointer recognizer, short[] data, int len);
+
+    public static native boolean vosk_recognizer_accept_waveform_f(Pointer recognizer, float[] data, int len);
+
+    public static native String vosk_recognizer_result(Pointer recognizer);
+
+    public static native String vosk_recognizer_final_result(Pointer recognizer);
+
+    public static native String vosk_recognizer_partial_result(Pointer recognizer);
+
+    public static native void vosk_recognizer_set_grm(Pointer recognizer, String grammar);
+
+    public static native void vosk_recognizer_reset(Pointer recognizer);
+
+    public static native void vosk_recognizer_set_endpointer_mode(Pointer recognizer, int mode);
+
+    public static native void vosk_recognizer_set_endpointer_delays(Pointer recognizer, float t_start_max, float t_end, float t_max);
+
+    public static native void vosk_recognizer_free(Pointer recognizer);
+
+    public static native Pointer vosk_text_processor_new(String verbalizer, String tagger);
+
+    public static native void vosk_text_processor_free(Pointer processor);
+
+    public static native String vosk_text_processor_itn(Pointer processor, String input);
+
+    /**
+     * Set log level for Kaldi messages.
+     *
+     *  @param loglevel the level
+     *     0 - default value to print info and error messages but no debug
+     *     less than 0 - don't print info messages
+     *     greater than 0 - more verbose mode
+     */
+    public static void setLogLevel(LogLevel loglevel) {
+        vosk_set_log_level(loglevel.getValue());
+    }
+}

android/lib/src/main/java/org/vosk/LogLevel.java

@@ -0,0 +1,17 @@
+package org.vosk;
+
+public enum LogLevel {
+    WARNINGS(-1),  // Print warning and errors
+    INFO(0),       // Print info, along with warning and error messages, but no debug
+    DEBUG(1);      // Print debug info
+
+    private final int value;
+
+    LogLevel(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return this.value;
+    }
+}

android/lib/src/main/java/org/vosk/Model.java

@@ -0,0 +1,22 @@
+package org.vosk;
+
+import java.io.IOException;
+import com.sun.jna.PointerType;
+
+public class Model extends PointerType implements AutoCloseable {
+    public Model() {
+    }
+
+    public Model(String path) throws IOException {
+        super(LibVosk.vosk_model_new(path));
+
+        if (getPointer() == null) {
+            throw new IOException("Failed to create a model");
+        }
+    }
+
+    @Override
+    public void close() {
+        LibVosk.vosk_model_free(this.getPointer());
+    }
+}

android/lib/src/main/java/org/vosk/Recognizer.java

@@ -0,0 +1,275 @@
+package org.vosk;
+
+import com.sun.jna.PointerType;
+import java.io.IOException;
+
+public class Recognizer extends PointerType implements AutoCloseable {
+    /**
+     * Creates the recognizer object.
+     *
+     * The recognizers process the speech and return text using shared model data
+     * @param model       VoskModel containing static data for recognizer. Model can be
+     *                    shared across recognizers, even running in different threads.
+     * @param sampleRate The sample rate of the audio you are going to feed into the recognizer.
+     *                    Make sure this rate matches the audio content, it is a common
+     *                    issue causing accuracy problems.
+     * @throws IOException if the recognizer could not be created
+     */
+    public Recognizer(Model model, float sampleRate) throws IOException {
+        super(LibVosk.vosk_recognizer_new(model, sampleRate));
+
+        if (getPointer() == null) {
+            throw new IOException("Failed to create a recognizer");
+        }
+    }
+
+    /**
+     * Creates the recognizer object with speaker recognition.
+     *
+     *  With the speaker recognition mode the recognizer not just recognize
+     *  text but also return speaker vectors one can use for speaker identification
+     *
+     *  @param model       VoskModel containing static data for recognizer. Model can be
+     *                     shared across recognizers, even running in different threads.
+     *  @param sampleRate The sample rate of the audio you are going to feed into the recognizer.
+     *                     Make sure this rate matches the audio content, it is a common
+     *                     issue causing accuracy problems.
+     *  @param spkModel speaker model for speaker identification
+     *  @throws IOException if the recognizer could not be created
+     */
+    public Recognizer(Model model, float sampleRate, SpeakerModel spkModel) throws IOException {
+        super(LibVosk.vosk_recognizer_new_spk(model.getPointer(), sampleRate, spkModel.getPointer()));
+
+        if (getPointer() == null) {
+            throw new IOException("Failed to create a recognizer");
+        }
+    }
+
+    /**
+     * Creates the recognizer object with the phrase list.
+     *
+     *  Sometimes when you want to improve recognition accuracy and when you don't need
+     *  to recognize large vocabulary you can specify a list of phrases to recognize. This
+     *  will improve recognizer speed and accuracy but might return [unk] if user said
+     *  something different.
+     *
+     *  Only recognizers with lookahead models support this type of quick configuration.
+     *  Precompiled HCLG graph models are not supported.
+     *
+     *  @param model       VoskModel containing static data for recognizer. Model can be
+     *                     shared across recognizers, even running in different threads.
+     *  @param sampleRate The sample rate of the audio you are going to feed into the recognizer.
+     *                     Make sure this rate matches the audio content, it is a common
+     *                     issue causing accuracy problems.
+     *  @param grammar The string with the list of phrases to recognize as JSON array of strings,
+     *                 for example "["one two three four five", "[unk]"]".
+     *  @throws IOException if the recognizer could not be created
+     */
+    public Recognizer(Model model, float sampleRate, String grammar) throws IOException {
+        super(LibVosk.vosk_recognizer_new_grm(model.getPointer(), sampleRate, grammar));
+
+        if (getPointer() == null) {
+            throw new IOException("Failed to create a recognizer");
+        }
+    }
+
+    /**
+     * Configures recognizer to output n-best results.
+     *
+     * <pre>
+     *   {
+     *      "alternatives": [
+     *          { "text": "one two three four five", "confidence": 0.97 },
+     *          { "text": "one two three for five", "confidence": 0.03 },
+     *      ]
+     *   }
+     * </pre>
+     *
+     * @param maxAlternatives - maximum alternatives to return from recognition results
+     */
+    public void setMaxAlternatives(int maxAlternatives) {
+        LibVosk.vosk_recognizer_set_max_alternatives(this.getPointer(), maxAlternatives);
+    }
+
+    /** Enables words with times in the output
+     *
+     * <pre>
+     *   "result" : [{
+     *       "conf" : 1.000000,
+     *       "end" : 1.110000,
+     *       "start" : 0.870000,
+     *       "word" : "what"
+     *     }, {
+     *       "conf" : 1.000000,
+     *       "end" : 1.530000,
+     *       "start" : 1.110000,
+     *       "word" : "zero"
+     *     }, {
+     *       "conf" : 1.000000,
+     *       "end" : 1.950000,
+     *       "start" : 1.530000,
+     *       "word" : "zero"
+     *     }, {
+     *       "conf" : 1.000000,
+     *       "end" : 2.340000,
+     *       "start" : 1.950000,
+     *       "word" : "zero"
+     *     }, {
+     *       "conf" : 1.000000,
+     *       "end" : 2.610000,
+     *       "start" : 2.340000,
+     *       "word" : "one"
+     *     }],
+     * </pre>
+     *
+     * @param words - boolean value
+     */
+    public void setWords(boolean words) {
+        LibVosk.vosk_recognizer_set_words(this.getPointer(), words);
+    }
+
+    /**
+     * Like above return words and confidences in partial results.
+     *
+     * @param partial_words - boolean value
+     */
+    public void setPartialWords(boolean partial_words) {
+        LibVosk.vosk_recognizer_set_partial_words(this.getPointer(), partial_words);
+    }
+
+    /**
+     * Adds speaker model to already initialized recognizer.
+     *
+     * Can add speaker recognition model to already created recognizer.
+     * Helps to initialize speaker recognition for grammar-based recognizer.
+     *
+     * @param spkModel Speaker recognition model
+     */
+    public void setSpeakerModel(SpeakerModel spkModel) {
+        LibVosk.vosk_recognizer_set_spk_model(this.getPointer(), spkModel.getPointer());
+    }
+
+    /**
+     * Accept and process new chunk of voice data.
+     *
+     *  @param data - audio data in PCM 16-bit mono format
+     *  @param len - length of the audio data
+     *  @return 1 if silence is occurred and you can retrieve a new utterance with result method
+     *           0 if decoding continues
+     *           -1 if exception occurred
+     */
+    public boolean acceptWaveForm(byte[] data, int len) {
+        return LibVosk.vosk_recognizer_accept_waveform(this.getPointer(), data, len);
+    }
+
+    public boolean acceptWaveForm(short[] data, int len) {
+        return LibVosk.vosk_recognizer_accept_waveform_s(this.getPointer(), data, len);
+    }
+
+    public boolean acceptWaveForm(float[] data, int len) {
+        return LibVosk.vosk_recognizer_accept_waveform_f(this.getPointer(), data, len);
+    }
+
+    /**
+     * Returns speech recognition result
+     *
+     * @return the result in JSON format which contains decoded line, decoded
+     *          words, times in seconds and confidences. You can parse this result
+     *          with any json parser
+     *
+     * <pre>
+     *  {
+     *    "text" : "what zero zero zero one"
+     *  }
+     * </pre>
+     *
+     * If alternatives enabled it returns result with alternatives, see also #setMaxAlternatives().
+     *
+     * If word times enabled returns word time, see also #setWordTimes().
+     */
+    public String getResult() {
+        return LibVosk.vosk_recognizer_result(this.getPointer());
+    }
+
+    /**
+     * Returns partial speech recognition.
+     *
+     * @return partial speech recognition text which is not yet finalized.
+     *          result may change as recognizer process more data.
+     *
+     * <pre>
+     * {
+     *    "partial" : "cyril one eight zero"
+     * }
+     * </pre>
+     */
+    public String getPartialResult() {
+        return LibVosk.vosk_recognizer_partial_result(this.getPointer());
+    }
+
+    /**
+     * Returns speech recognition result. Same as result, but doesn't wait for silence.
+     *  You usually call it in the end of the stream to get final bits of audio. It
+     *  flushes the feature pipeline, so all remaining audio chunks got processed.
+     *
+     *  @return speech result in JSON format.
+     */
+    public String getFinalResult() {
+        return LibVosk.vosk_recognizer_final_result(this.getPointer());
+    }
+
+    /**
+     * Reconfigures recognizer to use grammar.
+     *
+     * @param grammar      Set of phrases in JSON array of strings or "[]" to use default model graph.
+     * @see #Recognizer(Model, float, String)
+     */
+    public void setGrammar(String grammar) {
+        LibVosk.vosk_recognizer_set_grm(this.getPointer(), grammar);
+    }
+
+    /**
+     * Resets the recognizer.
+     * Resets current results so the recognition can continue from scratch.
+     */
+    public void reset() {
+        LibVosk.vosk_recognizer_reset(this.getPointer());
+    }
+
+    /**
+     * Endpointer delay mode
+     */
+    public class EndpointerMode {
+        public static final int DEFAULT = 0;
+        public static final int SHORT = 1;
+        public static final int LONG = 2;
+        public static final int VERY_LONG = 3;
+    }
+
+    /**
+     * Configures endpointer mode for recognizer
+     */
+    public void setEndpointerMode(int mode) {
+        LibVosk.vosk_recognizer_set_endpointer_mode(this.getPointer(), mode);
+    }
+
+    /**
+     * Set endpointer delays
+     *
+     * @param t_start_max     timeout for stopping recognition in case of initial silence (usually around 5.0)
+     * @param t_end           timeout for stopping recognition in milliseconds after we recognized something (usually around 0.5 - 1.0)
+     * @param t_max           timeout for forcing utterance end in milliseconds (usually around 20-30)
+     **/
+    public void setEndpointerDelays(float t_start_max, float t_end, float t_max) {
+        LibVosk.vosk_recognizer_set_endpointer_delays(this.getPointer(), t_start_max, t_end, t_max);
+    }
+
+    /**
+     * Releases recognizer object.
+     * Underlying model is also unreferenced and if needed, released.
+     */
+    @Override
+    public void close() {
+        LibVosk.vosk_recognizer_free(this.getPointer());
+    }
+}

android/lib/src/main/java/org/vosk/SpeakerModel.java

@@ -0,0 +1,40 @@
+package org.vosk;
+
+import com.sun.jna.PointerType;
+import java.io.IOException;
+
+/**
+ * Helps to initialize speaker recognition for grammar-based recognizer.
+ */
+public class SpeakerModel extends PointerType implements AutoCloseable {
+    public SpeakerModel() {
+    }
+
+    /**
+     * Loads speaker model data from the file.
+     *
+     * The path must contain:
+     * - a config file: mfcc.conf
+     * - kaldi nnet: final.ext.raw
+     * - mean.vec
+     * - transform.mat
+     *
+     * @param path the path of the model on the filesystem
+     * @throws IOException if the model could not be created
+     *
+     * @see <a href="http://kaldi-asr.org/doc/structkaldi_1_1MfccOptions.html">Kaldi MfccOptions</a>
+     * @see <a href="http://kaldi-asr.org/doc/classkaldi_1_1nnet3_1_1Nnet.html">Kaldi Nnet</a>
+     */
+    public SpeakerModel(String path) throws IOException {
+        super(LibVosk.vosk_spk_model_new(path));
+
+        if (getPointer() == null) {
+            throw new IOException("Failed to create a speaker model");
+        }
+    }
+
+    @Override
+    public void close() {
+        LibVosk.vosk_spk_model_free(this.getPointer());
+    }
+}

android/lib/src/main/java/org/vosk/TextProcessor.java

@@ -0,0 +1,21 @@
+package org.vosk;
+
+import com.sun.jna.PointerType;
+
+public class TextProcessor extends PointerType implements AutoCloseable {
+    public TextProcessor() {
+    }
+
+    public TextProcessor(String verbalizer, String tagger) {
+        super(LibVosk.vosk_text_processor_new(verbalizer, tagger));
+    }
+
+    @Override
+    public void close() {
+        LibVosk.vosk_text_processor_free(this.getPointer());
+    }
+
+    public String itn(String input) {
+        return LibVosk.vosk_text_processor_itn(this.getPointer(), input);
+    }
+}

android/lib/src/main/java/org/vosk/android/RecognitionListener.java

@@ -0,0 +1,46 @@
+// Copyright 2019 Alpha Cephei Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package org.vosk.android;
+
+/**
+ * Interface to receive recognition results
+ */
+public interface RecognitionListener {
+
+    /**
+     * Called when partial recognition result is available.
+     */
+    void onPartialResult(String hypothesis);
+
+    /**
+     * Called after silence occured.
+     */
+    void onResult(String hypothesis);
+
+    /**
+     * Called after stream end.
+     */
+    void onFinalResult(String hypothesis);
+
+    /**
+     * Called when an error occurs.
+     */
+    void onError(Exception exception);
+
+    /**
+     * Called after timeout expired
+     */
+    void onTimeout();
+}

android/lib/src/main/java/org/vosk/android/SpeechService.java

@@ -0,0 +1,316 @@
+// Copyright 2019 Alpha Cephei Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package org.vosk.android;
+
+import android.media.AudioFormat;
+import android.media.AudioRecord;
+import android.media.MediaRecorder.AudioSource;
+import android.os.Handler;
+import android.os.Looper;
+import android.annotation.SuppressLint;
+
+import org.vosk.Recognizer;
+import java.io.IOException;
+
+/**
+ * Service that records audio in a thread, passes it to a recognizer and emits
+ * recognition results. Recognition events are passed to a client using
+ * {@link RecognitionListener}
+ */
+public class SpeechService {
+
+    private final Recognizer recognizer;
+
+    private final int sampleRate;
+    private final static float BUFFER_SIZE_SECONDS = 0.2f;
+    private final int bufferSize;
+    private final AudioRecord recorder;
+
+    private RecognizerThread recognizerThread;
+
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+
+    /**
+     * Creates speech service. Service holds the AudioRecord object, so you
+     * need to call {@link #shutdown()} in order to properly finalize it.
+     *
+     * @throws IOException thrown if audio recorder can not be created for some reason.
+     */
+    @SuppressLint("MissingPermission")
+    public SpeechService(Recognizer recognizer, float sampleRate) throws IOException {
+        this.recognizer = recognizer;
+        this.sampleRate = (int) sampleRate;
+
+        bufferSize = Math.round(this.sampleRate * BUFFER_SIZE_SECONDS);
+        recorder = new AudioRecord(
+                AudioSource.VOICE_RECOGNITION, this.sampleRate,
+                AudioFormat.CHANNEL_IN_MONO,
+                AudioFormat.ENCODING_PCM_16BIT, bufferSize * 2);
+
+        if (recorder.getState() == AudioRecord.STATE_UNINITIALIZED) {
+            recorder.release();
+            throw new IOException(
+                    "Failed to initialize recorder. Microphone might be already in use.");
+        }
+    }
+
+    /**
+     * Creates speech service with a caller-supplied {@link AudioRecord}.
+     * <p>
+     * Use this when you need to control the audio input device - for example,
+     * to pin recording to the built-in microphone when an external USB device
+     * without a microphone is present:
+     * <pre>
+     * AudioRecord recorder = new AudioRecord.Builder()
+     *         .setAudioSource(MediaRecorder.AudioSource.VOICE_RECOGNITION)
+     *         .setAudioFormat(format)
+     *         .build();
+     * if (Build.VERSION.SDK_INT >= 28) {
+     *     AudioManager am = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
+     *     for (AudioDeviceInfo d : am.getDevices(AudioManager.GET_DEVICES_INPUTS)) {
+     *         if (d.getType() == AudioDeviceInfo.TYPE_BUILTIN_MIC) {
+     *             recorder.setPreferredDevice(d);
+     *             break;
+     *         }
+     *     }
+     * }
+     * SpeechService service = new SpeechService(recognizer, 16000f, recorder);
+     * </pre>
+     * <p>
+     * The caller retains ownership of {@code recorder}: if this constructor
+     * throws, the recorder is <em>not</em> released. Call
+     * {@link AudioRecord#release()} yourself in that case.
+     *
+     * @param recognizer the Vosk recognizer
+     * @param sampleRate sample rate in Hz; must match {@code recorder}'s configuration
+     * @param recorder   a fully-initialised {@link AudioRecord}
+     * @throws IOException if {@code recorder} is in STATE_UNINITIALIZED
+     */
+    public SpeechService(Recognizer recognizer, float sampleRate, AudioRecord recorder)
+            throws IOException {
+        this.recognizer = recognizer;
+        this.sampleRate = (int) sampleRate;
+        this.recorder   = recorder;
+
+        bufferSize = Math.round(this.sampleRate * BUFFER_SIZE_SECONDS);
+
+        if (recorder.getState() == AudioRecord.STATE_UNINITIALIZED) {
+            throw new IOException(
+                    "Failed to initialize recorder. Microphone might be already in use.");
+        }
+    }
+
+    /**
+     * Starts recognition. Does nothing if recognition is active.
+     *
+     * @return true if recognition was actually started
+     */
+    public boolean startListening(RecognitionListener listener) {
+        if (null != recognizerThread)
+            return false;
+
+        recognizerThread = new RecognizerThread(listener);
+        recognizerThread.start();
+        return true;
+    }
+
+    /**
+     * Starts recognition. After specified timeout listening stops and the
+     * endOfSpeech signals about that. Does nothing if recognition is active.
+     * <p>
+     * timeout - timeout in milliseconds to listen.
+     *
+     * @return true if recognition was actually started
+     */
+    public boolean startListening(RecognitionListener listener, int timeout) {
+        if (null != recognizerThread)
+            return false;
+
+        recognizerThread = new RecognizerThread(listener, timeout);
+        recognizerThread.start();
+        return true;
+    }
+
+    private boolean stopRecognizerThread() {
+        if (null == recognizerThread)
+            return false;
+
+        try {
+            recognizerThread.interrupt();
+            recognizerThread.join();
+        } catch (InterruptedException e) {
+            // Restore the interrupted status.
+            Thread.currentThread().interrupt();
+        }
+
+        recognizerThread = null;
+        return true;
+    }
+
+    /**
+     * Stops recognition. Listener should receive final result if there is
+     * any. Does nothing if recognition is not active.
+     *
+     * @return true if recognition was actually stopped
+     */
+    public boolean stop() {
+        return stopRecognizerThread();
+    }
+
+    /**
+     * Cancel recognition. Do not post any new events, simply cancel processing.
+     * Does nothing if recognition is not active.
+     *
+     * @return true if recognition was actually stopped
+     */
+    public boolean cancel() {
+        if (recognizerThread != null) {
+            recognizerThread.setPause(true);
+        }
+        return stopRecognizerThread();
+    }
+
+
+    /**
+     * Returns the audio session ID of the underlying {@link AudioRecord}.
+     * <p>
+     * The session ID can be used to attach audio effects such as
+     * {@link android.media.audiofx.NoiseSuppressor} to the recording session.
+     *
+     * @return audio session ID, or {@link AudioRecord#ERROR} if unavailable
+     */
+    public int getAudioSessionId() {
+        return recorder.getAudioSessionId();
+    }
+
+    /**
+     * Shutdown the recognizer and release the recorder
+     */
+    public void shutdown() {
+        recorder.release();
+    }
+
+    public void setPause(boolean paused) {
+        if (recognizerThread != null) {
+            recognizerThread.setPause(paused);
+        }
+    }
+
+    /**
+     * Resets recognizer in a thread, starts recognition over again
+     */
+    public void reset() {
+        if (recognizerThread != null) {
+            recognizerThread.reset();
+        }
+    }
+
+    private final class RecognizerThread extends Thread {
+
+        private int remainingSamples;
+        private final int timeoutSamples;
+        private final static int NO_TIMEOUT = -1;
+        private volatile boolean paused = false;
+        private volatile boolean reset = false;
+
+        RecognitionListener listener;
+
+        public RecognizerThread(RecognitionListener listener, int timeout) {
+            this.listener = listener;
+            if (timeout != NO_TIMEOUT)
+                this.timeoutSamples = timeout * sampleRate / 1000;
+            else
+                this.timeoutSamples = NO_TIMEOUT;
+            this.remainingSamples = this.timeoutSamples;
+        }
+
+        public RecognizerThread(RecognitionListener listener) {
+            this(listener, NO_TIMEOUT);
+        }
+
+        /**
+         * When we are paused, don't process audio by the recognizer and don't emit
+         * any listener results
+         *
+         * @param paused the status of pause
+         */
+        public void setPause(boolean paused) {
+            this.paused = paused;
+        }
+
+        /**
+         * Set reset state to signal reset of the recognizer and start over
+         */
+        public void reset() {
+            this.reset = true;
+        }
+
+        @Override
+        public void run() {
+
+            recorder.startRecording();
+            if (recorder.getRecordingState() == AudioRecord.RECORDSTATE_STOPPED) {
+                recorder.stop();
+                IOException ioe = new IOException(
+                        "Failed to start recording. Microphone might be already in use.");
+                mainHandler.post(() -> listener.onError(ioe));
+            }
+
+            short[] buffer = new short[bufferSize];
+
+            while (!interrupted()
+                    && ((timeoutSamples == NO_TIMEOUT) || (remainingSamples > 0))) {
+                int nread = recorder.read(buffer, 0, buffer.length);
+
+                if (paused) {
+                    continue;
+                }
+
+                if (reset) {
+                    recognizer.reset();
+                    reset = false;
+                }
+
+                if (nread < 0)
+                    throw new RuntimeException("error reading audio buffer");
+
+                if (recognizer.acceptWaveForm(buffer, nread)) {
+                    final String result = recognizer.getResult();
+                    mainHandler.post(() -> listener.onResult(result));
+                } else {
+                    final String partialResult = recognizer.getPartialResult();
+                    mainHandler.post(() -> listener.onPartialResult(partialResult));
+                }
+
+                if (timeoutSamples != NO_TIMEOUT) {
+                    remainingSamples = remainingSamples - nread;
+                }
+            }
+
+            recorder.stop();
+
+            if (!paused) {
+                // If we met timeout signal that speech ended
+                if (timeoutSamples != NO_TIMEOUT && remainingSamples <= 0) {
+                    mainHandler.post(() -> listener.onTimeout());
+                } else {
+                    final String finalResult = recognizer.getFinalResult();
+                    mainHandler.post(() -> listener.onFinalResult(finalResult));
+                }
+            }
+
+        }
+    }
+}

android/lib/src/main/java/org/vosk/android/SpeechStreamService.java

@@ -0,0 +1,165 @@
+// Copyright 2019 Alpha Cephei Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package org.vosk.android;
+
+import android.os.Handler;
+import android.os.Looper;
+
+import org.vosk.Recognizer;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Service that recognizes stream audio in a  thread, passes it to a recognizer and emits
+ * recognition results. Recognition events are passed to a client using
+ * {@link RecognitionListener}
+ */
+public class SpeechStreamService {
+
+    private final Recognizer recognizer;
+    private final InputStream inputStream;
+    private final int sampleRate;
+    private final static float BUFFER_SIZE_SECONDS = 0.2f;
+    private final int bufferSize;
+
+    private Thread recognizerThread;
+
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+
+    /**
+     * Creates speech service.
+     **/
+    public SpeechStreamService(Recognizer recognizer, InputStream inputStream, float sampleRate) {
+        this.recognizer = recognizer;
+        this.sampleRate = (int) sampleRate;
+        this.inputStream = inputStream;
+        bufferSize = Math.round(this.sampleRate * BUFFER_SIZE_SECONDS * 2);
+    }
+
+    /**
+     * Starts recognition. Does nothing if recognition is active.
+     *
+     * @return true if recognition was actually started
+     */
+    public boolean start(RecognitionListener listener) {
+        if (null != recognizerThread)
+            return false;
+
+        recognizerThread = new RecognizerThread(listener);
+        recognizerThread.start();
+        return true;
+    }
+
+    /**
+     * Starts recognition. After specified timeout listening stops and the
+     * endOfSpeech signals about that. Does nothing if recognition is active.
+     * <p>
+     * timeout - timeout in milliseconds to listen.
+     *
+     * @return true if recognition was actually started
+     */
+    public boolean start(RecognitionListener listener, int timeout) {
+        if (null != recognizerThread)
+            return false;
+
+        recognizerThread = new RecognizerThread(listener, timeout);
+        recognizerThread.start();
+        return true;
+    }
+
+    /**
+     * Stops recognition. All listeners should receive final result if there is
+     * any. Does nothing if recognition is not active.
+     *
+     * @return true if recognition was actually stopped
+     */
+    public boolean stop() {
+        if (null == recognizerThread)
+            return false;
+
+        try {
+            recognizerThread.interrupt();
+            recognizerThread.join();
+        } catch (InterruptedException e) {
+            // Restore the interrupted status.
+            Thread.currentThread().interrupt();
+        }
+
+        recognizerThread = null;
+        return true;
+    }
+
+    private final class RecognizerThread extends Thread {
+
+        private int remainingSamples;
+        private final int timeoutSamples;
+        private final static int NO_TIMEOUT = -1;
+        RecognitionListener listener;
+
+        public RecognizerThread(RecognitionListener listener, int timeout) {
+            this.listener = listener;
+            if (timeout != NO_TIMEOUT)
+                this.timeoutSamples = timeout * sampleRate / 1000;
+            else
+                this.timeoutSamples = NO_TIMEOUT;
+            this.remainingSamples = this.timeoutSamples;
+        }
+
+        public RecognizerThread(RecognitionListener listener) {
+            this(listener, NO_TIMEOUT);
+        }
+
+        @Override
+        public void run() {
+
+            byte[] buffer = new byte[bufferSize];
+
+            while (!interrupted()
+                    && ((timeoutSamples == NO_TIMEOUT) || (remainingSamples > 0))) {
+                try {
+                    int nread = inputStream.read(buffer, 0, buffer.length);
+                    if (nread < 0) {
+                        break;
+                    } else {
+                        boolean isSilence = recognizer.acceptWaveForm(buffer, nread);
+                        if (isSilence) {
+                            final String result = recognizer.getResult();
+                            mainHandler.post(() -> listener.onResult(result));
+                        } else {
+                            final String partialResult = recognizer.getPartialResult();
+                            mainHandler.post(() -> listener.onPartialResult(partialResult));
+                        }
+                    }
+
+                    if (timeoutSamples != NO_TIMEOUT) {
+                        remainingSamples = remainingSamples - nread;
+                    }
+
+                } catch (IOException e) {
+                    mainHandler.post(() -> listener.onError(e));
+                }
+            }
+
+            // If we met timeout signal that speech ended
+            if (timeoutSamples != NO_TIMEOUT && remainingSamples <= 0) {
+                mainHandler.post(() -> listener.onTimeout());
+            } else {
+                final String finalResult = recognizer.getFinalResult();
+                mainHandler.post(() -> listener.onFinalResult(finalResult));
+            }
+        }
+    }
+}

android/lib/src/main/java/org/vosk/android/StorageService.java

@@ -0,0 +1,150 @@
+// Copyright 2019 Alpha Cephei Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package org.vosk.android;
+
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.os.Environment;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+import org.vosk.Model;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
+/**
+ * Provides utility methods to sync model files to external storage to allow
+ * C++ code access them. Relies on file named "uuid" to track updates.
+ */
+public class StorageService {
+
+    protected static final String TAG = StorageService.class.getSimpleName();
+
+    public interface Callback<R> {
+        void onComplete(R result);
+    }
+
+    public static void unpack(Context context, String sourcePath, final String targetPath, final Callback<Model> completeCallback, final Callback<IOException> errorCallback) {
+        Executor executor = Executors.newSingleThreadExecutor(); // change according to your requirements
+        Handler handler = new Handler(Looper.getMainLooper());
+        executor.execute(() -> {
+            try {
+                final String outputPath = sync(context, sourcePath, targetPath);
+                Model model = new Model(outputPath);
+                handler.post(() -> completeCallback.onComplete(model));
+            } catch (final IOException e) {
+                handler.post(() -> errorCallback.onComplete(e));
+            }
+        });
+    }
+
+    public static String sync(Context context, String sourcePath, String targetPath) throws IOException {
+
+        AssetManager assetManager = context.getAssets();
+
+        File externalFilesDir = context.getExternalFilesDir(null);
+        if (externalFilesDir == null) {
+            throw new IOException("cannot get external files dir, "
+                    + "external storage state is " + Environment.getExternalStorageState());
+        }
+
+        File targetDir = new File(externalFilesDir, targetPath);
+        String resultPath = new File(targetDir, sourcePath).getAbsolutePath();
+        String sourceUUID = readLine(assetManager.open(sourcePath + "/uuid"));
+        try {
+            String targetUUID = readLine(new FileInputStream(new File(targetDir, sourcePath + "/uuid")));
+            if (targetUUID.equals(sourceUUID)) return resultPath;
+        } catch (FileNotFoundException e) {
+            // ignore
+        }
+        deleteContents(targetDir);
+
+        copyAssets(assetManager, sourcePath, targetDir);
+
+        // Copy uuid
+        copyFile(assetManager, sourcePath + "/uuid", targetDir);
+
+        return resultPath;
+    }
+
+    private static String readLine(InputStream is) throws IOException {
+        return new BufferedReader(new InputStreamReader(is)).readLine();
+    }
+
+    private static boolean deleteContents(File dir) {
+        File[] files = dir.listFiles();
+        boolean success = true;
+        if (files != null) {
+            for (File file : files) {
+                if (file.isDirectory()) {
+                    success &= deleteContents(file);
+                }
+                if (!file.delete()) {
+                    success = false;
+                }
+            }
+        }
+        return success;
+    }
+
+    private static void copyAssets(AssetManager assetManager, String path, File outPath) throws IOException {
+        String[] assets = assetManager.list(path);
+        if (assets == null) {
+            return;
+        }
+        if (assets.length == 0) {
+            if (!path.endsWith("uuid"))
+                copyFile(assetManager, path, outPath);
+        } else {
+            File dir = new File(outPath, path);
+            if (!dir.exists()) {
+                Log.v(TAG, "Making directory " + dir.getAbsolutePath());
+                if (!dir.mkdirs()) {
+                    Log.v(TAG, "Failed to create directory " + dir.getAbsolutePath());
+                }
+            }
+            for (String asset : assets) {
+                copyAssets(assetManager, path + "/" + asset, outPath);
+            }
+        }
+    }
+
+    private static void copyFile(AssetManager assetManager, String fileName, File outPath) throws IOException {
+        InputStream in;
+
+        Log.v(TAG, "Copy " + fileName + " to " + outPath);
+        in = assetManager.open(fileName);
+        OutputStream out = new FileOutputStream(outPath + "/" + fileName);
+
+        byte[] buffer = new byte[4000];
+        int read;
+        while ((read = in.read(buffer)) != -1) {
+            out.write(buffer, 0, read);
+        }
+        in.close();
+        out.close();
+    }
+}

android/model-en/build.gradle

@@ -0,0 +1,43 @@
+def archiveName = "vosk-model-en"
+def pomName = "Vosk English Model"
+def pomDescription = "Small English model for Android"
+
+android {
+    namespace "org.vosk"
+    compileSdkVersion 36
+    defaultConfig {
+        minSdkVersion 21
+        targetSdkVersion 36
+        versionCode 10
+        versionName = version
+        archivesBaseName = archiveName
+    }
+    buildFeatures {
+        buildConfig = false
+    }
+    sourceSets {
+        main {
+            assets.srcDirs += "$buildDir/generated/assets"
+        }
+    }
+}
+
+tasks.register('genUUID') {
+    def uuid = UUID.randomUUID().toString()
+    def odir = file("$buildDir/generated/assets/model-en-us")
+    def ofile = file("$odir/uuid")
+    doLast {
+        mkdir odir
+        ofile.text = uuid
+    }
+}
+
+preBuild.dependsOn(genUUID)
+
+mavenPublishing {
+    coordinates("com.alphacephei", archiveName, version)
+    pom {
+        name = pomName
+        description = pomDescription
+    }
+}

android/model-en/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest>
+</manifest>

android/settings.gradle

@@ -0,0 +1 @@
+include ':lib', ':model-en'