Home | History | Annotate | Download | only in jni
      1 /*
      2 **
      3 ** Copyright 2014, The Android Open Source Project
      4 **
      5 ** Licensed under the Apache License, Version 2.0 (the "License");
      6 ** you may not use this file except in compliance with the License.
      7 ** You may obtain a copy of the License at
      8 **
      9 **     http://www.apache.org/licenses/LICENSE-2.0
     10 **
     11 ** Unless required by applicable law or agreed to in writing, software
     12 ** distributed under the License is distributed on an "AS IS" BASIS,
     13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14 ** See the License for the specific language governing permissions and
     15 ** limitations under the License.
     16 */
     17 
     18 //#define LOG_NDEBUG 0
     19 #define LOG_TAG "SoundTrigger-JNI"
     20 #include <utils/Log.h>
     21 
     22 #include "jni.h"
     23 #include "JNIHelp.h"
     24 #include "core_jni_helpers.h"
     25 #include <system/sound_trigger.h>
     26 #include <soundtrigger/SoundTriggerCallback.h>
     27 #include <soundtrigger/SoundTrigger.h>
     28 #include <utils/RefBase.h>
     29 #include <utils/Vector.h>
     30 #include <binder/IMemory.h>
     31 #include <binder/MemoryDealer.h>
     32 #include "android_media_AudioFormat.h"
     33 
     34 using namespace android;
     35 
     36 static jclass gArrayListClass;
     37 static struct {
     38     jmethodID    add;
     39 } gArrayListMethods;
     40 
     41 static jclass gUUIDClass;
     42 static struct {
     43     jmethodID    toString;
     44 } gUUIDMethods;
     45 
     46 static const char* const kSoundTriggerClassPathName = "android/hardware/soundtrigger/SoundTrigger";
     47 static jclass gSoundTriggerClass;
     48 
     49 static const char* const kModuleClassPathName = "android/hardware/soundtrigger/SoundTriggerModule";
     50 static jclass gModuleClass;
     51 static struct {
     52     jfieldID    mNativeContext;
     53     jfieldID    mId;
     54 } gModuleFields;
     55 static jmethodID   gPostEventFromNative;
     56 
     57 static const char* const kModulePropertiesClassPathName =
     58                                      "android/hardware/soundtrigger/SoundTrigger$ModuleProperties";
     59 static jclass gModulePropertiesClass;
     60 static jmethodID   gModulePropertiesCstor;
     61 
     62 static const char* const kSoundModelClassPathName =
     63                                      "android/hardware/soundtrigger/SoundTrigger$SoundModel";
     64 static jclass gSoundModelClass;
     65 static struct {
     66     jfieldID    uuid;
     67     jfieldID    vendorUuid;
     68     jfieldID    data;
     69 } gSoundModelFields;
     70 
     71 static const char* const kGenericSoundModelClassPathName =
     72                                      "android/hardware/soundtrigger/SoundTrigger$GenericSoundModel";
     73 static jclass gGenericSoundModelClass;
     74 
     75 static const char* const kKeyphraseClassPathName =
     76                                      "android/hardware/soundtrigger/SoundTrigger$Keyphrase";
     77 static jclass gKeyphraseClass;
     78 static struct {
     79     jfieldID id;
     80     jfieldID recognitionModes;
     81     jfieldID locale;
     82     jfieldID text;
     83     jfieldID users;
     84 } gKeyphraseFields;
     85 
     86 static const char* const kKeyphraseSoundModelClassPathName =
     87                                  "android/hardware/soundtrigger/SoundTrigger$KeyphraseSoundModel";
     88 static jclass gKeyphraseSoundModelClass;
     89 static struct {
     90     jfieldID    keyphrases;
     91 } gKeyphraseSoundModelFields;
     92 
     93 static const char* const kRecognitionConfigClassPathName =
     94                                      "android/hardware/soundtrigger/SoundTrigger$RecognitionConfig";
     95 static jclass gRecognitionConfigClass;
     96 static struct {
     97     jfieldID captureRequested;
     98     jfieldID keyphrases;
     99     jfieldID data;
    100 } gRecognitionConfigFields;
    101 
    102 static const char* const kRecognitionEventClassPathName =
    103                                      "android/hardware/soundtrigger/SoundTrigger$RecognitionEvent";
    104 static jclass gRecognitionEventClass;
    105 static jmethodID   gRecognitionEventCstor;
    106 
    107 static const char* const kKeyphraseRecognitionEventClassPathName =
    108                              "android/hardware/soundtrigger/SoundTrigger$KeyphraseRecognitionEvent";
    109 static jclass gKeyphraseRecognitionEventClass;
    110 static jmethodID   gKeyphraseRecognitionEventCstor;
    111 
    112 static const char* const kGenericRecognitionEventClassPathName =
    113                              "android/hardware/soundtrigger/SoundTrigger$GenericRecognitionEvent";
    114 static jclass gGenericRecognitionEventClass;
    115 static jmethodID   gGenericRecognitionEventCstor;
    116 
    117 static const char* const kKeyphraseRecognitionExtraClassPathName =
    118                              "android/hardware/soundtrigger/SoundTrigger$KeyphraseRecognitionExtra";
    119 static jclass gKeyphraseRecognitionExtraClass;
    120 static jmethodID   gKeyphraseRecognitionExtraCstor;
    121 static struct {
    122     jfieldID id;
    123     jfieldID recognitionModes;
    124     jfieldID coarseConfidenceLevel;
    125     jfieldID confidenceLevels;
    126 } gKeyphraseRecognitionExtraFields;
    127 
    128 static const char* const kConfidenceLevelClassPathName =
    129                              "android/hardware/soundtrigger/SoundTrigger$ConfidenceLevel";
    130 static jclass gConfidenceLevelClass;
    131 static jmethodID   gConfidenceLevelCstor;
    132 static struct {
    133     jfieldID userId;
    134     jfieldID confidenceLevel;
    135 } gConfidenceLevelFields;
    136 
    137 static const char* const kAudioFormatClassPathName =
    138                              "android/media/AudioFormat";
    139 static jclass gAudioFormatClass;
    140 static jmethodID gAudioFormatCstor;
    141 
    142 static const char* const kSoundModelEventClassPathName =
    143                                      "android/hardware/soundtrigger/SoundTrigger$SoundModelEvent";
    144 static jclass gSoundModelEventClass;
    145 static jmethodID   gSoundModelEventCstor;
    146 
    147 static Mutex gLock;
    148 
    149 enum {
    150     SOUNDTRIGGER_STATUS_OK = 0,
    151     SOUNDTRIGGER_STATUS_ERROR = INT_MIN,
    152     SOUNDTRIGGER_PERMISSION_DENIED = -1,
    153     SOUNDTRIGGER_STATUS_NO_INIT = -19,
    154     SOUNDTRIGGER_STATUS_BAD_VALUE = -22,
    155     SOUNDTRIGGER_STATUS_DEAD_OBJECT = -32,
    156     SOUNDTRIGGER_INVALID_OPERATION = -38,
    157 };
    158 
    159 enum  {
    160     SOUNDTRIGGER_EVENT_RECOGNITION = 1,
    161     SOUNDTRIGGER_EVENT_SERVICE_DIED = 2,
    162     SOUNDTRIGGER_EVENT_SOUNDMODEL = 3,
    163     SOUNDTRIGGER_EVENT_SERVICE_STATE_CHANGE = 4,
    164 };
    165 
    166 // ----------------------------------------------------------------------------
    167 // ref-counted object for callbacks
    168 class JNISoundTriggerCallback: public SoundTriggerCallback
    169 {
    170 public:
    171     JNISoundTriggerCallback(JNIEnv* env, jobject thiz, jobject weak_thiz);
    172     ~JNISoundTriggerCallback();
    173 
    174     virtual void onRecognitionEvent(struct sound_trigger_recognition_event *event);
    175     virtual void onSoundModelEvent(struct sound_trigger_model_event *event);
    176     virtual void onServiceStateChange(sound_trigger_service_state_t state);
    177     virtual void onServiceDied();
    178 
    179 private:
    180     jclass      mClass;     // Reference to SoundTrigger class
    181     jobject     mObject;    // Weak ref to SoundTrigger Java object to call on
    182 };
    183 
    184 JNISoundTriggerCallback::JNISoundTriggerCallback(JNIEnv* env, jobject thiz, jobject weak_thiz)
    185 {
    186 
    187     // Hold onto the SoundTriggerModule class for use in calling the static method
    188     // that posts events to the application thread.
    189     jclass clazz = env->GetObjectClass(thiz);
    190     if (clazz == NULL) {
    191         ALOGE("Can't find class %s", kModuleClassPathName);
    192         return;
    193     }
    194     mClass = (jclass)env->NewGlobalRef(clazz);
    195 
    196     // We use a weak reference so the SoundTriggerModule object can be garbage collected.
    197     // The reference is only used as a proxy for callbacks.
    198     mObject  = env->NewGlobalRef(weak_thiz);
    199 }
    200 
    201 JNISoundTriggerCallback::~JNISoundTriggerCallback()
    202 {
    203     // remove global references
    204     JNIEnv *env = AndroidRuntime::getJNIEnv();
    205     env->DeleteGlobalRef(mObject);
    206     env->DeleteGlobalRef(mClass);
    207 }
    208 
    209 void JNISoundTriggerCallback::onRecognitionEvent(struct sound_trigger_recognition_event *event)
    210 {
    211     JNIEnv *env = AndroidRuntime::getJNIEnv();
    212     jobject jEvent = NULL;
    213     jbyteArray jData = NULL;
    214 
    215     if (event->data_size) {
    216         jData = env->NewByteArray(event->data_size);
    217         jbyte *nData = env->GetByteArrayElements(jData, NULL);
    218         memcpy(nData, (char *)event + event->data_offset, event->data_size);
    219         env->ReleaseByteArrayElements(jData, nData, 0);
    220     }
    221 
    222     jobject jAudioFormat = NULL;
    223     if (event->trigger_in_data || event->capture_available) {
    224         jAudioFormat = env->NewObject(gAudioFormatClass,
    225                                     gAudioFormatCstor,
    226                                     audioFormatFromNative(event->audio_config.format),
    227                                     event->audio_config.sample_rate,
    228                                     inChannelMaskFromNative(event->audio_config.channel_mask));
    229 
    230     }
    231     if (event->type == SOUND_MODEL_TYPE_KEYPHRASE) {
    232         struct sound_trigger_phrase_recognition_event *phraseEvent =
    233                 (struct sound_trigger_phrase_recognition_event *)event;
    234 
    235         jobjectArray jExtras = env->NewObjectArray(phraseEvent->num_phrases,
    236                                                   gKeyphraseRecognitionExtraClass, NULL);
    237         if (jExtras == NULL) {
    238             return;
    239         }
    240 
    241         for (size_t i = 0; i < phraseEvent->num_phrases; i++) {
    242             jobjectArray jConfidenceLevels = env->NewObjectArray(
    243                                                         phraseEvent->phrase_extras[i].num_levels,
    244                                                         gConfidenceLevelClass, NULL);
    245 
    246             if (jConfidenceLevels == NULL) {
    247                 return;
    248             }
    249             for (size_t j = 0; j < phraseEvent->phrase_extras[i].num_levels; j++) {
    250                 jobject jConfidenceLevel = env->NewObject(gConfidenceLevelClass,
    251                                                   gConfidenceLevelCstor,
    252                                                   phraseEvent->phrase_extras[i].levels[j].user_id,
    253                                                   phraseEvent->phrase_extras[i].levels[j].level);
    254                 env->SetObjectArrayElement(jConfidenceLevels, j, jConfidenceLevel);
    255                 env->DeleteLocalRef(jConfidenceLevel);
    256             }
    257 
    258             jobject jNewExtra = env->NewObject(gKeyphraseRecognitionExtraClass,
    259                                                gKeyphraseRecognitionExtraCstor,
    260                                                phraseEvent->phrase_extras[i].id,
    261                                                phraseEvent->phrase_extras[i].recognition_modes,
    262                                                phraseEvent->phrase_extras[i].confidence_level,
    263                                                jConfidenceLevels);
    264 
    265             if (jNewExtra == NULL) {
    266                 return;
    267             }
    268             env->SetObjectArrayElement(jExtras, i, jNewExtra);
    269             env->DeleteLocalRef(jNewExtra);
    270             env->DeleteLocalRef(jConfidenceLevels);
    271         }
    272         jEvent = env->NewObject(gKeyphraseRecognitionEventClass, gKeyphraseRecognitionEventCstor,
    273                                 event->status, event->model, event->capture_available,
    274                                 event->capture_session, event->capture_delay_ms,
    275                                 event->capture_preamble_ms, event->trigger_in_data,
    276                                 jAudioFormat, jData, jExtras);
    277         env->DeleteLocalRef(jExtras);
    278     } else if (event->type == SOUND_MODEL_TYPE_GENERIC) {
    279         jEvent = env->NewObject(gGenericRecognitionEventClass, gGenericRecognitionEventCstor,
    280                                 event->status, event->model, event->capture_available,
    281                                 event->capture_session, event->capture_delay_ms,
    282                                 event->capture_preamble_ms, event->trigger_in_data,
    283                                 jAudioFormat, jData);
    284     } else {
    285         jEvent = env->NewObject(gRecognitionEventClass, gRecognitionEventCstor,
    286                                 event->status, event->model, event->capture_available,
    287                                 event->capture_session, event->capture_delay_ms,
    288                                 event->capture_preamble_ms, event->trigger_in_data,
    289                                 jAudioFormat, jData);
    290     }
    291 
    292     if (jAudioFormat != NULL) {
    293         env->DeleteLocalRef(jAudioFormat);
    294     }
    295     if (jData != NULL) {
    296         env->DeleteLocalRef(jData);
    297     }
    298 
    299     env->CallStaticVoidMethod(mClass, gPostEventFromNative, mObject,
    300                               SOUNDTRIGGER_EVENT_RECOGNITION, 0, 0, jEvent);
    301 
    302     env->DeleteLocalRef(jEvent);
    303     if (env->ExceptionCheck()) {
    304         ALOGW("An exception occurred while notifying an event.");
    305         env->ExceptionClear();
    306     }
    307 }
    308 
    309 void JNISoundTriggerCallback::onSoundModelEvent(struct sound_trigger_model_event *event)
    310 {
    311     JNIEnv *env = AndroidRuntime::getJNIEnv();
    312     jobject jEvent = NULL;
    313     jbyteArray jData = NULL;
    314 
    315     if (event->data_size) {
    316         jData = env->NewByteArray(event->data_size);
    317         jbyte *nData = env->GetByteArrayElements(jData, NULL);
    318         memcpy(nData, (char *)event + event->data_offset, event->data_size);
    319         env->ReleaseByteArrayElements(jData, nData, 0);
    320     }
    321 
    322     jEvent = env->NewObject(gSoundModelEventClass, gSoundModelEventCstor,
    323                             event->status, event->model, jData);
    324 
    325     env->DeleteLocalRef(jData);
    326     env->CallStaticVoidMethod(mClass, gPostEventFromNative, mObject,
    327                               SOUNDTRIGGER_EVENT_SOUNDMODEL, 0, 0, jEvent);
    328     env->DeleteLocalRef(jEvent);
    329     if (env->ExceptionCheck()) {
    330         ALOGW("An exception occurred while notifying an event.");
    331         env->ExceptionClear();
    332     }
    333 }
    334 
    335 void JNISoundTriggerCallback::onServiceStateChange(sound_trigger_service_state_t state)
    336 {
    337     JNIEnv *env = AndroidRuntime::getJNIEnv();
    338     env->CallStaticVoidMethod(mClass, gPostEventFromNative, mObject,
    339                                         SOUNDTRIGGER_EVENT_SERVICE_STATE_CHANGE, state, 0, NULL);
    340     if (env->ExceptionCheck()) {
    341         ALOGW("An exception occurred while notifying an event.");
    342         env->ExceptionClear();
    343     }
    344 }
    345 
    346 void JNISoundTriggerCallback::onServiceDied()
    347 {
    348     JNIEnv *env = AndroidRuntime::getJNIEnv();
    349 
    350     env->CallStaticVoidMethod(mClass, gPostEventFromNative, mObject,
    351                               SOUNDTRIGGER_EVENT_SERVICE_DIED, 0, 0, NULL);
    352     if (env->ExceptionCheck()) {
    353         ALOGW("An exception occurred while notifying an event.");
    354         env->ExceptionClear();
    355     }
    356 }
    357 
    358 // ----------------------------------------------------------------------------
    359 
    360 static sp<SoundTrigger> getSoundTrigger(JNIEnv* env, jobject thiz)
    361 {
    362     Mutex::Autolock l(gLock);
    363     SoundTrigger* const st = (SoundTrigger*)env->GetLongField(thiz,
    364                                                          gModuleFields.mNativeContext);
    365     return sp<SoundTrigger>(st);
    366 }
    367 
    368 static sp<SoundTrigger> setSoundTrigger(JNIEnv* env, jobject thiz, const sp<SoundTrigger>& module)
    369 {
    370     Mutex::Autolock l(gLock);
    371     sp<SoundTrigger> old = (SoundTrigger*)env->GetLongField(thiz,
    372                                                          gModuleFields.mNativeContext);
    373     if (module.get()) {
    374         module->incStrong((void*)setSoundTrigger);
    375     }
    376     if (old != 0) {
    377         old->decStrong((void*)setSoundTrigger);
    378     }
    379     env->SetLongField(thiz, gModuleFields.mNativeContext, (jlong)module.get());
    380     return old;
    381 }
    382 
    383 
    384 static jint
    385 android_hardware_SoundTrigger_listModules(JNIEnv *env, jobject clazz,
    386                                           jobject jModules)
    387 {
    388     ALOGV("listModules");
    389 
    390     if (jModules == NULL) {
    391         ALOGE("listModules NULL AudioPatch ArrayList");
    392         return SOUNDTRIGGER_STATUS_BAD_VALUE;
    393     }
    394     if (!env->IsInstanceOf(jModules, gArrayListClass)) {
    395         ALOGE("listModules not an arraylist");
    396         return SOUNDTRIGGER_STATUS_BAD_VALUE;
    397     }
    398 
    399     unsigned int numModules = 0;
    400     struct sound_trigger_module_descriptor *nModules = NULL;
    401 
    402     status_t status = SoundTrigger::listModules(nModules, &numModules);
    403     if (status != NO_ERROR || numModules == 0) {
    404         return (jint)status;
    405     }
    406 
    407     nModules = (struct sound_trigger_module_descriptor *)
    408                             calloc(numModules, sizeof(struct sound_trigger_module_descriptor));
    409 
    410     status = SoundTrigger::listModules(nModules, &numModules);
    411     ALOGV("listModules SoundTrigger::listModules status %d numModules %d", status, numModules);
    412 
    413     if (status != NO_ERROR) {
    414         numModules = 0;
    415     }
    416 
    417     for (size_t i = 0; i < numModules; i++) {
    418         char str[SOUND_TRIGGER_MAX_STRING_LEN];
    419 
    420         jstring implementor = env->NewStringUTF(nModules[i].properties.implementor);
    421         jstring description = env->NewStringUTF(nModules[i].properties.description);
    422         SoundTrigger::guidToString(&nModules[i].properties.uuid,
    423                                    str,
    424                                    SOUND_TRIGGER_MAX_STRING_LEN);
    425         jstring uuid = env->NewStringUTF(str);
    426 
    427         ALOGV("listModules module %zu id %d description %s maxSoundModels %d",
    428               i, nModules[i].handle, nModules[i].properties.description,
    429               nModules[i].properties.max_sound_models);
    430 
    431         jobject newModuleDesc = env->NewObject(gModulePropertiesClass, gModulePropertiesCstor,
    432                                                nModules[i].handle,
    433                                                implementor, description, uuid,
    434                                                nModules[i].properties.version,
    435                                                nModules[i].properties.max_sound_models,
    436                                                nModules[i].properties.max_key_phrases,
    437                                                nModules[i].properties.max_users,
    438                                                nModules[i].properties.recognition_modes,
    439                                                nModules[i].properties.capture_transition,
    440                                                nModules[i].properties.max_buffer_ms,
    441                                                nModules[i].properties.concurrent_capture,
    442                                                nModules[i].properties.power_consumption_mw,
    443                                                nModules[i].properties.trigger_in_event);
    444 
    445         env->DeleteLocalRef(implementor);
    446         env->DeleteLocalRef(description);
    447         env->DeleteLocalRef(uuid);
    448         if (newModuleDesc == NULL) {
    449             status = SOUNDTRIGGER_STATUS_ERROR;
    450             goto exit;
    451         }
    452         env->CallBooleanMethod(jModules, gArrayListMethods.add, newModuleDesc);
    453     }
    454 
    455 exit:
    456     free(nModules);
    457     return (jint) status;
    458 }
    459 
    460 static void
    461 android_hardware_SoundTrigger_setup(JNIEnv *env, jobject thiz, jobject weak_this)
    462 {
    463     ALOGV("setup");
    464 
    465     sp<JNISoundTriggerCallback> callback = new JNISoundTriggerCallback(env, thiz, weak_this);
    466 
    467     sound_trigger_module_handle_t handle =
    468             (sound_trigger_module_handle_t)env->GetIntField(thiz, gModuleFields.mId);
    469 
    470     sp<SoundTrigger> module = SoundTrigger::attach(handle, callback);
    471     if (module == 0) {
    472         return;
    473     }
    474 
    475     setSoundTrigger(env, thiz, module);
    476 }
    477 
    478 static void
    479 android_hardware_SoundTrigger_detach(JNIEnv *env, jobject thiz)
    480 {
    481     ALOGV("detach");
    482     sp<SoundTrigger> module = setSoundTrigger(env, thiz, 0);
    483     ALOGV("detach module %p", module.get());
    484     if (module != 0) {
    485         ALOGV("detach module->detach()");
    486         module->detach();
    487     }
    488 }
    489 
    490 static void
    491 android_hardware_SoundTrigger_finalize(JNIEnv *env, jobject thiz)
    492 {
    493     ALOGV("finalize");
    494     sp<SoundTrigger> module = getSoundTrigger(env, thiz);
    495     if (module != 0) {
    496         ALOGW("SoundTrigger finalized without being detached");
    497     }
    498     android_hardware_SoundTrigger_detach(env, thiz);
    499 }
    500 
    501 static jint
    502 android_hardware_SoundTrigger_loadSoundModel(JNIEnv *env, jobject thiz,
    503                                              jobject jSoundModel, jintArray jHandle)
    504 {
    505     jint status = SOUNDTRIGGER_STATUS_OK;
    506     jbyte *nData = NULL;
    507     struct sound_trigger_sound_model *nSoundModel;
    508     jbyteArray jData;
    509     sp<MemoryDealer> memoryDealer;
    510     sp<IMemory> memory;
    511     size_t size;
    512     sound_model_handle_t handle = 0;
    513     jobject jUuid;
    514     jstring jUuidString;
    515     const char *nUuidString;
    516 
    517     ALOGV("loadSoundModel");
    518     sp<SoundTrigger> module = getSoundTrigger(env, thiz);
    519     if (module == NULL) {
    520         return SOUNDTRIGGER_STATUS_ERROR;
    521     }
    522     if (jHandle == NULL) {
    523         return SOUNDTRIGGER_STATUS_BAD_VALUE;
    524     }
    525     jsize jHandleLen = env->GetArrayLength(jHandle);
    526     if (jHandleLen == 0) {
    527         return SOUNDTRIGGER_STATUS_BAD_VALUE;
    528     }
    529     jint *nHandle = env->GetIntArrayElements(jHandle, NULL);
    530     if (nHandle == NULL) {
    531         return SOUNDTRIGGER_STATUS_ERROR;
    532     }
    533     if (!env->IsInstanceOf(jSoundModel, gSoundModelClass)) {
    534         status = SOUNDTRIGGER_STATUS_BAD_VALUE;
    535         goto exit;
    536     }
    537     size_t offset;
    538     sound_trigger_sound_model_type_t type;
    539     if (env->IsInstanceOf(jSoundModel, gKeyphraseSoundModelClass)) {
    540         offset = sizeof(struct sound_trigger_phrase_sound_model);
    541         type = SOUND_MODEL_TYPE_KEYPHRASE;
    542     } else if (env->IsInstanceOf(jSoundModel, gGenericSoundModelClass)) {
    543         offset = sizeof(struct sound_trigger_generic_sound_model);
    544         type = SOUND_MODEL_TYPE_GENERIC;
    545     } else {
    546         offset = sizeof(struct sound_trigger_sound_model);
    547         type = SOUND_MODEL_TYPE_UNKNOWN;
    548     }
    549 
    550     jUuid = env->GetObjectField(jSoundModel, gSoundModelFields.uuid);
    551     jUuidString = (jstring)env->CallObjectMethod(jUuid, gUUIDMethods.toString);
    552     nUuidString = env->GetStringUTFChars(jUuidString, NULL);
    553     sound_trigger_uuid_t nUuid;
    554     SoundTrigger::stringToGuid(nUuidString, &nUuid);
    555     env->ReleaseStringUTFChars(jUuidString, nUuidString);
    556     env->DeleteLocalRef(jUuidString);
    557 
    558     sound_trigger_uuid_t nVendorUuid;
    559     jUuid = env->GetObjectField(jSoundModel, gSoundModelFields.vendorUuid);
    560     if (jUuid != NULL) {
    561         jUuidString = (jstring)env->CallObjectMethod(jUuid, gUUIDMethods.toString);
    562         nUuidString = env->GetStringUTFChars(jUuidString, NULL);
    563         SoundTrigger::stringToGuid(nUuidString, &nVendorUuid);
    564         env->ReleaseStringUTFChars(jUuidString, nUuidString);
    565         env->DeleteLocalRef(jUuidString);
    566     } else {
    567         SoundTrigger::stringToGuid("00000000-0000-0000-0000-000000000000", &nVendorUuid);
    568     }
    569 
    570     jData = (jbyteArray)env->GetObjectField(jSoundModel, gSoundModelFields.data);
    571     if (jData == NULL) {
    572         status = SOUNDTRIGGER_STATUS_BAD_VALUE;
    573         goto exit;
    574     }
    575     size = env->GetArrayLength(jData);
    576 
    577     nData = env->GetByteArrayElements(jData, NULL);
    578     if (jData == NULL) {
    579         status = SOUNDTRIGGER_STATUS_ERROR;
    580         goto exit;
    581     }
    582 
    583     memoryDealer = new MemoryDealer(offset + size, "SoundTrigge-JNI::LoadModel");
    584     if (memoryDealer == 0) {
    585         status = SOUNDTRIGGER_STATUS_ERROR;
    586         goto exit;
    587     }
    588     memory = memoryDealer->allocate(offset + size);
    589     if (memory == 0 || memory->pointer() == NULL) {
    590         status = SOUNDTRIGGER_STATUS_ERROR;
    591         goto exit;
    592     }
    593 
    594     nSoundModel = (struct sound_trigger_sound_model *)memory->pointer();
    595 
    596     nSoundModel->type = type;
    597     nSoundModel->uuid = nUuid;
    598     nSoundModel->vendor_uuid = nVendorUuid;
    599     nSoundModel->data_size = size;
    600     nSoundModel->data_offset = offset;
    601     memcpy((char *)nSoundModel + offset, nData, size);
    602     if (type == SOUND_MODEL_TYPE_KEYPHRASE) {
    603         struct sound_trigger_phrase_sound_model *phraseModel =
    604                 (struct sound_trigger_phrase_sound_model *)nSoundModel;
    605 
    606         jobjectArray jPhrases =
    607             (jobjectArray)env->GetObjectField(jSoundModel, gKeyphraseSoundModelFields.keyphrases);
    608         if (jPhrases == NULL) {
    609             status = SOUNDTRIGGER_STATUS_BAD_VALUE;
    610             goto exit;
    611         }
    612 
    613         size_t numPhrases = env->GetArrayLength(jPhrases);
    614         phraseModel->num_phrases = numPhrases;
    615         ALOGV("loadSoundModel numPhrases %zu", numPhrases);
    616         for (size_t i = 0; i < numPhrases; i++) {
    617             jobject jPhrase = env->GetObjectArrayElement(jPhrases, i);
    618             phraseModel->phrases[i].id =
    619                                     env->GetIntField(jPhrase,gKeyphraseFields.id);
    620             phraseModel->phrases[i].recognition_mode =
    621                                     env->GetIntField(jPhrase,gKeyphraseFields.recognitionModes);
    622 
    623             jintArray jUsers = (jintArray)env->GetObjectField(jPhrase, gKeyphraseFields.users);
    624             phraseModel->phrases[i].num_users = env->GetArrayLength(jUsers);
    625             jint *nUsers = env->GetIntArrayElements(jUsers, NULL);
    626             memcpy(phraseModel->phrases[i].users,
    627                    nUsers,
    628                    phraseModel->phrases[i].num_users * sizeof(int));
    629             env->ReleaseIntArrayElements(jUsers, nUsers, 0);
    630             env->DeleteLocalRef(jUsers);
    631 
    632             jstring jLocale = (jstring)env->GetObjectField(jPhrase, gKeyphraseFields.locale);
    633             const char *nLocale = env->GetStringUTFChars(jLocale, NULL);
    634             strncpy(phraseModel->phrases[i].locale,
    635                     nLocale,
    636                     SOUND_TRIGGER_MAX_LOCALE_LEN);
    637             jstring jText = (jstring)env->GetObjectField(jPhrase, gKeyphraseFields.text);
    638             const char *nText = env->GetStringUTFChars(jText, NULL);
    639             strncpy(phraseModel->phrases[i].text,
    640                     nText,
    641                     SOUND_TRIGGER_MAX_STRING_LEN);
    642 
    643             env->ReleaseStringUTFChars(jLocale, nLocale);
    644             env->DeleteLocalRef(jLocale);
    645             env->ReleaseStringUTFChars(jText, nText);
    646             env->DeleteLocalRef(jText);
    647             ALOGV("loadSoundModel phrases %zu text %s locale %s",
    648                   i, phraseModel->phrases[i].text, phraseModel->phrases[i].locale);
    649             env->DeleteLocalRef(jPhrase);
    650         }
    651         env->DeleteLocalRef(jPhrases);
    652     } else if (type == SOUND_MODEL_TYPE_GENERIC) {
    653         /* No initialization needed */
    654     }
    655     status = module->loadSoundModel(memory, &handle);
    656     ALOGV("loadSoundModel status %d handle %d", status, handle);
    657 
    658 exit:
    659     if (nHandle != NULL) {
    660         nHandle[0] = (jint)handle;
    661         env->ReleaseIntArrayElements(jHandle, nHandle, NULL);
    662     }
    663     if (nData != NULL) {
    664         env->ReleaseByteArrayElements(jData, nData, NULL);
    665     }
    666     return status;
    667 }
    668 
    669 static jint
    670 android_hardware_SoundTrigger_unloadSoundModel(JNIEnv *env, jobject thiz,
    671                                                jint jHandle)
    672 {
    673     jint status = SOUNDTRIGGER_STATUS_OK;
    674     ALOGV("unloadSoundModel");
    675     sp<SoundTrigger> module = getSoundTrigger(env, thiz);
    676     if (module == NULL) {
    677         return SOUNDTRIGGER_STATUS_ERROR;
    678     }
    679     status = module->unloadSoundModel((sound_model_handle_t)jHandle);
    680 
    681     return status;
    682 }
    683 
    684 static jint
    685 android_hardware_SoundTrigger_startRecognition(JNIEnv *env, jobject thiz,
    686                                                jint jHandle, jobject jConfig)
    687 {
    688     jint status = SOUNDTRIGGER_STATUS_OK;
    689     ALOGV("startRecognition");
    690     sp<SoundTrigger> module = getSoundTrigger(env, thiz);
    691     if (module == NULL) {
    692         return SOUNDTRIGGER_STATUS_ERROR;
    693     }
    694 
    695     if (!env->IsInstanceOf(jConfig, gRecognitionConfigClass)) {
    696         return SOUNDTRIGGER_STATUS_BAD_VALUE;
    697     }
    698 
    699     jbyteArray jData = (jbyteArray)env->GetObjectField(jConfig, gRecognitionConfigFields.data);
    700     jsize dataSize = 0;
    701     jbyte *nData = NULL;
    702     if (jData != NULL) {
    703         dataSize = env->GetArrayLength(jData);
    704         if (dataSize == 0) {
    705             return SOUNDTRIGGER_STATUS_BAD_VALUE;
    706         }
    707         nData = env->GetByteArrayElements(jData, NULL);
    708         if (nData == NULL) {
    709             return SOUNDTRIGGER_STATUS_ERROR;
    710         }
    711     }
    712 
    713     size_t totalSize = sizeof(struct sound_trigger_recognition_config) + dataSize;
    714     sp<MemoryDealer> memoryDealer =
    715             new MemoryDealer(totalSize, "SoundTrigge-JNI::StartRecognition");
    716     if (memoryDealer == 0) {
    717         return SOUNDTRIGGER_STATUS_ERROR;
    718     }
    719     sp<IMemory> memory = memoryDealer->allocate(totalSize);
    720     if (memory == 0 || memory->pointer() == NULL) {
    721         return SOUNDTRIGGER_STATUS_ERROR;
    722     }
    723     if (dataSize != 0) {
    724         memcpy((char *)memory->pointer() + sizeof(struct sound_trigger_recognition_config),
    725                 nData,
    726                 dataSize);
    727         env->ReleaseByteArrayElements(jData, nData, 0);
    728     }
    729     env->DeleteLocalRef(jData);
    730     struct sound_trigger_recognition_config *config =
    731                                     (struct sound_trigger_recognition_config *)memory->pointer();
    732     config->data_size = dataSize;
    733     config->data_offset = sizeof(struct sound_trigger_recognition_config);
    734     config->capture_requested = env->GetBooleanField(jConfig,
    735                                                  gRecognitionConfigFields.captureRequested);
    736 
    737     config->num_phrases = 0;
    738     jobjectArray jPhrases =
    739         (jobjectArray)env->GetObjectField(jConfig, gRecognitionConfigFields.keyphrases);
    740     if (jPhrases != NULL) {
    741         config->num_phrases = env->GetArrayLength(jPhrases);
    742     }
    743     ALOGV("startRecognition num phrases %d", config->num_phrases);
    744     for (size_t i = 0; i < config->num_phrases; i++) {
    745         jobject jPhrase = env->GetObjectArrayElement(jPhrases, i);
    746         config->phrases[i].id = env->GetIntField(jPhrase,
    747                                                 gKeyphraseRecognitionExtraFields.id);
    748         config->phrases[i].recognition_modes = env->GetIntField(jPhrase,
    749                                                 gKeyphraseRecognitionExtraFields.recognitionModes);
    750         config->phrases[i].confidence_level = env->GetIntField(jPhrase,
    751                                             gKeyphraseRecognitionExtraFields.coarseConfidenceLevel);
    752         config->phrases[i].num_levels = 0;
    753         jobjectArray jConfidenceLevels = (jobjectArray)env->GetObjectField(jPhrase,
    754                                                 gKeyphraseRecognitionExtraFields.confidenceLevels);
    755         if (jConfidenceLevels != NULL) {
    756             config->phrases[i].num_levels = env->GetArrayLength(jConfidenceLevels);
    757         }
    758         ALOGV("startRecognition phrase %zu num_levels %d", i, config->phrases[i].num_levels);
    759         for (size_t j = 0; j < config->phrases[i].num_levels; j++) {
    760             jobject jConfidenceLevel = env->GetObjectArrayElement(jConfidenceLevels, j);
    761             config->phrases[i].levels[j].user_id = env->GetIntField(jConfidenceLevel,
    762                                                                     gConfidenceLevelFields.userId);
    763             config->phrases[i].levels[j].level = env->GetIntField(jConfidenceLevel,
    764                                                           gConfidenceLevelFields.confidenceLevel);
    765             env->DeleteLocalRef(jConfidenceLevel);
    766         }
    767         ALOGV("startRecognition phrases %zu", i);
    768         env->DeleteLocalRef(jConfidenceLevels);
    769         env->DeleteLocalRef(jPhrase);
    770     }
    771     env->DeleteLocalRef(jPhrases);
    772 
    773     status = module->startRecognition(jHandle, memory);
    774     return status;
    775 }
    776 
    777 static jint
    778 android_hardware_SoundTrigger_stopRecognition(JNIEnv *env, jobject thiz,
    779                                                jint jHandle)
    780 {
    781     jint status = SOUNDTRIGGER_STATUS_OK;
    782     ALOGV("stopRecognition");
    783     sp<SoundTrigger> module = getSoundTrigger(env, thiz);
    784     if (module == NULL) {
    785         return SOUNDTRIGGER_STATUS_ERROR;
    786     }
    787     status = module->stopRecognition(jHandle);
    788     return status;
    789 }
    790 
    791 static const JNINativeMethod gMethods[] = {
    792     {"listModules",
    793         "(Ljava/util/ArrayList;)I",
    794         (void *)android_hardware_SoundTrigger_listModules},
    795 };
    796 
    797 
    798 static const JNINativeMethod gModuleMethods[] = {
    799     {"native_setup",
    800         "(Ljava/lang/Object;)V",
    801         (void *)android_hardware_SoundTrigger_setup},
    802     {"native_finalize",
    803         "()V",
    804         (void *)android_hardware_SoundTrigger_finalize},
    805     {"detach",
    806         "()V",
    807         (void *)android_hardware_SoundTrigger_detach},
    808     {"loadSoundModel",
    809         "(Landroid/hardware/soundtrigger/SoundTrigger$SoundModel;[I)I",
    810         (void *)android_hardware_SoundTrigger_loadSoundModel},
    811     {"unloadSoundModel",
    812         "(I)I",
    813         (void *)android_hardware_SoundTrigger_unloadSoundModel},
    814     {"startRecognition",
    815         "(ILandroid/hardware/soundtrigger/SoundTrigger$RecognitionConfig;)I",
    816         (void *)android_hardware_SoundTrigger_startRecognition},
    817     {"stopRecognition",
    818         "(I)I",
    819         (void *)android_hardware_SoundTrigger_stopRecognition},
    820 };
    821 
    822 int register_android_hardware_SoundTrigger(JNIEnv *env)
    823 {
    824     jclass arrayListClass = FindClassOrDie(env, "java/util/ArrayList");
    825     gArrayListClass = MakeGlobalRefOrDie(env, arrayListClass);
    826     gArrayListMethods.add = GetMethodIDOrDie(env, arrayListClass, "add", "(Ljava/lang/Object;)Z");
    827 
    828     jclass uuidClass = FindClassOrDie(env, "java/util/UUID");
    829     gUUIDClass = MakeGlobalRefOrDie(env, uuidClass);
    830     gUUIDMethods.toString = GetMethodIDOrDie(env, uuidClass, "toString", "()Ljava/lang/String;");
    831 
    832     jclass lClass = FindClassOrDie(env, kSoundTriggerClassPathName);
    833     gSoundTriggerClass = MakeGlobalRefOrDie(env, lClass);
    834 
    835     jclass moduleClass = FindClassOrDie(env, kModuleClassPathName);
    836     gModuleClass = MakeGlobalRefOrDie(env, moduleClass);
    837     gPostEventFromNative = GetStaticMethodIDOrDie(env, moduleClass, "postEventFromNative",
    838                                                   "(Ljava/lang/Object;IIILjava/lang/Object;)V");
    839     gModuleFields.mNativeContext = GetFieldIDOrDie(env, moduleClass, "mNativeContext", "J");
    840     gModuleFields.mId = GetFieldIDOrDie(env, moduleClass, "mId", "I");
    841 
    842     jclass modulePropertiesClass = FindClassOrDie(env, kModulePropertiesClassPathName);
    843     gModulePropertiesClass = MakeGlobalRefOrDie(env, modulePropertiesClass);
    844     gModulePropertiesCstor = GetMethodIDOrDie(env, modulePropertiesClass, "<init>",
    845             "(ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;IIIIIZIZIZ)V");
    846 
    847     jclass soundModelClass = FindClassOrDie(env, kSoundModelClassPathName);
    848     gSoundModelClass = MakeGlobalRefOrDie(env, soundModelClass);
    849     gSoundModelFields.uuid = GetFieldIDOrDie(env, soundModelClass, "uuid", "Ljava/util/UUID;");
    850     gSoundModelFields.vendorUuid = GetFieldIDOrDie(env, soundModelClass, "vendorUuid",
    851                                                    "Ljava/util/UUID;");
    852     gSoundModelFields.data = GetFieldIDOrDie(env, soundModelClass, "data", "[B");
    853 
    854     jclass genericSoundModelClass = FindClassOrDie(env, kGenericSoundModelClassPathName);
    855     gGenericSoundModelClass = MakeGlobalRefOrDie(env, genericSoundModelClass);
    856 
    857     jclass keyphraseClass = FindClassOrDie(env, kKeyphraseClassPathName);
    858     gKeyphraseClass = MakeGlobalRefOrDie(env, keyphraseClass);
    859     gKeyphraseFields.id = GetFieldIDOrDie(env, keyphraseClass, "id", "I");
    860     gKeyphraseFields.recognitionModes = GetFieldIDOrDie(env, keyphraseClass, "recognitionModes",
    861                                                         "I");
    862     gKeyphraseFields.locale = GetFieldIDOrDie(env, keyphraseClass, "locale", "Ljava/lang/String;");
    863     gKeyphraseFields.text = GetFieldIDOrDie(env, keyphraseClass, "text", "Ljava/lang/String;");
    864     gKeyphraseFields.users = GetFieldIDOrDie(env, keyphraseClass, "users", "[I");
    865 
    866     jclass keyphraseSoundModelClass = FindClassOrDie(env, kKeyphraseSoundModelClassPathName);
    867     gKeyphraseSoundModelClass = MakeGlobalRefOrDie(env, keyphraseSoundModelClass);
    868     gKeyphraseSoundModelFields.keyphrases = GetFieldIDOrDie(env, keyphraseSoundModelClass,
    869                                          "keyphrases",
    870                                          "[Landroid/hardware/soundtrigger/SoundTrigger$Keyphrase;");
    871 
    872     jclass recognitionEventClass = FindClassOrDie(env, kRecognitionEventClassPathName);
    873     gRecognitionEventClass = MakeGlobalRefOrDie(env, recognitionEventClass);
    874     gRecognitionEventCstor = GetMethodIDOrDie(env, recognitionEventClass, "<init>",
    875                                               "(IIZIIIZLandroid/media/AudioFormat;[B)V");
    876 
    877     jclass keyphraseRecognitionEventClass = FindClassOrDie(env,
    878                                                            kKeyphraseRecognitionEventClassPathName);
    879     gKeyphraseRecognitionEventClass = MakeGlobalRefOrDie(env, keyphraseRecognitionEventClass);
    880     gKeyphraseRecognitionEventCstor = GetMethodIDOrDie(env, keyphraseRecognitionEventClass, "<init>",
    881               "(IIZIIIZLandroid/media/AudioFormat;[B[Landroid/hardware/soundtrigger/SoundTrigger$KeyphraseRecognitionExtra;)V");
    882 
    883     jclass genericRecognitionEventClass = FindClassOrDie(env,
    884                                                            kGenericRecognitionEventClassPathName);
    885     gGenericRecognitionEventClass = MakeGlobalRefOrDie(env, genericRecognitionEventClass);
    886     gGenericRecognitionEventCstor = GetMethodIDOrDie(env, genericRecognitionEventClass, "<init>",
    887                                               "(IIZIIIZLandroid/media/AudioFormat;[B)V");
    888 
    889     jclass keyRecognitionConfigClass = FindClassOrDie(env, kRecognitionConfigClassPathName);
    890     gRecognitionConfigClass = MakeGlobalRefOrDie(env, keyRecognitionConfigClass);
    891     gRecognitionConfigFields.captureRequested = GetFieldIDOrDie(env, keyRecognitionConfigClass,
    892                                                                 "captureRequested", "Z");
    893     gRecognitionConfigFields.keyphrases = GetFieldIDOrDie(env, keyRecognitionConfigClass,
    894            "keyphrases", "[Landroid/hardware/soundtrigger/SoundTrigger$KeyphraseRecognitionExtra;");
    895     gRecognitionConfigFields.data = GetFieldIDOrDie(env, keyRecognitionConfigClass, "data", "[B");
    896 
    897     jclass keyphraseRecognitionExtraClass = FindClassOrDie(env,
    898                                                            kKeyphraseRecognitionExtraClassPathName);
    899     gKeyphraseRecognitionExtraClass = MakeGlobalRefOrDie(env, keyphraseRecognitionExtraClass);
    900     gKeyphraseRecognitionExtraCstor = GetMethodIDOrDie(env, keyphraseRecognitionExtraClass,
    901             "<init>", "(III[Landroid/hardware/soundtrigger/SoundTrigger$ConfidenceLevel;)V");
    902     gKeyphraseRecognitionExtraFields.id = GetFieldIDOrDie(env, gKeyphraseRecognitionExtraClass,
    903                                                           "id", "I");
    904     gKeyphraseRecognitionExtraFields.recognitionModes = GetFieldIDOrDie(env,
    905             gKeyphraseRecognitionExtraClass, "recognitionModes", "I");
    906     gKeyphraseRecognitionExtraFields.coarseConfidenceLevel = GetFieldIDOrDie(env,
    907             gKeyphraseRecognitionExtraClass, "coarseConfidenceLevel", "I");
    908     gKeyphraseRecognitionExtraFields.confidenceLevels = GetFieldIDOrDie(env,
    909             gKeyphraseRecognitionExtraClass, "confidenceLevels",
    910             "[Landroid/hardware/soundtrigger/SoundTrigger$ConfidenceLevel;");
    911 
    912     jclass confidenceLevelClass = FindClassOrDie(env, kConfidenceLevelClassPathName);
    913     gConfidenceLevelClass = MakeGlobalRefOrDie(env, confidenceLevelClass);
    914     gConfidenceLevelCstor = GetMethodIDOrDie(env, confidenceLevelClass, "<init>", "(II)V");
    915     gConfidenceLevelFields.userId = GetFieldIDOrDie(env, confidenceLevelClass, "userId", "I");
    916     gConfidenceLevelFields.confidenceLevel = GetFieldIDOrDie(env, confidenceLevelClass,
    917                                                              "confidenceLevel", "I");
    918 
    919     jclass audioFormatClass = FindClassOrDie(env, kAudioFormatClassPathName);
    920     gAudioFormatClass = MakeGlobalRefOrDie(env, audioFormatClass);
    921     gAudioFormatCstor = GetMethodIDOrDie(env, audioFormatClass, "<init>", "(IIII)V");
    922 
    923     jclass soundModelEventClass = FindClassOrDie(env, kSoundModelEventClassPathName);
    924     gSoundModelEventClass = MakeGlobalRefOrDie(env, soundModelEventClass);
    925     gSoundModelEventCstor = GetMethodIDOrDie(env, soundModelEventClass, "<init>", "(II[B)V");
    926 
    927 
    928     RegisterMethodsOrDie(env, kSoundTriggerClassPathName, gMethods, NELEM(gMethods));
    929     return RegisterMethodsOrDie(env, kModuleClassPathName, gModuleMethods, NELEM(gModuleMethods));
    930 }
    931