tequilaOS/platform_hardware_interfaces
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

soundtrigger: Apply clang-format to 2.0 default implementation

Browse source 
The implementation needs to be updated to become extensible.
The current coding style is not consistent with the style
required for hardware/interfaces.

Reformatted with:
   clang-format -style=file -i <...>/SoundTriggerHalImpl.*
No manual changes.

Bug: 68823037
Change-Id: I5f5cbb599190a515dec8afe9026ca835b8fd20fa
Test: make
This commit is contained in:
Mikhail Naganov 2017-12-22 13:23:08 -08:00
parent 882d2377ec
commit 0bbc4aa61f
2 changed files with 169 additions and 225 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

151
soundtrigger/2.0/default/SoundTriggerHalImpl.cpp
View file

@ -17,9 +17,8 @@
#define LOG_TAG "SoundTriggerHalImpl" #define LOG_TAG "SoundTriggerHalImpl"
//#define LOG_NDEBUG 0 //#define LOG_NDEBUG 0
#include <android/log.h>
#include "SoundTriggerHalImpl.h" #include "SoundTriggerHalImpl.h"
#include <android/log.h>
namespace android { namespace android {
namespace hardware { namespace hardware {
@ -29,8 +28,7 @@ namespace implementation {
// static // static
void SoundTriggerHalImpl::soundModelCallback(struct sound_trigger_model_event* halEvent, void SoundTriggerHalImpl::soundModelCallback(struct sound_trigger_model_event* halEvent,
void *cookie) void* cookie) {
{
if (halEvent == NULL) { if (halEvent == NULL) {
ALOGW("soundModelCallback called with NULL event"); ALOGW("soundModelCallback called with NULL event");
return; return;
@ -56,8 +54,7 @@ void SoundTriggerHalImpl::soundModelCallback(struct sound_trigger_model_event *h
// static // static
void SoundTriggerHalImpl::recognitionCallback(struct sound_trigger_recognition_event* halEvent, void SoundTriggerHalImpl::recognitionCallback(struct sound_trigger_recognition_event* halEvent,
void *cookie) void* cookie) {
{
if (halEvent == NULL) { if (halEvent == NULL) {
ALOGW("recognitionCallback call NULL event"); ALOGW("recognitionCallback call NULL event");
return; return;
@ -81,11 +78,8 @@ void SoundTriggerHalImpl::recognitionCallback(struct sound_trigger_recognition_e
delete event; delete event;
} }
// Methods from ::android::hardware::soundtrigger::V2_0::ISoundTriggerHw follow. // Methods from ::android::hardware::soundtrigger::V2_0::ISoundTriggerHw follow.
Return<void> SoundTriggerHalImpl::getProperties(getProperties_cb _hidl_cb) Return<void> SoundTriggerHalImpl::getProperties(getProperties_cb _hidl_cb) {
{
ALOGV("getProperties() mHwDevice %p", mHwDevice); ALOGV("getProperties() mHwDevice %p", mHwDevice);
int ret; int ret;
struct sound_trigger_properties halProperties; struct sound_trigger_properties halProperties;
@ -100,8 +94,8 @@ Return<void> SoundTriggerHalImpl::getProperties(getProperties_cb _hidl_cb)
convertPropertiesFromHal(&properties, &halProperties); convertPropertiesFromHal(&properties, &halProperties);
ALOGV("getProperties implementor %s recognitionModes %08x", ALOGV("getProperties implementor %s recognitionModes %08x", properties.implementor.c_str(),
properties.implementor.c_str(), properties.recognitionModes); properties.recognitionModes);
exit: exit:
_hidl_cb(ret, properties); _hidl_cb(ret, properties);
@ -111,8 +105,7 @@ exit:
int SoundTriggerHalImpl::doLoadSoundModel(const ISoundTriggerHw::SoundModel& soundModel, int SoundTriggerHalImpl::doLoadSoundModel(const ISoundTriggerHw::SoundModel& soundModel,
const sp<ISoundTriggerHwCallback>& callback, const sp<ISoundTriggerHwCallback>& callback,
ISoundTriggerHwCallback::CallbackCookie cookie, ISoundTriggerHwCallback::CallbackCookie cookie,
uint32_t *modelId) uint32_t* modelId) {
{
int32_t ret = 0; int32_t ret = 0;
struct sound_trigger_sound_model* halSoundModel; struct sound_trigger_sound_model* halSoundModel;
*modelId = 0; *modelId = 0;
@ -137,13 +130,13 @@ int SoundTriggerHalImpl::doLoadSoundModel(const ISoundTriggerHw::SoundModel& sou
*modelId = nextUniqueId(); *modelId = nextUniqueId();
} while (mClients.valueFor(*modelId) != 0 && *modelId != 0); } while (mClients.valueFor(*modelId) != 0 && *modelId != 0);
} }
LOG_ALWAYS_FATAL_IF(*modelId == 0, LOG_ALWAYS_FATAL_IF(*modelId == 0, "wrap around in sound model IDs, num loaded models %zu",
"wrap around in sound model IDs, num loaded models %zu", mClients.size()); mClients.size());
client = new SoundModelClient(*modelId, callback, cookie); client = new SoundModelClient(*modelId, callback, cookie);
ret = mHwDevice->load_sound_model(mHwDevice, halSoundModel, soundModelCallback, ret = mHwDevice->load_sound_model(mHwDevice, halSoundModel, soundModelCallback, client.get(),
client.get(), &client->mHalHandle); &client->mHalHandle);
free(halSoundModel); free(halSoundModel);
@ -163,8 +156,7 @@ exit:
Return<void> SoundTriggerHalImpl::loadSoundModel(const ISoundTriggerHw::SoundModel& soundModel, Return<void> SoundTriggerHalImpl::loadSoundModel(const ISoundTriggerHw::SoundModel& soundModel,
const sp<ISoundTriggerHwCallback>& callback, const sp<ISoundTriggerHwCallback>& callback,
ISoundTriggerHwCallback::CallbackCookie cookie, ISoundTriggerHwCallback::CallbackCookie cookie,
loadSoundModel_cb _hidl_cb) loadSoundModel_cb _hidl_cb) {
{
uint32_t modelId = 0; uint32_t modelId = 0;
int32_t ret = doLoadSoundModel(soundModel, callback, cookie, &modelId); int32_t ret = doLoadSoundModel(soundModel, callback, cookie, &modelId);
@ -174,20 +166,17 @@ Return<void> SoundTriggerHalImpl::loadSoundModel(const ISoundTriggerHw::SoundMod
Return<void> SoundTriggerHalImpl::loadPhraseSoundModel( Return<void> SoundTriggerHalImpl::loadPhraseSoundModel(
const ISoundTriggerHw::PhraseSoundModel& soundModel, const ISoundTriggerHw::PhraseSoundModel& soundModel,
const sp<ISoundTriggerHwCallback>& callback, const sp<ISoundTriggerHwCallback>& callback, ISoundTriggerHwCallback::CallbackCookie cookie,
ISoundTriggerHwCallback::CallbackCookie cookie, ISoundTriggerHw::loadPhraseSoundModel_cb _hidl_cb) {
ISoundTriggerHw::loadPhraseSoundModel_cb _hidl_cb)
{
uint32_t modelId = 0; uint32_t modelId = 0;
int32_t ret = doLoadSoundModel((const ISoundTriggerHw::SoundModel&)soundModel, int32_t ret = doLoadSoundModel((const ISoundTriggerHw::SoundModel&)soundModel, callback, cookie,
callback, cookie, &modelId); &modelId);
_hidl_cb(ret, modelId); _hidl_cb(ret, modelId);
return Void(); return Void();
} }
Return<int32_t> SoundTriggerHalImpl::unloadSoundModel(SoundModelHandle modelHandle) Return<int32_t> SoundTriggerHalImpl::unloadSoundModel(SoundModelHandle modelHandle) {
{
int32_t ret; int32_t ret;
sp<SoundModelClient> client; sp<SoundModelClient> client;
@ -213,11 +202,10 @@ exit:
return ret; return ret;
} }
Return<int32_t> SoundTriggerHalImpl::startRecognition(SoundModelHandle modelHandle, Return<int32_t> SoundTriggerHalImpl::startRecognition(
const ISoundTriggerHw::RecognitionConfig& config, SoundModelHandle modelHandle, const ISoundTriggerHw::RecognitionConfig& config,
const sp<ISoundTriggerHwCallback>& callback __unused, const sp<ISoundTriggerHwCallback>& callback __unused,
ISoundTriggerHwCallback::CallbackCookie cookie __unused) ISoundTriggerHwCallback::CallbackCookie cookie __unused) {
{
int32_t ret; int32_t ret;
sp<SoundModelClient> client; sp<SoundModelClient> client;
struct sound_trigger_recognition_config* halConfig; struct sound_trigger_recognition_config* halConfig;
@ -236,7 +224,6 @@ Return<int32_t> SoundTriggerHalImpl::startRecognition(SoundModelHandle modelHand
} }
} }
halConfig = convertRecognitionConfigToHal(&config); halConfig = convertRecognitionConfigToHal(&config);
if (halConfig == NULL) { if (halConfig == NULL) {
@ -252,8 +239,7 @@ exit:
return ret; return ret;
} }
Return<int32_t> SoundTriggerHalImpl::stopRecognition(SoundModelHandle modelHandle) Return<int32_t> SoundTriggerHalImpl::stopRecognition(SoundModelHandle modelHandle) {
{
int32_t ret; int32_t ret;
sp<SoundModelClient> client; sp<SoundModelClient> client;
if (mHwDevice == NULL) { if (mHwDevice == NULL) {
@ -276,8 +262,7 @@ exit:
return ret; return ret;
} }
Return<int32_t> SoundTriggerHalImpl::stopAllRecognitions() Return<int32_t> SoundTriggerHalImpl::stopAllRecognitions() {
{
int32_t ret; int32_t ret;
if (mHwDevice == NULL) { if (mHwDevice == NULL) {
ret = -ENODEV; ret = -ENODEV;
@ -295,19 +280,16 @@ exit:
} }
SoundTriggerHalImpl::SoundTriggerHalImpl() SoundTriggerHalImpl::SoundTriggerHalImpl()
: mModuleName("primary"), mHwDevice(NULL), mNextModelId(1) : mModuleName("primary"), mHwDevice(NULL), mNextModelId(1) {}
{
}
void SoundTriggerHalImpl::onFirstRef() void SoundTriggerHalImpl::onFirstRef() {
{
const hw_module_t* mod; const hw_module_t* mod;
int rc; int rc;
rc = hw_get_module_by_class(SOUND_TRIGGER_HARDWARE_MODULE_ID, mModuleName, &mod); rc = hw_get_module_by_class(SOUND_TRIGGER_HARDWARE_MODULE_ID, mModuleName, &mod);
if (rc != 0) { if (rc != 0) {
ALOGE("couldn't load sound trigger module %s.%s (%s)", ALOGE("couldn't load sound trigger module %s.%s (%s)", SOUND_TRIGGER_HARDWARE_MODULE_ID,
SOUND_TRIGGER_HARDWARE_MODULE_ID, mModuleName, strerror(-rc)); mModuleName, strerror(-rc));
return; return;
} }
rc = sound_trigger_hw_device_open(mod, &mHwDevice); rc = sound_trigger_hw_device_open(mod, &mHwDevice);
@ -328,22 +310,18 @@ void SoundTriggerHalImpl::onFirstRef()
ALOGI("onFirstRef() mModuleName %s mHwDevice %p", mModuleName, mHwDevice); ALOGI("onFirstRef() mModuleName %s mHwDevice %p", mModuleName, mHwDevice);
} }
SoundTriggerHalImpl::~SoundTriggerHalImpl() SoundTriggerHalImpl::~SoundTriggerHalImpl() {
{
if (mHwDevice != NULL) { if (mHwDevice != NULL) {
sound_trigger_hw_device_close(mHwDevice); sound_trigger_hw_device_close(mHwDevice);
} }
} }
uint32_t SoundTriggerHalImpl::nextUniqueId() uint32_t SoundTriggerHalImpl::nextUniqueId() {
{ return (uint32_t)atomic_fetch_add_explicit(&mNextModelId, (uint_fast32_t)1,
return (uint32_t) atomic_fetch_add_explicit(&mNextModelId, memory_order_acq_rel);
(uint_fast32_t) 1, memory_order_acq_rel);
} }
void SoundTriggerHalImpl::convertUuidFromHal(Uuid *uuid, void SoundTriggerHalImpl::convertUuidFromHal(Uuid* uuid, const sound_trigger_uuid_t* halUuid) {
const sound_trigger_uuid_t *halUuid)
{
uuid->timeLow = halUuid->timeLow; uuid->timeLow = halUuid->timeLow;
uuid->timeMid = halUuid->timeMid; uuid->timeMid = halUuid->timeMid;
uuid->versionAndTimeHigh = halUuid->timeHiAndVersion; uuid->versionAndTimeHigh = halUuid->timeHiAndVersion;
@ -351,9 +329,7 @@ void SoundTriggerHalImpl::convertUuidFromHal(Uuid *uuid,
memcpy(&uuid->node[0], &halUuid->node[0], 6); memcpy(&uuid->node[0], &halUuid->node[0], 6);
} }
void SoundTriggerHalImpl::convertUuidToHal(sound_trigger_uuid_t *halUuid, void SoundTriggerHalImpl::convertUuidToHal(sound_trigger_uuid_t* halUuid, const Uuid* uuid) {
const Uuid *uuid)
{
halUuid->timeLow = uuid->timeLow; halUuid->timeLow = uuid->timeLow;
halUuid->timeMid = uuid->timeMid; halUuid->timeMid = uuid->timeMid;
halUuid->timeHiAndVersion = uuid->versionAndTimeHigh; halUuid->timeHiAndVersion = uuid->versionAndTimeHigh;
@ -362,9 +338,7 @@ void SoundTriggerHalImpl::convertUuidToHal(sound_trigger_uuid_t *halUuid,
} }
void SoundTriggerHalImpl::convertPropertiesFromHal( void SoundTriggerHalImpl::convertPropertiesFromHal(
ISoundTriggerHw::Properties *properties, ISoundTriggerHw::Properties* properties, const struct sound_trigger_properties* halProperties) {
const struct sound_trigger_properties *halProperties)
{
properties->implementor = halProperties->implementor; properties->implementor = halProperties->implementor;
properties->description = halProperties->description; properties->description = halProperties->description;
properties->version = halProperties->version; properties->version = halProperties->version;
@ -378,13 +352,10 @@ void SoundTriggerHalImpl::convertPropertiesFromHal(
properties->concurrentCapture = halProperties->concurrent_capture; properties->concurrentCapture = halProperties->concurrent_capture;
properties->triggerInEvent = halProperties->trigger_in_event; properties->triggerInEvent = halProperties->trigger_in_event;
properties->powerConsumptionMw = halProperties->power_consumption_mw; properties->powerConsumptionMw = halProperties->power_consumption_mw;
} }
void SoundTriggerHalImpl::convertTriggerPhraseToHal( void SoundTriggerHalImpl::convertTriggerPhraseToHal(struct sound_trigger_phrase* halTriggerPhrase,
struct sound_trigger_phrase *halTriggerPhrase, const ISoundTriggerHw::Phrase* triggerPhrase) {
const ISoundTriggerHw::Phrase *triggerPhrase)
{
halTriggerPhrase->id = triggerPhrase->id; halTriggerPhrase->id = triggerPhrase->id;
halTriggerPhrase->recognition_mode = triggerPhrase->recognitionModes; halTriggerPhrase->recognition_mode = triggerPhrase->recognitionModes;
unsigned int i; unsigned int i;
@ -395,15 +366,12 @@ void SoundTriggerHalImpl::convertTriggerPhraseToHal(
halTriggerPhrase->users[i] = triggerPhrase->users[i]; halTriggerPhrase->users[i] = triggerPhrase->users[i];
} }
strlcpy(halTriggerPhrase->locale, strlcpy(halTriggerPhrase->locale, triggerPhrase->locale.c_str(), SOUND_TRIGGER_MAX_LOCALE_LEN);
triggerPhrase->locale.c_str(), SOUND_TRIGGER_MAX_LOCALE_LEN); strlcpy(halTriggerPhrase->text, triggerPhrase->text.c_str(), SOUND_TRIGGER_MAX_STRING_LEN);
strlcpy(halTriggerPhrase->text,
triggerPhrase->text.c_str(), SOUND_TRIGGER_MAX_STRING_LEN);
} }
struct sound_trigger_sound_model* SoundTriggerHalImpl::convertSoundModelToHal( struct sound_trigger_sound_model* SoundTriggerHalImpl::convertSoundModelToHal(
const ISoundTriggerHw::SoundModel *soundModel) const ISoundTriggerHw::SoundModel* soundModel) {
{
struct sound_trigger_sound_model* halModel = NULL; struct sound_trigger_sound_model* halModel = NULL;
if (soundModel->type == SoundModelType::KEYPHRASE) { if (soundModel->type == SoundModelType::KEYPHRASE) {
size_t allocSize = size_t allocSize =
@ -411,22 +379,21 @@ struct sound_trigger_sound_model *SoundTriggerHalImpl::convertSoundModelToHal(
struct sound_trigger_phrase_sound_model* halKeyPhraseModel = struct sound_trigger_phrase_sound_model* halKeyPhraseModel =
static_cast<struct sound_trigger_phrase_sound_model*>(malloc(allocSize)); static_cast<struct sound_trigger_phrase_sound_model*>(malloc(allocSize));
LOG_ALWAYS_FATAL_IF(halKeyPhraseModel == NULL, LOG_ALWAYS_FATAL_IF(halKeyPhraseModel == NULL,
"malloc failed for size %zu in convertSoundModelToHal PHRASE", allocSize); "malloc failed for size %zu in convertSoundModelToHal PHRASE",
allocSize);
const ISoundTriggerHw::PhraseSoundModel* keyPhraseModel = const ISoundTriggerHw::PhraseSoundModel* keyPhraseModel =
reinterpret_cast<const ISoundTriggerHw::PhraseSoundModel*>(soundModel); reinterpret_cast<const ISoundTriggerHw::PhraseSoundModel*>(soundModel);
size_t i; size_t i;
for (i = 0; i < keyPhraseModel->phrases.size() && i < SOUND_TRIGGER_MAX_PHRASES; i++) { for (i = 0; i < keyPhraseModel->phrases.size() && i < SOUND_TRIGGER_MAX_PHRASES; i++) {
convertTriggerPhraseToHal(&halKeyPhraseModel->phrases[i], convertTriggerPhraseToHal(&halKeyPhraseModel->phrases[i], &keyPhraseModel->phrases[i]);
&keyPhraseModel->phrases[i]);
} }
halKeyPhraseModel->num_phrases = (unsigned int)i; halKeyPhraseModel->num_phrases = (unsigned int)i;
halModel = reinterpret_cast<struct sound_trigger_sound_model*>(halKeyPhraseModel); halModel = reinterpret_cast<struct sound_trigger_sound_model*>(halKeyPhraseModel);
halModel->data_offset = sizeof(struct sound_trigger_phrase_sound_model); halModel->data_offset = sizeof(struct sound_trigger_phrase_sound_model);
} else { } else {
size_t allocSize = size_t allocSize = sizeof(struct sound_trigger_sound_model) + soundModel->data.size();
sizeof(struct sound_trigger_sound_model) + soundModel->data.size();
halModel = static_cast<struct sound_trigger_sound_model*>(malloc(allocSize)); halModel = static_cast<struct sound_trigger_sound_model*>(malloc(allocSize));
LOG_ALWAYS_FATAL_IF(halModel == NULL, LOG_ALWAYS_FATAL_IF(halModel == NULL,
"malloc failed for size %zu in convertSoundModelToHal GENERIC", "malloc failed for size %zu in convertSoundModelToHal GENERIC",
@ -446,9 +413,7 @@ struct sound_trigger_sound_model *SoundTriggerHalImpl::convertSoundModelToHal(
} }
void SoundTriggerHalImpl::convertPhraseRecognitionExtraToHal( void SoundTriggerHalImpl::convertPhraseRecognitionExtraToHal(
struct sound_trigger_phrase_recognition_extra *halExtra, struct sound_trigger_phrase_recognition_extra* halExtra, const PhraseRecognitionExtra* extra) {
const PhraseRecognitionExtra *extra)
{
halExtra->id = extra->id; halExtra->id = extra->id;
halExtra->recognition_modes = extra->recognitionModes; halExtra->recognition_modes = extra->recognitionModes;
halExtra->confidence_level = extra->confidenceLevel; halExtra->confidence_level = extra->confidenceLevel;
@ -462,15 +427,13 @@ void SoundTriggerHalImpl::convertPhraseRecognitionExtraToHal(
} }
struct sound_trigger_recognition_config* SoundTriggerHalImpl::convertRecognitionConfigToHal( struct sound_trigger_recognition_config* SoundTriggerHalImpl::convertRecognitionConfigToHal(
const ISoundTriggerHw::RecognitionConfig *config) const ISoundTriggerHw::RecognitionConfig* config) {
{
size_t allocSize = sizeof(struct sound_trigger_recognition_config) + config->data.size(); size_t allocSize = sizeof(struct sound_trigger_recognition_config) + config->data.size();
struct sound_trigger_recognition_config* halConfig = struct sound_trigger_recognition_config* halConfig =
static_cast<struct sound_trigger_recognition_config*>(malloc(allocSize)); static_cast<struct sound_trigger_recognition_config*>(malloc(allocSize));
LOG_ALWAYS_FATAL_IF(halConfig == NULL, LOG_ALWAYS_FATAL_IF(halConfig == NULL,
"malloc failed for size %zu in convertRecognitionConfigToHal", "malloc failed for size %zu in convertRecognitionConfigToHal", allocSize);
allocSize);
halConfig->capture_handle = (audio_io_handle_t)config->captureHandle; halConfig->capture_handle = (audio_io_handle_t)config->captureHandle;
halConfig->capture_device = (audio_devices_t)config->captureDevice; halConfig->capture_device = (audio_devices_t)config->captureDevice;
@ -478,8 +441,7 @@ struct sound_trigger_recognition_config *SoundTriggerHalImpl::convertRecognition
unsigned int i; unsigned int i;
for (i = 0; i < config->phrases.size() && i < SOUND_TRIGGER_MAX_PHRASES; i++) { for (i = 0; i < config->phrases.size() && i < SOUND_TRIGGER_MAX_PHRASES; i++) {
convertPhraseRecognitionExtraToHal(&halConfig->phrases[i], convertPhraseRecognitionExtraToHal(&halConfig->phrases[i], &config->phrases[i]);
&config->phrases[i]);
} }
halConfig->num_phrases = i; halConfig->num_phrases = i;
@ -492,9 +454,8 @@ struct sound_trigger_recognition_config *SoundTriggerHalImpl::convertRecognition
} }
// static // static
void SoundTriggerHalImpl::convertSoundModelEventFromHal(ISoundTriggerHwCallback::ModelEvent *event, void SoundTriggerHalImpl::convertSoundModelEventFromHal(
const struct sound_trigger_model_event *halEvent) ISoundTriggerHwCallback::ModelEvent* event, const struct sound_trigger_model_event* halEvent) {
{
event->status = (ISoundTriggerHwCallback::SoundModelStatus)halEvent->status; event->status = (ISoundTriggerHwCallback::SoundModelStatus)halEvent->status;
// event->model to be remapped by called // event->model to be remapped by called
event->data.setToExternal( event->data.setToExternal(
@ -504,8 +465,7 @@ void SoundTriggerHalImpl::convertSoundModelEventFromHal(ISoundTriggerHwCallback:
// static // static
ISoundTriggerHwCallback::RecognitionEvent* SoundTriggerHalImpl::convertRecognitionEventFromHal( ISoundTriggerHwCallback::RecognitionEvent* SoundTriggerHalImpl::convertRecognitionEventFromHal(
const struct sound_trigger_recognition_event *halEvent) const struct sound_trigger_recognition_event* halEvent) {
{
ISoundTriggerHwCallback::RecognitionEvent* event; ISoundTriggerHwCallback::RecognitionEvent* event;
if (halEvent->type == SOUND_MODEL_TYPE_KEYPHRASE) { if (halEvent->type == SOUND_MODEL_TYPE_KEYPHRASE) {
@ -550,15 +510,12 @@ ISoundTriggerHwCallback::RecognitionEvent *SoundTriggerHalImpl::convertRecogniti
// static // static
void SoundTriggerHalImpl::convertPhraseRecognitionExtraFromHal( void SoundTriggerHalImpl::convertPhraseRecognitionExtraFromHal(
PhraseRecognitionExtra *extra, PhraseRecognitionExtra* extra, const struct sound_trigger_phrase_recognition_extra* halExtra) {
const struct sound_trigger_phrase_recognition_extra *halExtra)
{
extra->id = halExtra->id; extra->id = halExtra->id;
extra->recognitionModes = halExtra->recognition_modes; extra->recognitionModes = halExtra->recognition_modes;
extra->confidenceLevel = halExtra->confidence_level; extra->confidenceLevel = halExtra->confidence_level;
ConfidenceLevel *levels = ConfidenceLevel* levels = new ConfidenceLevel[halExtra->num_levels];
new ConfidenceLevel[halExtra->num_levels];
for (unsigned int i = 0; i < halExtra->num_levels; i++) { for (unsigned int i = 0; i < halExtra->num_levels; i++) {
levels[i].userId = halExtra->levels[i].user_id; levels[i].userId = halExtra->levels[i].user_id;
levels[i].levelPercent = halExtra->levels[i].level; levels[i].levelPercent = halExtra->levels[i].level;
@ -569,8 +526,7 @@ void SoundTriggerHalImpl::convertPhraseRecognitionExtraFromHal(
delete[] levels; delete[] levels;
} }
ISoundTriggerHw *HIDL_FETCH_ISoundTriggerHw(const char* /* name */) ISoundTriggerHw* HIDL_FETCH_ISoundTriggerHw(const char* /* name */) {
{
return new SoundTriggerHalImpl(); return new SoundTriggerHalImpl();
} }
} // namespace implementation } // namespace implementation
@ -578,6 +534,3 @@ ISoundTriggerHw *HIDL_FETCH_ISoundTriggerHw(const char* /* name */)
} // namespace soundtrigger } // namespace soundtrigger
} // namespace hardware } // namespace hardware
} // namespace android } // namespace android

31
soundtrigger/2.0/default/SoundTriggerHalImpl.h
View file

@ -19,12 +19,12 @@
#include <android/hardware/soundtrigger/2.0/ISoundTriggerHw.h> #include <android/hardware/soundtrigger/2.0/ISoundTriggerHw.h>
#include <android/hardware/soundtrigger/2.0/ISoundTriggerHwCallback.h> #include <android/hardware/soundtrigger/2.0/ISoundTriggerHwCallback.h>
#include <hardware/sound_trigger.h>
#include <hidl/Status.h> #include <hidl/Status.h>
#include <stdatomic.h> #include <stdatomic.h>
#include <utils/threads.h>
#include <utils/KeyedVector.h>
#include <system/sound_trigger.h> #include <system/sound_trigger.h>
#include <hardware/sound_trigger.h> #include <utils/KeyedVector.h>
#include <utils/threads.h>
namespace android { namespace android {
namespace hardware { namespace hardware {
@ -35,7 +35,6 @@ namespace implementation {
using ::android::hardware::audio::common::V2_0::Uuid; using ::android::hardware::audio::common::V2_0::Uuid;
using ::android::hardware::soundtrigger::V2_0::ISoundTriggerHwCallback; using ::android::hardware::soundtrigger::V2_0::ISoundTriggerHwCallback;
class SoundTriggerHalImpl : public ISoundTriggerHw { class SoundTriggerHalImpl : public ISoundTriggerHw {
public: public:
SoundTriggerHalImpl(); SoundTriggerHalImpl();
@ -62,13 +61,10 @@ public:
// RefBase // RefBase
virtual void onFirstRef(); virtual void onFirstRef();
static void soundModelCallback(struct sound_trigger_model_event *halEvent, static void soundModelCallback(struct sound_trigger_model_event* halEvent, void* cookie);
void *cookie); static void recognitionCallback(struct sound_trigger_recognition_event* halEvent, void* cookie);
static void recognitionCallback(struct sound_trigger_recognition_event *halEvent,
void *cookie);
private: private:
class SoundModelClient : public RefBase { class SoundModelClient : public RefBase {
public: public:
SoundModelClient(uint32_t id, sp<ISoundTriggerHwCallback> callback, SoundModelClient(uint32_t id, sp<ISoundTriggerHwCallback> callback,
@ -83,10 +79,8 @@ private:
}; };
uint32_t nextUniqueId(); uint32_t nextUniqueId();
void convertUuidFromHal(Uuid *uuid, void convertUuidFromHal(Uuid* uuid, const sound_trigger_uuid_t* halUuid);
const sound_trigger_uuid_t *halUuid); void convertUuidToHal(sound_trigger_uuid_t* halUuid, const Uuid* uuid);
void convertUuidToHal(sound_trigger_uuid_t *halUuid,
const Uuid *uuid);
void convertPropertiesFromHal(ISoundTriggerHw::Properties* properties, void convertPropertiesFromHal(ISoundTriggerHw::Properties* properties,
const struct sound_trigger_properties* halProperties); const struct sound_trigger_properties* halProperties);
void convertTriggerPhraseToHal(struct sound_trigger_phrase* halTriggerPhrase, void convertTriggerPhraseToHal(struct sound_trigger_phrase* halTriggerPhrase,
@ -94,25 +88,23 @@ private:
// returned HAL sound model must be freed by caller // returned HAL sound model must be freed by caller
struct sound_trigger_sound_model* convertSoundModelToHal( struct sound_trigger_sound_model* convertSoundModelToHal(
const ISoundTriggerHw::SoundModel* soundModel); const ISoundTriggerHw::SoundModel* soundModel);
void convertPhraseRecognitionExtraToHal( void convertPhraseRecognitionExtraToHal(struct sound_trigger_phrase_recognition_extra* halExtra,
struct sound_trigger_phrase_recognition_extra *halExtra,
const PhraseRecognitionExtra* extra); const PhraseRecognitionExtra* extra);
// returned recognition config must be freed by caller // returned recognition config must be freed by caller
struct sound_trigger_recognition_config* convertRecognitionConfigToHal( struct sound_trigger_recognition_config* convertRecognitionConfigToHal(
const ISoundTriggerHw::RecognitionConfig* config); const ISoundTriggerHw::RecognitionConfig* config);
static void convertSoundModelEventFromHal(ISoundTriggerHwCallback::ModelEvent* event, static void convertSoundModelEventFromHal(ISoundTriggerHwCallback::ModelEvent* event,
const struct sound_trigger_model_event* halEvent); const struct sound_trigger_model_event* halEvent);
static ISoundTriggerHwCallback::RecognitionEvent* convertRecognitionEventFromHal( static ISoundTriggerHwCallback::RecognitionEvent* convertRecognitionEventFromHal(
const struct sound_trigger_recognition_event* halEvent); const struct sound_trigger_recognition_event* halEvent);
static void convertPhraseRecognitionExtraFromHal(PhraseRecognitionExtra *extra, static void convertPhraseRecognitionExtraFromHal(
PhraseRecognitionExtra* extra,
const struct sound_trigger_phrase_recognition_extra* halExtra); const struct sound_trigger_phrase_recognition_extra* halExtra);
int doLoadSoundModel(const ISoundTriggerHw::SoundModel& soundModel, int doLoadSoundModel(const ISoundTriggerHw::SoundModel& soundModel,
const sp<ISoundTriggerHwCallback>& callback, const sp<ISoundTriggerHwCallback>& callback,
ISoundTriggerHwCallback::CallbackCookie cookie, ISoundTriggerHwCallback::CallbackCookie cookie, uint32_t* modelId);
uint32_t *modelId);
virtual ~SoundTriggerHalImpl(); virtual ~SoundTriggerHalImpl();
@ -132,4 +124,3 @@ extern "C" ISoundTriggerHw *HIDL_FETCH_ISoundTriggerHw(const char *name);
} // namespace android } // namespace android
#endif // ANDROID_HARDWARE_SOUNDTRIGGER_V2_0_IMPLEMENTATION_H #endif // ANDROID_HARDWARE_SOUNDTRIGGER_V2_0_IMPLEMENTATION_H