1/* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#define LOG_TAG "SoundTriggerHwService" 18//#define LOG_NDEBUG 0 19 20#include <stdio.h> 21#include <string.h> 22#include <sys/types.h> 23#include <pthread.h> 24 25#include <system/sound_trigger.h> 26#include <cutils/atomic.h> 27#include <cutils/properties.h> 28#include <hardware/hardware.h> 29#include <media/AudioSystem.h> 30#include <utils/Errors.h> 31#include <utils/Log.h> 32#include <binder/IServiceManager.h> 33#include <binder/MemoryBase.h> 34#include <binder/MemoryHeapBase.h> 35#include <hardware/sound_trigger.h> 36#include <ServiceUtilities.h> 37#include "SoundTriggerHwService.h" 38 39namespace android { 40 41#ifdef SOUND_TRIGGER_USE_STUB_MODULE 42#define HW_MODULE_PREFIX "stub" 43#else 44#define HW_MODULE_PREFIX "primary" 45#endif 46 47SoundTriggerHwService::SoundTriggerHwService() 48 : BnSoundTriggerHwService(), 49 mNextUniqueId(1), 50 mMemoryDealer(new MemoryDealer(1024 * 1024, "SoundTriggerHwService")), 51 mCaptureState(false) 52{ 53} 54 55void SoundTriggerHwService::onFirstRef() 56{ 57 const hw_module_t *mod; 58 int rc; 59 sound_trigger_hw_device *dev; 60 61 rc = hw_get_module_by_class(SOUND_TRIGGER_HARDWARE_MODULE_ID, HW_MODULE_PREFIX, &mod); 62 if (rc != 0) { 63 ALOGE("couldn't load sound trigger module %s.%s (%s)", 64 SOUND_TRIGGER_HARDWARE_MODULE_ID, HW_MODULE_PREFIX, strerror(-rc)); 65 return; 66 } 67 rc = sound_trigger_hw_device_open(mod, &dev); 68 if (rc != 0) { 69 ALOGE("couldn't open sound trigger hw device in %s.%s (%s)", 70 SOUND_TRIGGER_HARDWARE_MODULE_ID, HW_MODULE_PREFIX, strerror(-rc)); 71 return; 72 } 73 if (dev->common.version < SOUND_TRIGGER_DEVICE_API_VERSION_1_0 || 74 dev->common.version > SOUND_TRIGGER_DEVICE_API_VERSION_CURRENT) { 75 ALOGE("wrong sound trigger hw device version %04x", dev->common.version); 76 return; 77 } 78 79 sound_trigger_module_descriptor descriptor; 80 rc = dev->get_properties(dev, &descriptor.properties); 81 if (rc != 0) { 82 ALOGE("could not read implementation properties"); 83 return; 84 } 85 descriptor.handle = 86 (sound_trigger_module_handle_t)android_atomic_inc(&mNextUniqueId); 87 ALOGI("loaded default module %s, handle %d", descriptor.properties.description, 88 descriptor.handle); 89 90 sp<ISoundTriggerClient> client; 91 sp<Module> module = new Module(this, dev, descriptor, client); 92 mModules.add(descriptor.handle, module); 93 mCallbackThread = new CallbackThread(this); 94} 95 96SoundTriggerHwService::~SoundTriggerHwService() 97{ 98 if (mCallbackThread != 0) { 99 mCallbackThread->exit(); 100 } 101 for (size_t i = 0; i < mModules.size(); i++) { 102 sound_trigger_hw_device_close(mModules.valueAt(i)->hwDevice()); 103 } 104} 105 106status_t SoundTriggerHwService::listModules(struct sound_trigger_module_descriptor *modules, 107 uint32_t *numModules) 108{ 109 ALOGV("listModules"); 110 if (!captureHotwordAllowed()) { 111 return PERMISSION_DENIED; 112 } 113 114 AutoMutex lock(mServiceLock); 115 if (numModules == NULL || (*numModules != 0 && modules == NULL)) { 116 return BAD_VALUE; 117 } 118 size_t maxModules = *numModules; 119 *numModules = mModules.size(); 120 for (size_t i = 0; i < mModules.size() && i < maxModules; i++) { 121 modules[i] = mModules.valueAt(i)->descriptor(); 122 } 123 return NO_ERROR; 124} 125 126status_t SoundTriggerHwService::attach(const sound_trigger_module_handle_t handle, 127 const sp<ISoundTriggerClient>& client, 128 sp<ISoundTrigger>& moduleInterface) 129{ 130 ALOGV("attach module %d", handle); 131 if (!captureHotwordAllowed()) { 132 return PERMISSION_DENIED; 133 } 134 135 AutoMutex lock(mServiceLock); 136 moduleInterface.clear(); 137 if (client == 0) { 138 return BAD_VALUE; 139 } 140 ssize_t index = mModules.indexOfKey(handle); 141 if (index < 0) { 142 return BAD_VALUE; 143 } 144 sp<Module> module = mModules.valueAt(index); 145 146 module->setClient(client); 147 IInterface::asBinder(client)->linkToDeath(module); 148 moduleInterface = module; 149 150 module->setCaptureState_l(mCaptureState); 151 152 return NO_ERROR; 153} 154 155status_t SoundTriggerHwService::setCaptureState(bool active) 156{ 157 ALOGV("setCaptureState %d", active); 158 AutoMutex lock(mServiceLock); 159 mCaptureState = active; 160 for (size_t i = 0; i < mModules.size(); i++) { 161 mModules.valueAt(i)->setCaptureState_l(active); 162 } 163 return NO_ERROR; 164} 165 166 167void SoundTriggerHwService::detachModule(sp<Module> module) 168{ 169 ALOGV("detachModule"); 170 AutoMutex lock(mServiceLock); 171 module->clearClient(); 172} 173 174 175static const int kDumpLockRetries = 50; 176static const int kDumpLockSleep = 60000; 177 178static bool tryLock(Mutex& mutex) 179{ 180 bool locked = false; 181 for (int i = 0; i < kDumpLockRetries; ++i) { 182 if (mutex.tryLock() == NO_ERROR) { 183 locked = true; 184 break; 185 } 186 usleep(kDumpLockSleep); 187 } 188 return locked; 189} 190 191status_t SoundTriggerHwService::dump(int fd, const Vector<String16>& args __unused) { 192 String8 result; 193 if (checkCallingPermission(String16("android.permission.DUMP")) == false) { 194 result.appendFormat("Permission Denial: can't dump SoundTriggerHwService"); 195 write(fd, result.string(), result.size()); 196 } else { 197 bool locked = tryLock(mServiceLock); 198 // failed to lock - SoundTriggerHwService is probably deadlocked 199 if (!locked) { 200 result.append("SoundTriggerHwService may be deadlocked\n"); 201 write(fd, result.string(), result.size()); 202 } 203 204 if (locked) mServiceLock.unlock(); 205 } 206 return NO_ERROR; 207} 208 209status_t SoundTriggerHwService::onTransact( 210 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { 211 return BnSoundTriggerHwService::onTransact(code, data, reply, flags); 212} 213 214 215// static 216void SoundTriggerHwService::recognitionCallback(struct sound_trigger_recognition_event *event, 217 void *cookie) 218{ 219 Module *module = (Module *)cookie; 220 if (module == NULL) { 221 return; 222 } 223 sp<SoundTriggerHwService> service = module->service().promote(); 224 if (service == 0) { 225 return; 226 } 227 228 service->sendRecognitionEvent(event, module); 229} 230 231sp<IMemory> SoundTriggerHwService::prepareRecognitionEvent_l( 232 struct sound_trigger_recognition_event *event) 233{ 234 sp<IMemory> eventMemory; 235 236 //sanitize event 237 switch (event->type) { 238 case SOUND_MODEL_TYPE_KEYPHRASE: 239 ALOGW_IF(event->data_size != 0 && event->data_offset != 240 sizeof(struct sound_trigger_phrase_recognition_event), 241 "prepareRecognitionEvent_l(): invalid data offset %u for keyphrase event type", 242 event->data_offset); 243 event->data_offset = sizeof(struct sound_trigger_phrase_recognition_event); 244 break; 245 case SOUND_MODEL_TYPE_GENERIC: 246 ALOGW_IF(event->data_size != 0 && event->data_offset != 247 sizeof(struct sound_trigger_generic_recognition_event), 248 "prepareRecognitionEvent_l(): invalid data offset %u for generic event type", 249 event->data_offset); 250 event->data_offset = sizeof(struct sound_trigger_generic_recognition_event); 251 break; 252 case SOUND_MODEL_TYPE_UNKNOWN: 253 ALOGW_IF(event->data_size != 0 && event->data_offset != 254 sizeof(struct sound_trigger_recognition_event), 255 "prepareRecognitionEvent_l(): invalid data offset %u for unknown event type", 256 event->data_offset); 257 event->data_offset = sizeof(struct sound_trigger_recognition_event); 258 break; 259 default: 260 return eventMemory; 261 } 262 263 size_t size = event->data_offset + event->data_size; 264 eventMemory = mMemoryDealer->allocate(size); 265 if (eventMemory == 0 || eventMemory->pointer() == NULL) { 266 eventMemory.clear(); 267 return eventMemory; 268 } 269 memcpy(eventMemory->pointer(), event, size); 270 271 return eventMemory; 272} 273 274void SoundTriggerHwService::sendRecognitionEvent(struct sound_trigger_recognition_event *event, 275 Module *module) 276 { 277 AutoMutex lock(mServiceLock); 278 if (module == NULL) { 279 return; 280 } 281 sp<IMemory> eventMemory = prepareRecognitionEvent_l(event); 282 if (eventMemory == 0) { 283 return; 284 } 285 sp<Module> strongModule; 286 for (size_t i = 0; i < mModules.size(); i++) { 287 if (mModules.valueAt(i).get() == module) { 288 strongModule = mModules.valueAt(i); 289 break; 290 } 291 } 292 if (strongModule == 0) { 293 return; 294 } 295 296 sendCallbackEvent_l(new CallbackEvent(CallbackEvent::TYPE_RECOGNITION, 297 eventMemory, strongModule)); 298} 299 300// static 301void SoundTriggerHwService::soundModelCallback(struct sound_trigger_model_event *event, 302 void *cookie) 303{ 304 Module *module = (Module *)cookie; 305 if (module == NULL) { 306 return; 307 } 308 sp<SoundTriggerHwService> service = module->service().promote(); 309 if (service == 0) { 310 return; 311 } 312 313 service->sendSoundModelEvent(event, module); 314} 315 316sp<IMemory> SoundTriggerHwService::prepareSoundModelEvent_l(struct sound_trigger_model_event *event) 317{ 318 sp<IMemory> eventMemory; 319 320 size_t size = event->data_offset + event->data_size; 321 eventMemory = mMemoryDealer->allocate(size); 322 if (eventMemory == 0 || eventMemory->pointer() == NULL) { 323 eventMemory.clear(); 324 return eventMemory; 325 } 326 memcpy(eventMemory->pointer(), event, size); 327 328 return eventMemory; 329} 330 331void SoundTriggerHwService::sendSoundModelEvent(struct sound_trigger_model_event *event, 332 Module *module) 333{ 334 AutoMutex lock(mServiceLock); 335 sp<IMemory> eventMemory = prepareSoundModelEvent_l(event); 336 if (eventMemory == 0) { 337 return; 338 } 339 sp<Module> strongModule; 340 for (size_t i = 0; i < mModules.size(); i++) { 341 if (mModules.valueAt(i).get() == module) { 342 strongModule = mModules.valueAt(i); 343 break; 344 } 345 } 346 if (strongModule == 0) { 347 return; 348 } 349 sendCallbackEvent_l(new CallbackEvent(CallbackEvent::TYPE_SOUNDMODEL, 350 eventMemory, strongModule)); 351} 352 353 354sp<IMemory> SoundTriggerHwService::prepareServiceStateEvent_l(sound_trigger_service_state_t state) 355{ 356 sp<IMemory> eventMemory; 357 358 size_t size = sizeof(sound_trigger_service_state_t); 359 eventMemory = mMemoryDealer->allocate(size); 360 if (eventMemory == 0 || eventMemory->pointer() == NULL) { 361 eventMemory.clear(); 362 return eventMemory; 363 } 364 *((sound_trigger_service_state_t *)eventMemory->pointer()) = state; 365 return eventMemory; 366} 367 368// call with mServiceLock held 369void SoundTriggerHwService::sendServiceStateEvent_l(sound_trigger_service_state_t state, 370 Module *module) 371{ 372 sp<IMemory> eventMemory = prepareServiceStateEvent_l(state); 373 if (eventMemory == 0) { 374 return; 375 } 376 sp<Module> strongModule; 377 for (size_t i = 0; i < mModules.size(); i++) { 378 if (mModules.valueAt(i).get() == module) { 379 strongModule = mModules.valueAt(i); 380 break; 381 } 382 } 383 if (strongModule == 0) { 384 return; 385 } 386 sendCallbackEvent_l(new CallbackEvent(CallbackEvent::TYPE_SERVICE_STATE, 387 eventMemory, strongModule)); 388} 389 390// call with mServiceLock held 391void SoundTriggerHwService::sendCallbackEvent_l(const sp<CallbackEvent>& event) 392{ 393 mCallbackThread->sendCallbackEvent(event); 394} 395 396void SoundTriggerHwService::onCallbackEvent(const sp<CallbackEvent>& event) 397{ 398 ALOGV("onCallbackEvent"); 399 sp<Module> module; 400 { 401 AutoMutex lock(mServiceLock); 402 module = event->mModule.promote(); 403 if (module == 0) { 404 return; 405 } 406 } 407 module->onCallbackEvent(event); 408 { 409 AutoMutex lock(mServiceLock); 410 // clear now to execute with mServiceLock locked 411 event->mMemory.clear(); 412 } 413} 414 415#undef LOG_TAG 416#define LOG_TAG "SoundTriggerHwService::CallbackThread" 417 418SoundTriggerHwService::CallbackThread::CallbackThread(const wp<SoundTriggerHwService>& service) 419 : mService(service) 420{ 421} 422 423SoundTriggerHwService::CallbackThread::~CallbackThread() 424{ 425 while (!mEventQueue.isEmpty()) { 426 mEventQueue[0]->mMemory.clear(); 427 mEventQueue.removeAt(0); 428 } 429} 430 431void SoundTriggerHwService::CallbackThread::onFirstRef() 432{ 433 run("soundTrigger cbk", ANDROID_PRIORITY_URGENT_AUDIO); 434} 435 436bool SoundTriggerHwService::CallbackThread::threadLoop() 437{ 438 while (!exitPending()) { 439 sp<CallbackEvent> event; 440 sp<SoundTriggerHwService> service; 441 { 442 Mutex::Autolock _l(mCallbackLock); 443 while (mEventQueue.isEmpty() && !exitPending()) { 444 ALOGV("CallbackThread::threadLoop() sleep"); 445 mCallbackCond.wait(mCallbackLock); 446 ALOGV("CallbackThread::threadLoop() wake up"); 447 } 448 if (exitPending()) { 449 break; 450 } 451 event = mEventQueue[0]; 452 mEventQueue.removeAt(0); 453 service = mService.promote(); 454 } 455 if (service != 0) { 456 service->onCallbackEvent(event); 457 } 458 } 459 return false; 460} 461 462void SoundTriggerHwService::CallbackThread::exit() 463{ 464 Mutex::Autolock _l(mCallbackLock); 465 requestExit(); 466 mCallbackCond.broadcast(); 467} 468 469void SoundTriggerHwService::CallbackThread::sendCallbackEvent( 470 const sp<SoundTriggerHwService::CallbackEvent>& event) 471{ 472 AutoMutex lock(mCallbackLock); 473 mEventQueue.add(event); 474 mCallbackCond.signal(); 475} 476 477SoundTriggerHwService::CallbackEvent::CallbackEvent(event_type type, sp<IMemory> memory, 478 wp<Module> module) 479 : mType(type), mMemory(memory), mModule(module) 480{ 481} 482 483SoundTriggerHwService::CallbackEvent::~CallbackEvent() 484{ 485} 486 487 488#undef LOG_TAG 489#define LOG_TAG "SoundTriggerHwService::Module" 490 491SoundTriggerHwService::Module::Module(const sp<SoundTriggerHwService>& service, 492 sound_trigger_hw_device* hwDevice, 493 sound_trigger_module_descriptor descriptor, 494 const sp<ISoundTriggerClient>& client) 495 : mService(service), mHwDevice(hwDevice), mDescriptor(descriptor), 496 mClient(client), mServiceState(SOUND_TRIGGER_STATE_NO_INIT) 497{ 498} 499 500SoundTriggerHwService::Module::~Module() { 501} 502 503void SoundTriggerHwService::Module::detach() { 504 ALOGV("detach()"); 505 if (!captureHotwordAllowed()) { 506 return; 507 } 508 { 509 AutoMutex lock(mLock); 510 for (size_t i = 0; i < mModels.size(); i++) { 511 sp<Model> model = mModels.valueAt(i); 512 ALOGV("detach() unloading model %d", model->mHandle); 513 if (model->mState == Model::STATE_ACTIVE) { 514 mHwDevice->stop_recognition(mHwDevice, model->mHandle); 515 } 516 mHwDevice->unload_sound_model(mHwDevice, model->mHandle); 517 } 518 mModels.clear(); 519 } 520 if (mClient != 0) { 521 IInterface::asBinder(mClient)->unlinkToDeath(this); 522 } 523 sp<SoundTriggerHwService> service = mService.promote(); 524 if (service == 0) { 525 return; 526 } 527 service->detachModule(this); 528} 529 530status_t SoundTriggerHwService::Module::loadSoundModel(const sp<IMemory>& modelMemory, 531 sound_model_handle_t *handle) 532{ 533 ALOGV("loadSoundModel() handle"); 534 if (!captureHotwordAllowed()) { 535 return PERMISSION_DENIED; 536 } 537 538 if (modelMemory == 0 || modelMemory->pointer() == NULL) { 539 ALOGE("loadSoundModel() modelMemory is 0 or has NULL pointer()"); 540 return BAD_VALUE; 541 } 542 struct sound_trigger_sound_model *sound_model = 543 (struct sound_trigger_sound_model *)modelMemory->pointer(); 544 545 AutoMutex lock(mLock); 546 547 if (mModels.size() >= mDescriptor.properties.max_sound_models) { 548 ALOGW("loadSoundModel(): Not loading, max number of models (%d) would be exceeded", 549 mDescriptor.properties.max_sound_models); 550 return INVALID_OPERATION; 551 } 552 553 status_t status = mHwDevice->load_sound_model(mHwDevice, sound_model, 554 SoundTriggerHwService::soundModelCallback, 555 this, handle); 556 557 if (status != NO_ERROR) { 558 return status; 559 } 560 audio_session_t session; 561 audio_io_handle_t ioHandle; 562 audio_devices_t device; 563 564 status = AudioSystem::acquireSoundTriggerSession(&session, &ioHandle, &device); 565 if (status != NO_ERROR) { 566 return status; 567 } 568 569 sp<Model> model = new Model(*handle, session, ioHandle, device, sound_model->type); 570 mModels.replaceValueFor(*handle, model); 571 572 return status; 573} 574 575status_t SoundTriggerHwService::Module::unloadSoundModel(sound_model_handle_t handle) 576{ 577 ALOGV("unloadSoundModel() model handle %d", handle); 578 if (!captureHotwordAllowed()) { 579 return PERMISSION_DENIED; 580 } 581 582 AutoMutex lock(mLock); 583 return unloadSoundModel_l(handle); 584} 585 586status_t SoundTriggerHwService::Module::unloadSoundModel_l(sound_model_handle_t handle) 587{ 588 ssize_t index = mModels.indexOfKey(handle); 589 if (index < 0) { 590 return BAD_VALUE; 591 } 592 sp<Model> model = mModels.valueAt(index); 593 mModels.removeItem(handle); 594 if (model->mState == Model::STATE_ACTIVE) { 595 mHwDevice->stop_recognition(mHwDevice, model->mHandle); 596 model->mState = Model::STATE_IDLE; 597 } 598 AudioSystem::releaseSoundTriggerSession(model->mCaptureSession); 599 return mHwDevice->unload_sound_model(mHwDevice, handle); 600} 601 602status_t SoundTriggerHwService::Module::startRecognition(sound_model_handle_t handle, 603 const sp<IMemory>& dataMemory) 604{ 605 ALOGV("startRecognition() model handle %d", handle); 606 if (!captureHotwordAllowed()) { 607 return PERMISSION_DENIED; 608 } 609 610 if (dataMemory != 0 && dataMemory->pointer() == NULL) { 611 ALOGE("startRecognition() dataMemory is non-0 but has NULL pointer()"); 612 return BAD_VALUE; 613 614 } 615 AutoMutex lock(mLock); 616 if (mServiceState == SOUND_TRIGGER_STATE_DISABLED) { 617 return INVALID_OPERATION; 618 } 619 sp<Model> model = getModel(handle); 620 if (model == 0) { 621 return BAD_VALUE; 622 } 623 if ((dataMemory == 0) || 624 (dataMemory->size() < sizeof(struct sound_trigger_recognition_config))) { 625 return BAD_VALUE; 626 } 627 628 if (model->mState == Model::STATE_ACTIVE) { 629 return INVALID_OPERATION; 630 } 631 632 struct sound_trigger_recognition_config *config = 633 (struct sound_trigger_recognition_config *)dataMemory->pointer(); 634 635 //TODO: get capture handle and device from audio policy service 636 config->capture_handle = model->mCaptureIOHandle; 637 config->capture_device = model->mCaptureDevice; 638 status_t status = mHwDevice->start_recognition(mHwDevice, handle, config, 639 SoundTriggerHwService::recognitionCallback, 640 this); 641 642 if (status == NO_ERROR) { 643 model->mState = Model::STATE_ACTIVE; 644 model->mConfig = *config; 645 } 646 647 return status; 648} 649 650status_t SoundTriggerHwService::Module::stopRecognition(sound_model_handle_t handle) 651{ 652 ALOGV("stopRecognition() model handle %d", handle); 653 if (!captureHotwordAllowed()) { 654 return PERMISSION_DENIED; 655 } 656 657 AutoMutex lock(mLock); 658 sp<Model> model = getModel(handle); 659 if (model == 0) { 660 return BAD_VALUE; 661 } 662 663 if (model->mState != Model::STATE_ACTIVE) { 664 return INVALID_OPERATION; 665 } 666 mHwDevice->stop_recognition(mHwDevice, handle); 667 model->mState = Model::STATE_IDLE; 668 return NO_ERROR; 669} 670 671 672void SoundTriggerHwService::Module::onCallbackEvent(const sp<CallbackEvent>& event) 673{ 674 ALOGV("onCallbackEvent type %d", event->mType); 675 676 sp<IMemory> eventMemory = event->mMemory; 677 678 if (eventMemory == 0 || eventMemory->pointer() == NULL) { 679 return; 680 } 681 if (mClient == 0) { 682 ALOGI("%s mClient == 0", __func__); 683 return; 684 } 685 686 switch (event->mType) { 687 case CallbackEvent::TYPE_RECOGNITION: { 688 struct sound_trigger_recognition_event *recognitionEvent = 689 (struct sound_trigger_recognition_event *)eventMemory->pointer(); 690 sp<ISoundTriggerClient> client; 691 { 692 AutoMutex lock(mLock); 693 sp<Model> model = getModel(recognitionEvent->model); 694 if (model == 0) { 695 ALOGW("%s model == 0", __func__); 696 return; 697 } 698 if (model->mState != Model::STATE_ACTIVE) { 699 ALOGV("onCallbackEvent model->mState %d != Model::STATE_ACTIVE", model->mState); 700 return; 701 } 702 703 recognitionEvent->capture_session = model->mCaptureSession; 704 model->mState = Model::STATE_IDLE; 705 client = mClient; 706 } 707 if (client != 0) { 708 client->onRecognitionEvent(eventMemory); 709 } 710 } break; 711 case CallbackEvent::TYPE_SOUNDMODEL: { 712 struct sound_trigger_model_event *soundmodelEvent = 713 (struct sound_trigger_model_event *)eventMemory->pointer(); 714 sp<ISoundTriggerClient> client; 715 { 716 AutoMutex lock(mLock); 717 sp<Model> model = getModel(soundmodelEvent->model); 718 if (model == 0) { 719 ALOGW("%s model == 0", __func__); 720 return; 721 } 722 client = mClient; 723 } 724 if (client != 0) { 725 client->onSoundModelEvent(eventMemory); 726 } 727 } break; 728 case CallbackEvent::TYPE_SERVICE_STATE: { 729 sp<ISoundTriggerClient> client; 730 { 731 AutoMutex lock(mLock); 732 client = mClient; 733 } 734 if (client != 0) { 735 client->onServiceStateChange(eventMemory); 736 } 737 } break; 738 default: 739 LOG_ALWAYS_FATAL("onCallbackEvent unknown event type %d", event->mType); 740 } 741} 742 743sp<SoundTriggerHwService::Model> SoundTriggerHwService::Module::getModel( 744 sound_model_handle_t handle) 745{ 746 sp<Model> model; 747 ssize_t index = mModels.indexOfKey(handle); 748 if (index >= 0) { 749 model = mModels.valueAt(index); 750 } 751 return model; 752} 753 754void SoundTriggerHwService::Module::binderDied( 755 const wp<IBinder> &who __unused) { 756 ALOGW("client binder died for module %d", mDescriptor.handle); 757 detach(); 758} 759 760// Called with mServiceLock held 761void SoundTriggerHwService::Module::setCaptureState_l(bool active) 762{ 763 ALOGV("Module::setCaptureState_l %d", active); 764 sp<SoundTriggerHwService> service; 765 sound_trigger_service_state_t state; 766 767 Vector< sp<IMemory> > events; 768 { 769 AutoMutex lock(mLock); 770 state = (active && !mDescriptor.properties.concurrent_capture) ? 771 SOUND_TRIGGER_STATE_DISABLED : SOUND_TRIGGER_STATE_ENABLED; 772 773 if (state == mServiceState) { 774 return; 775 } 776 777 mServiceState = state; 778 779 service = mService.promote(); 780 if (service == 0) { 781 return; 782 } 783 784 if (state == SOUND_TRIGGER_STATE_ENABLED) { 785 goto exit; 786 } 787 788 const bool supports_stop_all = 789 (mHwDevice->common.version >= SOUND_TRIGGER_DEVICE_API_VERSION_1_1 && 790 mHwDevice->stop_all_recognitions); 791 792 if (supports_stop_all) { 793 mHwDevice->stop_all_recognitions(mHwDevice); 794 } 795 796 for (size_t i = 0; i < mModels.size(); i++) { 797 sp<Model> model = mModels.valueAt(i); 798 if (model->mState == Model::STATE_ACTIVE) { 799 if (!supports_stop_all) { 800 mHwDevice->stop_recognition(mHwDevice, model->mHandle); 801 } 802 // keep model in ACTIVE state so that event is processed by onCallbackEvent() 803 if (model->mType == SOUND_MODEL_TYPE_KEYPHRASE) { 804 struct sound_trigger_phrase_recognition_event event; 805 memset(&event, 0, sizeof(struct sound_trigger_phrase_recognition_event)); 806 event.num_phrases = model->mConfig.num_phrases; 807 for (size_t i = 0; i < event.num_phrases; i++) { 808 event.phrase_extras[i] = model->mConfig.phrases[i]; 809 } 810 event.common.status = RECOGNITION_STATUS_ABORT; 811 event.common.type = model->mType; 812 event.common.model = model->mHandle; 813 event.common.data_size = 0; 814 sp<IMemory> eventMemory = service->prepareRecognitionEvent_l(&event.common); 815 if (eventMemory != 0) { 816 events.add(eventMemory); 817 } 818 } else if (model->mType == SOUND_MODEL_TYPE_GENERIC) { 819 struct sound_trigger_generic_recognition_event event; 820 memset(&event, 0, sizeof(struct sound_trigger_generic_recognition_event)); 821 event.common.status = RECOGNITION_STATUS_ABORT; 822 event.common.type = model->mType; 823 event.common.model = model->mHandle; 824 event.common.data_size = 0; 825 sp<IMemory> eventMemory = service->prepareRecognitionEvent_l(&event.common); 826 if (eventMemory != 0) { 827 events.add(eventMemory); 828 } 829 } else if (model->mType == SOUND_MODEL_TYPE_UNKNOWN) { 830 struct sound_trigger_phrase_recognition_event event; 831 memset(&event, 0, sizeof(struct sound_trigger_phrase_recognition_event)); 832 event.common.status = RECOGNITION_STATUS_ABORT; 833 event.common.type = model->mType; 834 event.common.model = model->mHandle; 835 event.common.data_size = 0; 836 sp<IMemory> eventMemory = service->prepareRecognitionEvent_l(&event.common); 837 if (eventMemory != 0) { 838 events.add(eventMemory); 839 } 840 } else { 841 goto exit; 842 } 843 } 844 } 845 } 846 847 for (size_t i = 0; i < events.size(); i++) { 848 service->sendCallbackEvent_l(new CallbackEvent(CallbackEvent::TYPE_RECOGNITION, events[i], 849 this)); 850 } 851 852exit: 853 service->sendServiceStateEvent_l(state, this); 854} 855 856 857SoundTriggerHwService::Model::Model(sound_model_handle_t handle, audio_session_t session, 858 audio_io_handle_t ioHandle, audio_devices_t device, 859 sound_trigger_sound_model_type_t type) : 860 mHandle(handle), mState(STATE_IDLE), mCaptureSession(session), 861 mCaptureIOHandle(ioHandle), mCaptureDevice(device), mType(type) 862{ 863 864} 865 866status_t SoundTriggerHwService::Module::dump(int fd __unused, 867 const Vector<String16>& args __unused) { 868 String8 result; 869 return NO_ERROR; 870} 871 872}; // namespace android 873