User Tools

Site Tools


tutorialandroid

Pocketsphinx on Android

Introduction

Current tutorial describes a most recent verison pocketsphinx-android-demo-5prealpha which is available in downloads. You can also checkout it from subversion or from github.

PocketSphinx Android demo

To try the demo the best thing would be to use Android Studio. You can download Android Studio IDE and sdk from the official page

Building and running from Android Studio

You can obtain the demo in a multiple ways:

1) Select to checkout project from VCS, select github and enter the project URL http://github.com/cmusphinx/pocketsphinx-android-demo

2) Download the package from distribution and import as an existing Android Studio project.

Once project will be set, IDE will update and download all dependencies automatically, you can just run the project.

After start recognizer will take some time to initialize, then it will wait for a keyword “oh mighty computer”. Once keyword is detected, it will ask you to select the demo - “digits”, “weather” or “phones”. The digits demo recognizes digits from 0 to 9, the weather demo recognizes weather forecasts and “phones” demo demonstrates phonetic recognition.

To try it import this project into IDE and run as usual, check logcat for details if something doesn't work.

Building and running from Eclipse

We do not support Eclipse project anymore, please consider SDK upgrade.

Building and running from command-line

You can also build with gradle build system.

  1. Attach your physical device or setup a virtual device.
  2. Create a file local.properties to point to sdk folder:
    sdk.dir = /home/user/android/sdk
  3. Run
    gradle installDebug

    It will build and install the application on the device.

  4. Manually run the application from the device application menu.

Using pocketsphinx-android

Referencing the library in Android project

Library is distributed as architecture-independent pocketsphinx-android-5prealpha-nolib.jar and binary .so files for different hardware architectures.

In Android Studio you need to place jar file in app/libs folder and jni .so files into app/src/main/jniLibs folder.

Including resource files

The standard way to ship resource files with your application in Android is to put them in assets/ directory of your project. But in order to make them available for pocketsphinx files should have physical path, as long as they are within .apk they don't have one. Assets class from pocketsphinx-android provides a method to automatically copy asset files to external storage of the target device. edu.cmu.pocketsphinx.Assets#syncAssets synchronizes resources reading items from assets.lst file located on the top assets/. Before copying it matches MD5 checksums of an asset and a file on external storage with the same name if such exists. It only does actualy copying if there is incomplete information (no file on external storage, no any of two .md5 files) or there is hash mismatch. PocketSphinxAndroidDemo contains ant script that generates assets.lst as well as .md5 files, look for assets.xml.

Please note that if ant build script doesn't run properly in your build process, assets might be out of sync. Make sure that script runs or create md5 files and assets.lst yourself.

To integrate assets sync in your application do the following

  1. Include app/asset.xml build file into your application
  2. Edit build.gradle build file to run assets.xml:
      ant.importBuild 'assets.xml'
      preBuild.dependsOn(list, checksum)
      clean.dependsOn(clean_assets)

That should do the trick

Sample application

The classes and methods of pocketsphinx-android were designed to resemble the same workflow used in pocketsphinx, except that basic data structures organized into classes and functions working with them are turned into methods of the corresponding classes. So if you are familiar with pocketsphinx you should feel comfortable with pocketsphinx-android too.

SpeechRecognizer is the main class to access decoder functionality. It is created with the help of SpeechRecognizerSetup builder. SpeechRecognizerBuilder allows to configure main properties as well as other parameters of teh decoder. The parameters keys and values are the same as those are passed in command-line to pocketsphinx binaries. Read more about tweaking pocketsphinx performance.

        recognizer = defaultSetup()
                .setAcousticModel(new File(assetsDir, "en-us-ptm"))
                .setDictionary(new File(assetsDir, "cmudict-en-us.dict"))
                .setRawLogDir(assetsDir).setKeywordThreshold(1e-20f)
                .getRecognizer();
        recognizer.addListener(this);

Decoder configuration is lengthy process that contains IO operation, so it's recommended to run in inside async task.

Decoder supports multiple named searches which you can switch in runtime

        // Create keyword-activation search.
        recognizer.addKeyphraseSearch(KWS_SEARCH, KEYPHRASE);
        // Create grammar-based searches.
        File menuGrammar = new File(assetsDir, "menu.gram");
        recognizer.addGrammarSearch(MENU_SEARCH, menuGrammar);
        // Next search for digits
        File digitsGrammar = new File(assetsDir, "digits.gram");
        recognizer.addGrammarSearch(DIGITS_SEARCH, digitsGrammar);
        // Create language model search.
        File languageModel = new File(assetsDir, "weather.dmp");
        recognizer.addNgramSearch(FORECAST_SEARCH, languageModel);

Once you setup the decoder and add all the searches you can start recognition with

recognizer.startListening(searchName);

You will get notified on speech end event in onEndOfSpeech callback of the recognizer listener. Then you could call recognizer.stop or recognizer.cancel(). Latter will cancel the recognition, former will cause the final result be passed you in onResult callback.

During the recognition you will get partial results in onPartialResult callback.

You can also access other Pocketsphinx method wrapped with Java classes in swig, check for details Decoder, Hypothesis, Segment and NBest classes.

Building pocketsphinx-android

Pocketsphinx is provided with prebuilt binaries and it's not easy to compile it on various platforms. You shouldn't build it unless you understand what you are doing. Use prebuilt binaries instead.

Build dependencies

Building steps

You need to checkout sphinxbase, pocketsphinx and pocketsphinx-android and put them in the same folder.

Root folder
 \_pocketsphinx
 \_sphinxbase
 \_pocketsphinx-android

Older versions might be incompatible with the latest pocketsphinx-android, so you need to make sure you are using latest versions. You can use the following command to checkout from repository:

      svn checkout svn://svn.code.sf.net/p/cmusphinx/code/trunk/sphinxbase
      svn checkout svn://svn.code.sf.net/p/cmusphinx/code/trunk/pocketsphinx
      svn checkout svn://svn.code.sf.net/p/cmusphinx/code/trunk/pocketsphinx-android

After arragement of the files you need to update the file gradle.properties in the project root and define the following properties:

  • sdkDir - path to Android SDK
  • ndkDir - path to Android NDK
  • sdkVersion - Android API version
  • ndkExt - extension for ndk-build script (empty on Linux, .cmd on Windows)

For example:

sdkDir=/home/user/local/adt-bundle-linux-x86_64-20140321/sdk
ndkDir=/home/user/local/android-ndk-r9d
sdkVersion=19

After everything is set, run gradle build. It will create pocketsphinx-android-5prealpha-nolib.jar in build/libs. It will also create .so files in libs folder

tutorialandroid.txt · Last modified: 2015/03/27 21:30 by admin