SoundTrigger.cpp revision 3769871b5998f4bbe6d8fe7c124ee97daa6e7fab
1/* 2** 3** Copyright (C) 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_TAG "SoundTrigger" 19//#define LOG_NDEBUG 0 20 21#include <utils/Log.h> 22#include <utils/threads.h> 23#include <binder/IPCThreadState.h> 24#include <binder/IServiceManager.h> 25#include <binder/IMemory.h> 26 27#include <soundtrigger/SoundTrigger.h> 28#include <soundtrigger/ISoundTrigger.h> 29#include <soundtrigger/ISoundTriggerHwService.h> 30#include <soundtrigger/ISoundTriggerClient.h> 31#include <soundtrigger/SoundTriggerCallback.h> 32 33namespace android { 34 35namespace { 36 sp<ISoundTriggerHwService> gSoundTriggerHwService; 37 const int kSoundTriggerHwServicePollDelay = 500000; // 0.5s 38 const char* kSoundTriggerHwServiceName = "media.sound_trigger_hw"; 39 Mutex gLock; 40 41 class DeathNotifier : public IBinder::DeathRecipient 42 { 43 public: 44 DeathNotifier() { 45 } 46 47 virtual void binderDied(const wp<IBinder>& who __unused) { 48 ALOGV("binderDied"); 49 Mutex::Autolock _l(gLock); 50 gSoundTriggerHwService.clear(); 51 ALOGW("Sound trigger service died!"); 52 } 53 }; 54 55 sp<DeathNotifier> gDeathNotifier; 56}; // namespace anonymous 57 58const sp<ISoundTriggerHwService> SoundTrigger::getSoundTriggerHwService() 59{ 60 Mutex::Autolock _l(gLock); 61 if (gSoundTriggerHwService.get() == 0) { 62 sp<IServiceManager> sm = defaultServiceManager(); 63 sp<IBinder> binder; 64 do { 65 binder = sm->getService(String16(kSoundTriggerHwServiceName)); 66 if (binder != 0) { 67 break; 68 } 69 ALOGW("SoundTriggerHwService not published, waiting..."); 70 usleep(kSoundTriggerHwServicePollDelay); 71 } while(true); 72 if (gDeathNotifier == NULL) { 73 gDeathNotifier = new DeathNotifier(); 74 } 75 binder->linkToDeath(gDeathNotifier); 76 gSoundTriggerHwService = interface_cast<ISoundTriggerHwService>(binder); 77 } 78 ALOGE_IF(gSoundTriggerHwService == 0, "no SoundTriggerHwService!?"); 79 return gSoundTriggerHwService; 80} 81 82// Static methods 83status_t SoundTrigger::listModules(struct sound_trigger_module_descriptor *modules, 84 uint32_t *numModules) 85{ 86 ALOGV("listModules()"); 87 const sp<ISoundTriggerHwService> service = getSoundTriggerHwService(); 88 if (service == 0) { 89 return NO_INIT; 90 } 91 return service->listModules(modules, numModules); 92} 93 94sp<SoundTrigger> SoundTrigger::attach(const sound_trigger_module_handle_t module, 95 const sp<SoundTriggerCallback>& callback) 96{ 97 ALOGV("attach()"); 98 sp<SoundTrigger> soundTrigger; 99 const sp<ISoundTriggerHwService> service = getSoundTriggerHwService(); 100 if (service == 0) { 101 return soundTrigger; 102 } 103 soundTrigger = new SoundTrigger(module, callback); 104 status_t status = service->attach(module, soundTrigger, soundTrigger->mISoundTrigger); 105 106 if (status == NO_ERROR && soundTrigger->mISoundTrigger != 0) { 107 IInterface::asBinder(soundTrigger->mISoundTrigger)->linkToDeath(soundTrigger); 108 } else { 109 ALOGW("Error %d connecting to sound trigger service", status); 110 soundTrigger.clear(); 111 } 112 return soundTrigger; 113} 114 115 116status_t SoundTrigger::setCaptureState(bool active) 117{ 118 ALOGV("setCaptureState(%d)", active); 119 const sp<ISoundTriggerHwService> service = getSoundTriggerHwService(); 120 if (service == 0) { 121 return NO_INIT; 122 } 123 return service->setCaptureState(active); 124} 125 126// SoundTrigger 127SoundTrigger::SoundTrigger(sound_trigger_module_handle_t module, 128 const sp<SoundTriggerCallback>& callback) 129 : mModule(module), mCallback(callback) 130{ 131} 132 133SoundTrigger::~SoundTrigger() 134{ 135 if (mISoundTrigger != 0) { 136 mISoundTrigger->detach(); 137 } 138} 139 140 141void SoundTrigger::detach() { 142 ALOGV("detach()"); 143 Mutex::Autolock _l(mLock); 144 mCallback.clear(); 145 if (mISoundTrigger != 0) { 146 mISoundTrigger->detach(); 147 IInterface::asBinder(mISoundTrigger)->unlinkToDeath(this); 148 mISoundTrigger = 0; 149 } 150} 151 152status_t SoundTrigger::loadSoundModel(const sp<IMemory>& modelMemory, 153 sound_model_handle_t *handle) 154{ 155 Mutex::Autolock _l(mLock); 156 if (mISoundTrigger == 0) { 157 return NO_INIT; 158 } 159 160 return mISoundTrigger->loadSoundModel(modelMemory, handle); 161} 162 163status_t SoundTrigger::unloadSoundModel(sound_model_handle_t handle) 164{ 165 Mutex::Autolock _l(mLock); 166 if (mISoundTrigger == 0) { 167 return NO_INIT; 168 } 169 return mISoundTrigger->unloadSoundModel(handle); 170} 171 172status_t SoundTrigger::startRecognition(sound_model_handle_t handle, 173 const sp<IMemory>& dataMemory) 174{ 175 Mutex::Autolock _l(mLock); 176 if (mISoundTrigger == 0) { 177 return NO_INIT; 178 } 179 return mISoundTrigger->startRecognition(handle, dataMemory); 180} 181 182status_t SoundTrigger::stopRecognition(sound_model_handle_t handle) 183{ 184 Mutex::Autolock _l(mLock); 185 if (mISoundTrigger == 0) { 186 return NO_INIT; 187 } 188 return mISoundTrigger->stopRecognition(handle); 189} 190 191// BpSoundTriggerClient 192void SoundTrigger::onRecognitionEvent(const sp<IMemory>& eventMemory) 193{ 194 Mutex::Autolock _l(mLock); 195 if (eventMemory == 0 || eventMemory->pointer() == NULL) { 196 return; 197 } 198 199 if (mCallback != 0) { 200 mCallback->onRecognitionEvent( 201 (struct sound_trigger_recognition_event *)eventMemory->pointer()); 202 } 203} 204 205void SoundTrigger::onSoundModelEvent(const sp<IMemory>& eventMemory) 206{ 207 Mutex::Autolock _l(mLock); 208 if (eventMemory == 0 || eventMemory->pointer() == NULL) { 209 return; 210 } 211 212 if (mCallback != 0) { 213 mCallback->onSoundModelEvent( 214 (struct sound_trigger_model_event *)eventMemory->pointer()); 215 } 216} 217 218void SoundTrigger::onServiceStateChange(const sp<IMemory>& eventMemory) 219{ 220 Mutex::Autolock _l(mLock); 221 if (eventMemory == 0 || eventMemory->pointer() == NULL) { 222 return; 223 } 224 225 if (mCallback != 0) { 226 mCallback->onServiceStateChange( 227 *((sound_trigger_service_state_t *)eventMemory->pointer())); 228 } 229} 230 231//IBinder::DeathRecipient 232void SoundTrigger::binderDied(const wp<IBinder>& who __unused) { 233 Mutex::Autolock _l(mLock); 234 ALOGW("SoundTrigger server binder Died "); 235 mISoundTrigger = 0; 236 if (mCallback != 0) { 237 mCallback->onServiceDied(); 238 } 239} 240 241status_t SoundTrigger::stringToGuid(const char *str, sound_trigger_uuid_t *guid) 242{ 243 if (str == NULL || guid == NULL) { 244 return BAD_VALUE; 245 } 246 247 int tmp[10]; 248 249 if (sscanf(str, "%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x", 250 tmp, tmp+1, tmp+2, tmp+3, tmp+4, tmp+5, tmp+6, tmp+7, tmp+8, tmp+9) < 10) { 251 return BAD_VALUE; 252 } 253 guid->timeLow = (uint32_t)tmp[0]; 254 guid->timeMid = (uint16_t)tmp[1]; 255 guid->timeHiAndVersion = (uint16_t)tmp[2]; 256 guid->clockSeq = (uint16_t)tmp[3]; 257 guid->node[0] = (uint8_t)tmp[4]; 258 guid->node[1] = (uint8_t)tmp[5]; 259 guid->node[2] = (uint8_t)tmp[6]; 260 guid->node[3] = (uint8_t)tmp[7]; 261 guid->node[4] = (uint8_t)tmp[8]; 262 guid->node[5] = (uint8_t)tmp[9]; 263 264 return NO_ERROR; 265} 266 267status_t SoundTrigger::guidToString(const sound_trigger_uuid_t *guid, char *str, size_t maxLen) 268{ 269 if (guid == NULL || str == NULL) { 270 return BAD_VALUE; 271 } 272 273 snprintf(str, maxLen, "%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x", 274 guid->timeLow, 275 guid->timeMid, 276 guid->timeHiAndVersion, 277 guid->clockSeq, 278 guid->node[0], 279 guid->node[1], 280 guid->node[2], 281 guid->node[3], 282 guid->node[4], 283 guid->node[5]); 284 285 return NO_ERROR; 286} 287 288}; // namespace android 289