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 33 namespace android { 34 35 namespace { 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 58 const 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 83 status_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 94 sp<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 soundTrigger->mISoundTrigger->asBinder()->linkToDeath(soundTrigger); 108 } else { 109 ALOGW("Error %d connecting to sound trigger service", status); 110 soundTrigger.clear(); 111 } 112 return soundTrigger; 113 } 114 115 116 status_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 127 SoundTrigger::SoundTrigger(sound_trigger_module_handle_t module, 128 const sp<SoundTriggerCallback>& callback) 129 : mModule(module), mCallback(callback) 130 { 131 } 132 133 SoundTrigger::~SoundTrigger() 134 { 135 if (mISoundTrigger != 0) { 136 mISoundTrigger->detach(); 137 } 138 } 139 140 141 void SoundTrigger::detach() { 142 ALOGV("detach()"); 143 Mutex::Autolock _l(mLock); 144 mCallback.clear(); 145 if (mISoundTrigger != 0) { 146 mISoundTrigger->detach(); 147 mISoundTrigger->asBinder()->unlinkToDeath(this); 148 mISoundTrigger = 0; 149 } 150 } 151 152 status_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 163 status_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 172 status_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 182 status_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 192 void 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 205 void 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 218 void 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 232 void 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 241 status_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 267 status_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