soundtrigger/SoundTrigger.cpp - LeafOS-Project/android_frameworks_av - Gitiles

 /*
 **
 ** Copyright (C) 2014, The Android Open Source Project
 **
 ** 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.
 */

 #define LOG_TAG "SoundTrigger"
 //#define LOG_NDEBUG 0

 #include <utils/Log.h>
 #include <utils/threads.h>
 #include <binder/IPCThreadState.h>
 #include <binder/IServiceManager.h>
 #include <binder/IMemory.h>

 #include <soundtrigger/SoundTrigger.h>
 #include <soundtrigger/ISoundTrigger.h>
 #include <soundtrigger/ISoundTriggerHwService.h>
 #include <soundtrigger/ISoundTriggerClient.h>
 #include <soundtrigger/SoundTriggerCallback.h>

 namespace android {

 namespace {
     sp<ISoundTriggerHwService> gSoundTriggerHwService;
     const int                  kSoundTriggerHwServicePollDelay = 500000; // 0.5s
     const char*                kSoundTriggerHwServiceName      = "media.sound_trigger_hw";
     Mutex                      gLock;

     class DeathNotifier : public IBinder::DeathRecipient
     {
     public:
         DeathNotifier() {
         }

         virtual void binderDied(const wp<IBinder>& who __unused) {
             ALOGV("binderDied");
             Mutex::Autolock _l(gLock);
             gSoundTriggerHwService.clear();
             ALOGW("Sound trigger service died!");
         }
     };

     sp<DeathNotifier>         gDeathNotifier;
 }; // namespace anonymous

 const sp<ISoundTriggerHwService> SoundTrigger::getSoundTriggerHwService()
 {
     Mutex::Autolock _l(gLock);
     if (gSoundTriggerHwService.get() == 0) {
         sp<IServiceManager> sm = defaultServiceManager();
         sp<IBinder> binder;
         do {
             binder = sm->getService(String16(kSoundTriggerHwServiceName));
             if (binder != 0) {
                 break;
             }
             ALOGW("SoundTriggerHwService not published, waiting...");
             usleep(kSoundTriggerHwServicePollDelay);
         } while(true);
         if (gDeathNotifier == NULL) {
             gDeathNotifier = new DeathNotifier();
         }
         binder->linkToDeath(gDeathNotifier);
         gSoundTriggerHwService = interface_cast<ISoundTriggerHwService>(binder);
     }
     ALOGE_IF(gSoundTriggerHwService == 0, "no SoundTriggerHwService!?");
     return gSoundTriggerHwService;
 }

 // Static methods
 status_t SoundTrigger::listModules(const String16& opPackageName,
                                    struct sound_trigger_module_descriptor *modules,
                                    uint32_t *numModules)
 {
     ALOGV("listModules()");
     const sp<ISoundTriggerHwService> service = getSoundTriggerHwService();
     if (service == 0) {
         return NO_INIT;
     }
     return service->listModules(opPackageName, modules, numModules);
 }

 sp<SoundTrigger> SoundTrigger::attach(const String16& opPackageName,
                                       const sound_trigger_module_handle_t module,
                                       const sp<SoundTriggerCallback>& callback)
 {
     ALOGV("attach()");
     sp<SoundTrigger> soundTrigger;
     const sp<ISoundTriggerHwService> service = getSoundTriggerHwService();
     if (service == 0) {
         return soundTrigger;
     }
     soundTrigger = new SoundTrigger(module, callback);
     status_t status = service->attach(opPackageName, module, soundTrigger,
                                       soundTrigger->mISoundTrigger);

     if (status == NO_ERROR && soundTrigger->mISoundTrigger != 0) {
         IInterface::asBinder(soundTrigger->mISoundTrigger)->linkToDeath(soundTrigger);
     } else {
         ALOGW("Error %d connecting to sound trigger service", status);
         soundTrigger.clear();
     }
     return soundTrigger;
 }


 status_t SoundTrigger::setCaptureState(bool active)
 {
     ALOGV("setCaptureState(%d)", active);
     const sp<ISoundTriggerHwService> service = getSoundTriggerHwService();
     if (service == 0) {
         return NO_INIT;
     }
     return service->setCaptureState(active);
 }

 // SoundTrigger
 SoundTrigger::SoundTrigger(sound_trigger_module_handle_t /*module*/,
                                  const sp<SoundTriggerCallback>& callback)
     : mCallback(callback)
 {
 }

 SoundTrigger::~SoundTrigger()
 {
     if (mISoundTrigger != 0) {
         mISoundTrigger->detach();
     }
 }


 void SoundTrigger::detach() {
     ALOGV("detach()");
     Mutex::Autolock _l(mLock);
     mCallback.clear();
     if (mISoundTrigger != 0) {
         mISoundTrigger->detach();
         IInterface::asBinder(mISoundTrigger)->unlinkToDeath(this);
         mISoundTrigger = 0;
     }
 }

 status_t SoundTrigger::loadSoundModel(const sp<IMemory>& modelMemory,
                                 sound_model_handle_t *handle)
 {
     Mutex::Autolock _l(mLock);
     if (mISoundTrigger == 0) {
         return NO_INIT;
     }

     return mISoundTrigger->loadSoundModel(modelMemory, handle);
 }

 status_t SoundTrigger::unloadSoundModel(sound_model_handle_t handle)
 {
     Mutex::Autolock _l(mLock);
     if (mISoundTrigger == 0) {
         return NO_INIT;
     }
     return mISoundTrigger->unloadSoundModel(handle);
 }

 status_t SoundTrigger::startRecognition(sound_model_handle_t handle,
                                         const sp<IMemory>& dataMemory)
 {
     Mutex::Autolock _l(mLock);
     if (mISoundTrigger == 0) {
         return NO_INIT;
     }
     return mISoundTrigger->startRecognition(handle, dataMemory);
 }

 status_t SoundTrigger::stopRecognition(sound_model_handle_t handle)
 {
     Mutex::Autolock _l(mLock);
     if (mISoundTrigger == 0) {
         return NO_INIT;
     }
     return mISoundTrigger->stopRecognition(handle);
 }

 status_t SoundTrigger::getModelState(sound_model_handle_t handle)
 {
     Mutex::Autolock _l(mLock);
     if (mISoundTrigger == 0) {
         return NO_INIT;
     }
     return mISoundTrigger->getModelState(handle);
 }

 status_t SoundTrigger::setParameter(sound_model_handle_t handle,
         sound_trigger_model_parameter_t param, int32_t value)
 {
     Mutex::Autolock _l(mLock);
     if (mISoundTrigger == 0) {
         return NO_INIT;
     }
     return mISoundTrigger->setParameter(handle, param, value);
 }

 status_t SoundTrigger::getParameter(sound_model_handle_t handle,
         sound_trigger_model_parameter_t param, int32_t* value)
 {
     Mutex::Autolock _l(mLock);
     if (mISoundTrigger == 0) {
         return NO_INIT;
     }
     return mISoundTrigger->getParameter(handle, param, value);
 }

 status_t SoundTrigger::queryParameter(sound_model_handle_t handle,
         sound_trigger_model_parameter_t param,
         sound_trigger_model_parameter_range_t* param_range)
 {
     Mutex::Autolock _l(mLock);
     if (mISoundTrigger == 0) {
         return NO_INIT;
     }
     return mISoundTrigger->queryParameter(handle, param, param_range);
 }

 // BpSoundTriggerClient
 void SoundTrigger::onRecognitionEvent(const sp<IMemory>& eventMemory)
 {
     Mutex::Autolock _l(mLock);
     if (eventMemory == 0 || eventMemory->unsecurePointer() == NULL) {
         return;
     }

     if (mCallback != 0) {
         // Memory is coming from a trusted process.
         mCallback->onRecognitionEvent(
                 (struct sound_trigger_recognition_event *)eventMemory->unsecurePointer());
     }
 }

 void SoundTrigger::onSoundModelEvent(const sp<IMemory>& eventMemory)
 {
     Mutex::Autolock _l(mLock);
     if (eventMemory == 0 || eventMemory->unsecurePointer() == NULL) {
         return;
     }

     if (mCallback != 0) {
         // Memory is coming from a trusted process.
         mCallback->onSoundModelEvent(
                 (struct sound_trigger_model_event *)eventMemory->unsecurePointer());
     }
 }

 void SoundTrigger::onServiceStateChange(const sp<IMemory>& eventMemory)
 {
     Mutex::Autolock _l(mLock);
     if (eventMemory == 0 || eventMemory->unsecurePointer() == NULL) {
         return;
     }

     if (mCallback != 0) {
         // Memory is coming from a trusted process.
         mCallback->onServiceStateChange(
                 *((sound_trigger_service_state_t *)eventMemory->unsecurePointer()));
     }
 }

 //IBinder::DeathRecipient
 void SoundTrigger::binderDied(const wp<IBinder>& who __unused) {
     Mutex::Autolock _l(mLock);
     ALOGW("SoundTrigger server binder Died ");
     mISoundTrigger = 0;
     if (mCallback != 0) {
         mCallback->onServiceDied();
     }
 }

 status_t SoundTrigger::stringToGuid(const char *str, sound_trigger_uuid_t *guid)
 {
     if (str == NULL || guid == NULL) {
         return BAD_VALUE;
     }

     int tmp[10];

     if (sscanf(str, "%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x",
             tmp, tmp+1, tmp+2, tmp+3, tmp+4, tmp+5, tmp+6, tmp+7, tmp+8, tmp+9) < 10) {
         return BAD_VALUE;
     }
     guid->timeLow = (uint32_t)tmp[0];
     guid->timeMid = (uint16_t)tmp[1];
     guid->timeHiAndVersion = (uint16_t)tmp[2];
     guid->clockSeq = (uint16_t)tmp[3];
     guid->node[0] = (uint8_t)tmp[4];
     guid->node[1] = (uint8_t)tmp[5];
     guid->node[2] = (uint8_t)tmp[6];
     guid->node[3] = (uint8_t)tmp[7];
     guid->node[4] = (uint8_t)tmp[8];
     guid->node[5] = (uint8_t)tmp[9];

     return NO_ERROR;
 }

 status_t SoundTrigger::guidToString(const sound_trigger_uuid_t *guid, char *str, size_t maxLen)
 {
     if (guid == NULL || str == NULL) {
         return BAD_VALUE;
     }

     snprintf(str, maxLen, "%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x",
             guid->timeLow,
             guid->timeMid,
             guid->timeHiAndVersion,
             guid->clockSeq,
             guid->node[0],
             guid->node[1],
             guid->node[2],
             guid->node[3],
             guid->node[4],
             guid->node[5]);

     return NO_ERROR;
 }

 }; // namespace android
	/*
	**
	** Copyright (C) 2014, The Android Open Source Project
	**
	** 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.
	*/

	#define LOG_TAG "SoundTrigger"
	//#define LOG_NDEBUG 0

	#include <utils/Log.h>
	#include <utils/threads.h>
	#include <binder/IPCThreadState.h>
	#include <binder/IServiceManager.h>
	#include <binder/IMemory.h>

	#include <soundtrigger/SoundTrigger.h>
	#include <soundtrigger/ISoundTrigger.h>
	#include <soundtrigger/ISoundTriggerHwService.h>
	#include <soundtrigger/ISoundTriggerClient.h>
	#include <soundtrigger/SoundTriggerCallback.h>

	namespace android {

	namespace {
	sp<ISoundTriggerHwService> gSoundTriggerHwService;
	const int kSoundTriggerHwServicePollDelay = 500000; // 0.5s
	const char* kSoundTriggerHwServiceName = "media.sound_trigger_hw";
	Mutex gLock;

	class DeathNotifier : public IBinder::DeathRecipient
	{
	public:
	DeathNotifier() {
	}

	virtual void binderDied(const wp<IBinder>& who __unused) {
	ALOGV("binderDied");
	Mutex::Autolock _l(gLock);
	gSoundTriggerHwService.clear();
	ALOGW("Sound trigger service died!");
	}
	};

	sp<DeathNotifier> gDeathNotifier;
	}; // namespace anonymous

	const sp<ISoundTriggerHwService> SoundTrigger::getSoundTriggerHwService()
	{
	Mutex::Autolock _l(gLock);
	if (gSoundTriggerHwService.get() == 0) {
	sp<IServiceManager> sm = defaultServiceManager();
	sp<IBinder> binder;
	do {
	binder = sm->getService(String16(kSoundTriggerHwServiceName));
	if (binder != 0) {
	break;
	}
	ALOGW("SoundTriggerHwService not published, waiting...");
	usleep(kSoundTriggerHwServicePollDelay);
	} while(true);
	if (gDeathNotifier == NULL) {
	gDeathNotifier = new DeathNotifier();
	}
	binder->linkToDeath(gDeathNotifier);
	gSoundTriggerHwService = interface_cast<ISoundTriggerHwService>(binder);
	}
	ALOGE_IF(gSoundTriggerHwService == 0, "no SoundTriggerHwService!?");
	return gSoundTriggerHwService;
	}

	// Static methods
	status_t SoundTrigger::listModules(const String16& opPackageName,
	struct sound_trigger_module_descriptor *modules,
	uint32_t *numModules)
	{
	ALOGV("listModules()");
	const sp<ISoundTriggerHwService> service = getSoundTriggerHwService();
	if (service == 0) {
	return NO_INIT;
	}
	return service->listModules(opPackageName, modules, numModules);
	}

	sp<SoundTrigger> SoundTrigger::attach(const String16& opPackageName,
	const sound_trigger_module_handle_t module,
	const sp<SoundTriggerCallback>& callback)
	{
	ALOGV("attach()");
	sp<SoundTrigger> soundTrigger;
	const sp<ISoundTriggerHwService> service = getSoundTriggerHwService();
	if (service == 0) {
	return soundTrigger;
	}
	soundTrigger = new SoundTrigger(module, callback);
	status_t status = service->attach(opPackageName, module, soundTrigger,
	soundTrigger->mISoundTrigger);

	if (status == NO_ERROR && soundTrigger->mISoundTrigger != 0) {
	IInterface::asBinder(soundTrigger->mISoundTrigger)->linkToDeath(soundTrigger);
	} else {
	ALOGW("Error %d connecting to sound trigger service", status);
	soundTrigger.clear();
	}
	return soundTrigger;
	}


	status_t SoundTrigger::setCaptureState(bool active)
	{
	ALOGV("setCaptureState(%d)", active);
	const sp<ISoundTriggerHwService> service = getSoundTriggerHwService();
	if (service == 0) {
	return NO_INIT;
	}
	return service->setCaptureState(active);
	}

	// SoundTrigger
	SoundTrigger::SoundTrigger(sound_trigger_module_handle_t /module/,
	const sp<SoundTriggerCallback>& callback)
	: mCallback(callback)
	{
	}

	SoundTrigger::~SoundTrigger()
	{
	if (mISoundTrigger != 0) {
	mISoundTrigger->detach();
	}
	}


	void SoundTrigger::detach() {
	ALOGV("detach()");
	Mutex::Autolock _l(mLock);
	mCallback.clear();
	if (mISoundTrigger != 0) {
	mISoundTrigger->detach();
	IInterface::asBinder(mISoundTrigger)->unlinkToDeath(this);
	mISoundTrigger = 0;
	}
	}

	status_t SoundTrigger::loadSoundModel(const sp<IMemory>& modelMemory,
	sound_model_handle_t *handle)
	{
	Mutex::Autolock _l(mLock);
	if (mISoundTrigger == 0) {
	return NO_INIT;
	}

	return mISoundTrigger->loadSoundModel(modelMemory, handle);
	}

	status_t SoundTrigger::unloadSoundModel(sound_model_handle_t handle)
	{
	Mutex::Autolock _l(mLock);
	if (mISoundTrigger == 0) {
	return NO_INIT;
	}
	return mISoundTrigger->unloadSoundModel(handle);
	}

	status_t SoundTrigger::startRecognition(sound_model_handle_t handle,
	const sp<IMemory>& dataMemory)
	{
	Mutex::Autolock _l(mLock);
	if (mISoundTrigger == 0) {
	return NO_INIT;
	}
	return mISoundTrigger->startRecognition(handle, dataMemory);
	}

	status_t SoundTrigger::stopRecognition(sound_model_handle_t handle)
	{
	Mutex::Autolock _l(mLock);
	if (mISoundTrigger == 0) {
	return NO_INIT;
	}
	return mISoundTrigger->stopRecognition(handle);
	}

	status_t SoundTrigger::getModelState(sound_model_handle_t handle)
	{
	Mutex::Autolock _l(mLock);
	if (mISoundTrigger == 0) {
	return NO_INIT;
	}
	return mISoundTrigger->getModelState(handle);
	}

	status_t SoundTrigger::setParameter(sound_model_handle_t handle,
	sound_trigger_model_parameter_t param, int32_t value)
	{
	Mutex::Autolock _l(mLock);
	if (mISoundTrigger == 0) {
	return NO_INIT;
	}
	return mISoundTrigger->setParameter(handle, param, value);
	}

	status_t SoundTrigger::getParameter(sound_model_handle_t handle,
	sound_trigger_model_parameter_t param, int32_t* value)
	{
	Mutex::Autolock _l(mLock);
	if (mISoundTrigger == 0) {
	return NO_INIT;
	}
	return mISoundTrigger->getParameter(handle, param, value);
	}

	status_t SoundTrigger::queryParameter(sound_model_handle_t handle,
	sound_trigger_model_parameter_t param,
	sound_trigger_model_parameter_range_t* param_range)
	{
	Mutex::Autolock _l(mLock);
	if (mISoundTrigger == 0) {
	return NO_INIT;
	}
	return mISoundTrigger->queryParameter(handle, param, param_range);
	}

	// BpSoundTriggerClient
	void SoundTrigger::onRecognitionEvent(const sp<IMemory>& eventMemory)
	{
	Mutex::Autolock _l(mLock);
	if (eventMemory == 0 \|\| eventMemory->unsecurePointer() == NULL) {
	return;
	}

	if (mCallback != 0) {
	// Memory is coming from a trusted process.
	mCallback->onRecognitionEvent(
	(struct sound_trigger_recognition_event *)eventMemory->unsecurePointer());
	}
	}

	void SoundTrigger::onSoundModelEvent(const sp<IMemory>& eventMemory)
	{
	Mutex::Autolock _l(mLock);
	if (eventMemory == 0 \|\| eventMemory->unsecurePointer() == NULL) {
	return;
	}

	if (mCallback != 0) {
	// Memory is coming from a trusted process.
	mCallback->onSoundModelEvent(
	(struct sound_trigger_model_event *)eventMemory->unsecurePointer());
	}
	}

	void SoundTrigger::onServiceStateChange(const sp<IMemory>& eventMemory)
	{
	Mutex::Autolock _l(mLock);
	if (eventMemory == 0 \|\| eventMemory->unsecurePointer() == NULL) {
	return;
	}

	if (mCallback != 0) {
	// Memory is coming from a trusted process.
	mCallback->onServiceStateChange(
	((sound_trigger_service_state_t )eventMemory->unsecurePointer()));
	}
	}

	//IBinder::DeathRecipient
	void SoundTrigger::binderDied(const wp<IBinder>& who __unused) {
	Mutex::Autolock _l(mLock);
	ALOGW("SoundTrigger server binder Died ");
	mISoundTrigger = 0;
	if (mCallback != 0) {
	mCallback->onServiceDied();
	}
	}

	status_t SoundTrigger::stringToGuid(const char str, sound_trigger_uuid_t guid)
	{
	if (str == NULL \|\| guid == NULL) {
	return BAD_VALUE;
	}

	int tmp[10];

	if (sscanf(str, "%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x",
	tmp, tmp+1, tmp+2, tmp+3, tmp+4, tmp+5, tmp+6, tmp+7, tmp+8, tmp+9) < 10) {
	return BAD_VALUE;
	}
	guid->timeLow = (uint32_t)tmp[0];
	guid->timeMid = (uint16_t)tmp[1];
	guid->timeHiAndVersion = (uint16_t)tmp[2];
	guid->clockSeq = (uint16_t)tmp[3];
	guid->node[0] = (uint8_t)tmp[4];
	guid->node[1] = (uint8_t)tmp[5];
	guid->node[2] = (uint8_t)tmp[6];
	guid->node[3] = (uint8_t)tmp[7];
	guid->node[4] = (uint8_t)tmp[8];
	guid->node[5] = (uint8_t)tmp[9];

	return NO_ERROR;
	}

	status_t SoundTrigger::guidToString(const sound_trigger_uuid_t guid, char str, size_t maxLen)
	{
	if (guid == NULL \|\| str == NULL) {
	return BAD_VALUE;
	}

	snprintf(str, maxLen, "%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x",
	guid->timeLow,
	guid->timeMid,
	guid->timeHiAndVersion,
	guid->clockSeq,
	guid->node[0],
	guid->node[1],
	guid->node[2],
	guid->node[3],
	guid->node[4],
	guid->node[5]);

	return NO_ERROR;
	}

	}; // namespace android