/*---------------------------------------------------------------------------*
* android_speech_srec_Recognizer.cpp *
* *
* Copyright 2007 Nuance Communciations, 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. *
* *
*---------------------------------------------------------------------------*/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <jni.h>
#define LOG_TAG "srec_jni"
#include "utils/Log.h"
#include "passert.h"
#include "ESR_CommandLine.h"
#include "ESR_Session.h"
#include "LCHAR.h"
#include "PFile.h"
#include "PFileSystem.h"
#include "PANSIFileSystem.h"
//#include "PMemoryFileSystem.h"
#include "plog.h"
#include "pmemory.h"
#include "ptypes.h"
#include "SR_Grammar.h"
#include "SR_Recognizer.h"
#include "SR_RecognizerImpl.h"
#include "SR_RecognizerResult.h"
#include "SR_Session.h"
#include "SR_Vocabulary.h"
#include "SR_AcousticState.h"
#include "SR_Nametag.h"
#include "PStackSize.h"
//
// helper function to throw an exception
//
static void JNU_ThrowByName(JNIEnv *env, const char* name, const char* msg) {
jclass cls = env->FindClass(name);
if (cls != NULL) {
env->ThrowNew(cls, msg);
}
env->DeleteLocalRef(cls);
}
static void unimplemented(JNIEnv* env) {
JNU_ThrowByName(env, "java/lang/IllegalStateException", "unimplemented!!!");
}
static void checkEsrError(JNIEnv* env, ESR_ReturnCode esr_status) {
if (esr_status != ESR_SUCCESS) {
JNU_ThrowByName(env, "java/lang/IllegalStateException", ESR_rc2str(esr_status));
}
}
///////////////////////////////////////////////////////////////////////////
// PMem JNI implementations
///////////////////////////////////////////////////////////////////////////
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_PMemInit
(JNIEnv *env, jclass clazz) {
checkEsrError(env, PMemInit());
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_PMemShutdown
(JNIEnv *env, jclass clazz) {
checkEsrError(env, PMemShutdown());
}
//////////////////////////////////////////////////////////////////////////
// SR_Session JNI implementations
//////////////////////////////////////////////////////////////////////////
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1SessionCreate
(JNIEnv *env, jclass clazz, jstring fileName) {
// TODO: check for fileName NPE
const char* fn = env->GetStringUTFChars(fileName, 0);
checkEsrError(env, SR_SessionCreate(fn)); // TODO: can I post this before freeing the string?
env->ReleaseStringUTFChars(fileName, fn);
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1SessionDestroy
(JNIEnv *env, jclass clazz) {
checkEsrError(env, SR_SessionDestroy());
}
//////////////////////////////////////////////////////////////////////////
// SR_Recognizer JNI implementations
//////////////////////////////////////////////////////////////////////////
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerStart
(JNIEnv *env, jclass clazz, jint recognizer) {
checkEsrError(env, SR_RecognizerStart((SR_Recognizer*)recognizer));
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerStop
(JNIEnv *env, jclass clazz, jint recognizer) {
checkEsrError(env, SR_RecognizerStop((SR_Recognizer*)recognizer));
}
static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerCreate
(JNIEnv *env, jclass clazz) {
SR_Recognizer* recognizer = NULL;
// TODO: do we need to clean up the recognizer if this fails?
checkEsrError(env, SR_RecognizerCreate(&recognizer));
return (jint)recognizer;
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerDestroy
(JNIEnv *env, jclass clazz, jint recognizer) {
checkEsrError(env, SR_RecognizerDestroy((SR_Recognizer*)recognizer));
return;
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerSetup
(JNIEnv *env, jclass clazz, jint recognizer) {
checkEsrError(env, SR_RecognizerSetup((SR_Recognizer*)recognizer));
return;
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerUnsetup
(JNIEnv *env, jclass clazz, jint recognizer) {
checkEsrError(env, SR_RecognizerUnsetup((SR_Recognizer*)recognizer));
return;
}
static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsSetup
(JNIEnv *env, jclass clazz, jint recognizer) {
ESR_BOOL rtn = ESR_FALSE;
checkEsrError(env, SR_RecognizerIsSetup((SR_Recognizer*)recognizer, &rtn));
return rtn;
}
static JNIEXPORT jstring JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerGetParameter
(JNIEnv *env, jclass clazz, jint recognizer, jstring key) {
unimplemented(env);
return 0;
}
static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerGetSize_1tParameter
(JNIEnv *env, jclass clazz, jint recognizer, jstring key) {
unimplemented(env);
return 0;
}
static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerGetBoolParameter
(JNIEnv *env, jclass clazz, jint recognizer, jstring key) {
unimplemented(env);
return JNI_FALSE;
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerSetParameter
(JNIEnv *env, jclass clazz, jint recognizer, jstring key, jstring value) {
unimplemented(env);
return;
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerSetSize_1tParameter
(JNIEnv *env, jclass clazz, jint recognizer, jstring key, jint value) {
unimplemented(env);
return;
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerSetBoolParameter
(JNIEnv *env, jclass clazz, jint recognizer, jstring key , jboolean value) {
unimplemented(env);
return;
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerSetupRule
(JNIEnv *env, jclass clazz, jint recognizer, jint grammar, jstring ruleName) {
const char* rn = env->GetStringUTFChars(ruleName, 0);
checkEsrError(env, SR_RecognizerSetupRule((SR_Recognizer*)recognizer, (SR_Grammar*)grammar, rn));
env->ReleaseStringUTFChars(ruleName, rn);
}
static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerHasSetupRules
(JNIEnv *env, jclass clazz, jint recognizer) {
ESR_BOOL rtn = ESR_FALSE;
checkEsrError(env, SR_RecognizerHasSetupRules((SR_Recognizer*)recognizer, &rtn));
return rtn;
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerActivateRule
(JNIEnv *env, jclass clazz, jint recognizer, jint grammar, jstring ruleName, jint weight) {
const char* rn = env->GetStringUTFChars(ruleName, 0);
checkEsrError(env, SR_RecognizerActivateRule((SR_Recognizer*)recognizer, (SR_Grammar*)grammar, rn, weight));
env->ReleaseStringUTFChars(ruleName, rn);
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerDeactivateRule
(JNIEnv *env, jclass clazz, jint recognizer, jint grammar, jstring ruleName) {
const char* rn = env->GetStringUTFChars(ruleName, 0);
checkEsrError(env, SR_RecognizerDeactivateRule((SR_Recognizer*)recognizer, (SR_Grammar*)grammar, rn));
env->ReleaseStringUTFChars(ruleName, rn);
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerDeactivateAllRules
(JNIEnv *env, jclass clazz, jint recognizer) {
checkEsrError(env, SR_RecognizerDeactivateAllRules((SR_Recognizer*)recognizer));
}
static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsActiveRule
(JNIEnv *env, jclass clazz, jint recognizer, jint grammar, jstring ruleName) {
ESR_BOOL rtn = ESR_FALSE;
const char* rn = env->GetStringUTFChars(ruleName, 0);
checkEsrError(env, SR_RecognizerIsActiveRule((SR_Recognizer*)recognizer, (SR_Grammar*)grammar, rn, &rtn));
env->ReleaseStringUTFChars(ruleName, rn);
return rtn;
}
static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerCheckGrammarConsistency
(JNIEnv *env, jclass clazz, jint recognizer, jint grammar) {
ESR_BOOL rtn = ESR_FALSE;
checkEsrError(env, SR_RecognizerCheckGrammarConsistency((SR_Recognizer*)recognizer, (SR_Grammar*)grammar, &rtn));
return rtn;
}
static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerPutAudio
(JNIEnv *env, jclass clazz, jint recognizer, jbyteArray audio, jint offset, jint length, jboolean isLast) {
// set the length
jbyte buffer[1024];
if (length > (int)sizeof(buffer)) length = sizeof(buffer);
size_t samples = length / sizeof(asr_int16_t);
length = samples * sizeof(asr_int16_t);
// fetch data from java
env->GetByteArrayRegion(audio, offset, length, buffer);
// put the samples into the recognizer
checkEsrError(env, SR_RecognizerPutAudio((SR_Recognizer*)recognizer,
(asr_int16_t*)buffer, &samples, isLast ? ESR_TRUE : ESR_FALSE));
if (samples != length / sizeof(asr_int16_t)) {
checkEsrError(env, ESR_READ_ERROR);
return 0;
}
return samples * sizeof(asr_int16_t);
}
static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerAdvance
(JNIEnv *env, jclass clazz, jint recognizer) {
SR_RecognizerStatus status = SR_RECOGNIZER_EVENT_INVALID;
SR_RecognizerResultType type = SR_RECOGNIZER_RESULT_TYPE_INVALID;
SR_RecognizerResult* recognizerResult = NULL;
checkEsrError(env, SR_RecognizerAdvance((SR_Recognizer*)recognizer, &status, &type, &recognizerResult));
return status;
}
static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalClipping
(JNIEnv *env, jclass clazz, jint recognizer) {
ESR_BOOL rtn = ESR_FALSE;
checkEsrError(env, SR_RecognizerIsSignalClipping((SR_Recognizer*)recognizer, &rtn));
return rtn;
}
static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalDCOffset
(JNIEnv *env, jclass clazz, jint recognizer) {
ESR_BOOL rtn = ESR_FALSE;
checkEsrError(env, SR_RecognizerIsSignalDCOffset((SR_Recognizer*)recognizer, &rtn));
return rtn;
}
static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalNoisy
(JNIEnv *env, jclass clazz, jint recognizer) {
ESR_BOOL rtn = ESR_FALSE;
checkEsrError(env, SR_RecognizerIsSignalNoisy((SR_Recognizer*)recognizer, &rtn));
return rtn;
}
static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooQuiet
(JNIEnv *env, jclass clazz, jint recognizer) {
ESR_BOOL rtn = ESR_FALSE;
checkEsrError(env, SR_RecognizerIsSignalTooQuiet((SR_Recognizer*)recognizer, &rtn));
return rtn;
}
static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooFewSamples
(JNIEnv *env, jclass clazz, jint recognizer) {
ESR_BOOL rtn = ESR_FALSE;
checkEsrError(env, SR_RecognizerIsSignalTooFewSamples((SR_Recognizer*)recognizer, &rtn));
return rtn;
}
static JNIEXPORT jboolean JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooManySamples
(JNIEnv *env, jclass clazz, jint recognizer) {
ESR_BOOL rtn = ESR_FALSE;
checkEsrError(env, SR_RecognizerIsSignalTooManySamples((SR_Recognizer*)recognizer, &rtn));
return rtn;
}
//////////////////////////////////////////////////////////////////////////
// SR_AcousticState JNI implementations
//////////////////////////////////////////////////////////////////////////
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1AcousticStateReset
(JNIEnv *env, jclass clazz, jint recognizer) {
checkEsrError(env, SR_AcousticStateReset((SR_Recognizer*)recognizer));
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1AcousticStateSet
(JNIEnv *env, jclass clazz, jint recognizer, jstring state) {
const char* st = env->GetStringUTFChars(state, 0);
checkEsrError(env, SR_AcousticStateSet((SR_Recognizer*)recognizer, st));
env->ReleaseStringUTFChars(state, st);
}
static JNIEXPORT jstring JNICALL Java_android_speech_srec_Recognizer_SR_1AcousticStateGet
(JNIEnv *env, jclass clazz, jint recognizer) {
char rtn[1000];
size_t rtnLength = sizeof(rtn) - 1;
ESR_ReturnCode esr_status = SR_AcousticStateGet((SR_Recognizer*)recognizer, rtn, &rtnLength);
if (esr_status) {
checkEsrError(env, esr_status);
return NULL;
}
rtn[rtnLength] = 0;
return env->NewStringUTF(rtn);
}
//////////////////////////////////////////////////////////////////////////
// SR_Grammar JNI implementations
//////////////////////////////////////////////////////////////////////////
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarCompile
(JNIEnv *env, jclass clazz, jint grammar) {
checkEsrError(env, SR_GrammarCompile((SR_Grammar*)grammar));
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarAddWordToSlot
(JNIEnv *env, jclass clazz, jint grammar, jstring slot, jstring word, jstring pronunciation, jint weight, jstring tag) {
const char* sl = 0;
const char* wo = 0;
const char* pr = 0;
const char* ta = 0;
if ((sl = env->GetStringUTFChars(slot, 0)) &&
(wo = env->GetStringUTFChars(word, 0)) &&
(!pronunciation || (pr = env->GetStringUTFChars(pronunciation, 0))) &&
(ta = env->GetStringUTFChars(tag, 0))) {
checkEsrError(env, SR_GrammarAddWordToSlot((SR_Grammar*)grammar, sl, wo, pr, weight, ta));
}
if (ta) env->ReleaseStringUTFChars(tag, ta);
if (pr) env->ReleaseStringUTFChars(pronunciation, pr);
if (wo) env->ReleaseStringUTFChars(word, wo);
if (sl) env->ReleaseStringUTFChars(slot, sl);
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarResetAllSlots
(JNIEnv *env, jclass clazz, jint grammar) {
checkEsrError(env, SR_GrammarResetAllSlots((SR_Grammar*)grammar));
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarSetupVocabulary
(JNIEnv *env, jclass clazz, jint grammar, jint vocabulary) {
checkEsrError(env, SR_GrammarSetupVocabulary((SR_Grammar*)grammar, (SR_Vocabulary*)vocabulary));
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarSetupRecognizer
(JNIEnv *env, jclass clazz, jint grammar, jint recognizer) {
checkEsrError(env, SR_GrammarSetupRecognizer((SR_Grammar*)grammar, (SR_Recognizer*)recognizer));
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarUnsetupRecognizer
(JNIEnv *env, jclass clazz, jint grammar) {
checkEsrError(env, SR_GrammarUnsetupRecognizer((SR_Grammar*)grammar));
}
static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarCreate
(JNIEnv *env, jclass clazz) {
SR_Grammar* grammar = 0;
checkEsrError(env, SR_GrammarCreate(&grammar));
return (jint)grammar;
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarDestroy
(JNIEnv *env, jclass clazz, jint grammar) {
checkEsrError(env, SR_GrammarDestroy((SR_Grammar*)grammar));
}
static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarLoad
(JNIEnv *env, jclass clazz, jstring fileName) {
// TODO: check for fileName NPE
SR_Grammar* grammar = 0;
const char* fn = env->GetStringUTFChars(fileName, 0);
checkEsrError(env, SR_GrammarLoad(fn, &grammar));
env->ReleaseStringUTFChars(fileName, fn);
return (jint)grammar;
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarSave
(JNIEnv *env, jclass clazz, jint grammar, jstring fileName) {
const char* fn = env->GetStringUTFChars(fileName, 0);
checkEsrError(env, SR_GrammarSave((SR_Grammar*)grammar, fn));
env->ReleaseStringUTFChars(fileName, fn);
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarAllowOnly
(JNIEnv *env, jclass clazz, jint grammar, jstring transcription) {
const char* tr = env->GetStringUTFChars(transcription, 0);
checkEsrError(env, SR_GrammarSave((SR_Grammar*)grammar, tr));
env->ReleaseStringUTFChars(transcription, tr);
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1GrammarAllowAll
(JNIEnv *env, jclass clazz, jint grammar) {
checkEsrError(env, SR_GrammarAllowAll((SR_Grammar*)grammar));
}
//////////////////////////////////////////////////////////////////////////
// SR_Vocabulary JNI implementations
//////////////////////////////////////////////////////////////////////////
static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1VocabularyLoad
(JNIEnv *env, jclass clazz) {
char filename[P_PATH_MAX];
size_t flen = sizeof(filename) - 1;
checkEsrError(env, ESR_SessionGetLCHAR ( L("cmdline.vocabulary"), filename, &flen ));
filename[sizeof(filename) - 1] = 0;
// TODO: do we need to clean up the recognizer if this fails?
SR_Vocabulary* vocabulary = NULL;
checkEsrError(env, SR_VocabularyLoad(filename, &vocabulary));
return (jint)vocabulary;
}
static JNIEXPORT void JNICALL Java_android_speech_srec_Recognizer_SR_1VocabularyDestroy
(JNIEnv *env, jclass clazz, jint vocabulary) {
// TODO: do we need to clean up the recognizer if this fails?
checkEsrError(env, SR_VocabularyDestroy((SR_Vocabulary*)vocabulary));
}
static JNIEXPORT jstring JNICALL Java_android_speech_srec_Recognizer_SR_1VocabularyGetPronunciation
(JNIEnv *env, jclass clazz, jint vocabulary, jstring word) {
char rtn[1000];
size_t rtnLength = sizeof(rtn) - 1;
const char* wo = env->GetStringUTFChars(word, 0);
ESR_ReturnCode esr_status = SR_VocabularyGetPronunciation((SR_Vocabulary*)vocabulary, wo, rtn, &rtnLength);
env->ReleaseStringUTFChars(word, wo);
if (esr_status) {
checkEsrError(env, esr_status);
return NULL;
}
rtn[rtnLength] = 0;
return env->NewStringUTF(rtn);
}
//////////////////////////////////////////////////////////////////////////
// SR_RecognizerResult JNI implementations
//////////////////////////////////////////////////////////////////////////
static JNIEXPORT jbyteArray JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetWaveform
(JNIEnv *env, jclass clazz, jint recognizer) {
unimplemented(env);
return 0;
}
static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetSize
(JNIEnv *env, jclass clazz, jint recognizer) {
size_t size = 0;
checkEsrError(env, SR_RecognizerResultGetSize(((SR_RecognizerImpl*)recognizer)->result, &size));
return size;
}
static JNIEXPORT jint JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetKeyCount
(JNIEnv *env, jclass clazz, jint recognizer, jint nbest) {
size_t size = 0;
checkEsrError(env, SR_RecognizerResultGetKeyCount(((SR_RecognizerImpl*)recognizer)->result, nbest, &size));
return size;
}
static JNIEXPORT jobjectArray JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetKeyList
(JNIEnv *env, jclass clazz, jint recognizer, jint nbest) {
// fetch list
LCHAR* list[200];
size_t listSize = sizeof(list) / sizeof(list[0]);
ESR_ReturnCode esr_status = SR_RecognizerResultGetKeyList(((SR_RecognizerImpl*)recognizer)->result, nbest, list, &listSize);
if (esr_status) {
checkEsrError(env, esr_status);
return NULL;
}
// create String[] of keys
jclass stringClass = env->FindClass("java/lang/String");
if (!stringClass) return NULL;
jobjectArray array = env->NewObjectArray(listSize, stringClass, NULL);
if (!array) return NULL;
// fill it
for (size_t i = 0; i < listSize; i++) {
// generate new String for key
jstring key = env->NewStringUTF(list[i]);
if (!key) return NULL;
// set the array
env->SetObjectArrayElement(array, i, key);
env->DeleteLocalRef(key);
}
return array;
}
static JNIEXPORT jstring JNICALL Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetValue
(JNIEnv *env, jclass clazz, jint recognizer, jint nbest, jstring key) {
char rtn[1000];
size_t rtnLength = sizeof(rtn) - 1;
const char* ke = env->GetStringUTFChars(key, 0);
ESR_ReturnCode esr_status = SR_RecognizerResultGetValue(((SR_RecognizerImpl*)recognizer)->result, nbest, ke, rtn, &rtnLength);
env->ReleaseStringUTFChars(key, ke);
if (esr_status) {
checkEsrError(env, esr_status);
return NULL;
}
rtn[rtnLength] = 0;
return env->NewStringUTF(rtn);
}
/*
* Table of methods associated with a single class.
*/
static JNINativeMethod gMethods[] = {
/* name, signature, funcPtr */
// PMem
{"PMemInit", "()V", (void*)Java_android_speech_srec_Recognizer_PMemInit},
{"PMemShutdown", "()V", (void*)Java_android_speech_srec_Recognizer_PMemShutdown},
// SR_Session
{"SR_SessionCreate", "(Ljava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1SessionCreate},
{"SR_SessionDestroy", "()V", (void*)Java_android_speech_srec_Recognizer_SR_1SessionDestroy},
// SR_Recognizer
{"SR_RecognizerStart", "(I)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerStart},
{"SR_RecognizerStop", "(I)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerStop},
{"SR_RecognizerCreate", "()I", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerCreate},
{"SR_RecognizerDestroy", "(I)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerDestroy},
{"SR_RecognizerSetup", "(I)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetup},
{"SR_RecognizerUnsetup", "(I)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerUnsetup},
{"SR_RecognizerIsSetup", "(I)Z", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSetup},
{"SR_RecognizerGetParameter", "(ILjava/lang/String;)Ljava/lang/String;", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerGetParameter},
{"SR_RecognizerGetSize_tParameter", "(ILjava/lang/String;)I", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerGetSize_1tParameter},
{"SR_RecognizerGetBoolParameter", "(ILjava/lang/String;)Z", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerGetBoolParameter},
{"SR_RecognizerSetParameter", "(ILjava/lang/String;Ljava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetParameter},
{"SR_RecognizerSetSize_tParameter", "(ILjava/lang/String;I)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetSize_1tParameter},
{"SR_RecognizerSetBoolParameter", "(ILjava/lang/String;Z)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetBoolParameter},
{"SR_RecognizerSetupRule", "(IILjava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerSetupRule},
{"SR_RecognizerHasSetupRules", "(I)Z", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerHasSetupRules},
{"SR_RecognizerActivateRule", "(IILjava/lang/String;I)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerActivateRule},
{"SR_RecognizerDeactivateRule", "(IILjava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerDeactivateRule},
{"SR_RecognizerDeactivateAllRules", "(I)V", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerDeactivateAllRules},
{"SR_RecognizerIsActiveRule", "(IILjava/lang/String;)Z", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsActiveRule},
{"SR_RecognizerCheckGrammarConsistency", "(II)Z", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerCheckGrammarConsistency},
{"SR_RecognizerPutAudio", "(I[BIIZ)I", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerPutAudio},
{"SR_RecognizerAdvance", "(I)I", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerAdvance},
{"SR_RecognizerIsSignalClipping", "(I)Z", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalClipping},
{"SR_RecognizerIsSignalDCOffset", "(I)Z", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalDCOffset},
{"SR_RecognizerIsSignalNoisy", "(I)Z", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalNoisy},
{"SR_RecognizerIsSignalTooQuiet", "(I)Z", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooQuiet},
{"SR_RecognizerIsSignalTooFewSamples", "(I)Z", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooFewSamples},
{"SR_RecognizerIsSignalTooManySamples", "(I)Z", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerIsSignalTooManySamples},
// SR_AcousticState
{"SR_AcousticStateReset", "(I)V", (void*)Java_android_speech_srec_Recognizer_SR_1AcousticStateReset},
{"SR_AcousticStateSet", "(ILjava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1AcousticStateSet},
{"SR_AcousticStateGet", "(I)Ljava/lang/String;", (void*)Java_android_speech_srec_Recognizer_SR_1AcousticStateGet},
// SR_Grammar
{"SR_GrammarCompile", "(I)V", (void*)Java_android_speech_srec_Recognizer_SR_1GrammarCompile},
{"SR_GrammarAddWordToSlot", "(ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1GrammarAddWordToSlot},
{"SR_GrammarResetAllSlots", "(I)V", (void*)Java_android_speech_srec_Recognizer_SR_1GrammarResetAllSlots},
{"SR_GrammarSetupVocabulary", "(II)V", (void*)Java_android_speech_srec_Recognizer_SR_1GrammarSetupVocabulary},
{"SR_GrammarSetupRecognizer", "(II)V", (void*)Java_android_speech_srec_Recognizer_SR_1GrammarSetupRecognizer},
{"SR_GrammarUnsetupRecognizer", "(I)V", (void*)Java_android_speech_srec_Recognizer_SR_1GrammarUnsetupRecognizer},
{"SR_GrammarCreate", "()I", (void*)Java_android_speech_srec_Recognizer_SR_1GrammarCreate},
{"SR_GrammarDestroy", "(I)V", (void*)Java_android_speech_srec_Recognizer_SR_1GrammarDestroy},
{"SR_GrammarLoad", "(Ljava/lang/String;)I", (void*)Java_android_speech_srec_Recognizer_SR_1GrammarLoad},
{"SR_GrammarSave", "(ILjava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1GrammarSave},
{"SR_GrammarAllowOnly", "(ILjava/lang/String;)V", (void*)Java_android_speech_srec_Recognizer_SR_1GrammarAllowOnly},
{"SR_GrammarAllowAll", "(I)V", (void*)Java_android_speech_srec_Recognizer_SR_1GrammarAllowAll},
// SR_Vocabulary
{"SR_VocabularyLoad", "()I", (void*)Java_android_speech_srec_Recognizer_SR_1VocabularyLoad},
{"SR_VocabularyDestroy", "(I)V", (void*)Java_android_speech_srec_Recognizer_SR_1VocabularyDestroy},
{"SR_VocabularyGetPronunciation", "(ILjava/lang/String;)Ljava/lang/String;", (void*)Java_android_speech_srec_Recognizer_SR_1VocabularyGetPronunciation},
// SR_RecognizerResult
{"SR_RecognizerResultGetWaveform", "(I)[B", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetWaveform},
{"SR_RecognizerResultGetSize", "(I)I", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetSize},
{"SR_RecognizerResultGetKeyCount", "(II)I", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetKeyCount},
{"SR_RecognizerResultGetKeyList", "(II)[Ljava/lang/String;", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetKeyList},
{"SR_RecognizerResultGetValue", "(IILjava/lang/String;)Ljava/lang/String;", (void*)Java_android_speech_srec_Recognizer_SR_1RecognizerResultGetValue},
};
/*
* Returns the JNI version on success, -1 on failure.
*/
jint register_android_speech_srec_Recognizer(JavaVM* vm, void* reserved)
{
JNIEnv* env = NULL;
jclass clazz = NULL;
const char* className = "android/speech/srec/Recognizer";
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
ALOGE("ERROR: GetEnv failed\n");
return -1;
}
assert(env != NULL);
clazz = env->FindClass(className);
if (clazz == NULL) {
ALOGE("Native registration unable to find class '%s'\n", className);
return -1;
}
if (env->RegisterNatives(clazz, gMethods,
sizeof(gMethods) / sizeof(gMethods[0])) < 0) {
ALOGE("RegisterNatives failed for '%s'\n", className);
return -1;
}
/* success -- return valid version number */
return JNI_VERSION_1_4;
}
extern jint register_android_speech_srec_MicrophoneInputStream(JavaVM* vm, void* reserved);
jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
if (register_android_speech_srec_MicrophoneInputStream(vm, reserved) != JNI_VERSION_1_4 ||
register_android_speech_srec_Recognizer(vm, reserved) != JNI_VERSION_1_4) return -1;
return JNI_VERSION_1_4;
}