services/soundtrigger/SoundTriggerHalHidl.cpp

/*
 * Copyright (C) 2016 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 "SoundTriggerHalHidl"
//#define LOG_NDEBUG 0

#include <android/hidl/allocator/1.0/IAllocator.h>
#include <media/audiohal/hidl/HalDeathHandler.h>
#include <utils/Log.h>
#include "SoundTriggerHalHidl.h"
#include <hidlmemory/mapping.h>
#include <hwbinder/IPCThreadState.h>
#include <hwbinder/ProcessState.h>

namespace android {

using ::android::hardware::ProcessState;
using ::android::hardware::Return;
using ::android::hardware::Status;
using ::android::hardware::Void;
using ::android::hardware::audio::common::V2_0::AudioDevice;
using ::android::hardware::hidl_memory;
using ::android::hidl::allocator::V1_0::IAllocator;
using ::android::hidl::memory::V1_0::IMemory;

namespace {

// Backs up by the vector with the contents of shared memory.
// It is assumed that the passed hidl_vector is empty, so it's
// not cleared if the memory is a null object.
// The caller needs to keep the returned sp<IMemory> as long as
// the data is needed.
std::pair<bool, sp<IMemory>> memoryAsVector(const hidl_memory& m, hidl_vec<uint8_t>* vec) {
    sp<IMemory> memory;
    if (m.size() == 0) {
        return std::make_pair(true, memory);
    }
    memory = mapMemory(m);
    if (memory != nullptr) {
        memory->read();
        vec->setToExternal(static_cast<uint8_t*>(static_cast<void*>(memory->getPointer())),
                memory->getSize());
        return std::make_pair(true, memory);
    }
    ALOGE("%s: Could not map HIDL memory to IMemory", __func__);
    return std::make_pair(false, memory);
}

// Moves the data from the vector into allocated shared memory,
// emptying the vector.
// It is assumed that the passed hidl_memory is a null object, so it's
// not reset if the vector is empty.
// The caller needs to keep the returned sp<IMemory> as long as
// the data is needed.
std::pair<bool, sp<IMemory>> moveVectorToMemory(hidl_vec<uint8_t>* v, hidl_memory* mem) {
    sp<IMemory> memory;
    if (v->size() == 0) {
        return std::make_pair(true, memory);
    }
    sp<IAllocator> ashmem = IAllocator::getService("ashmem");
    if (ashmem == 0) {
        ALOGE("Failed to retrieve ashmem allocator service");
        return std::make_pair(false, memory);
    }
    bool success = false;
    Return<void> r = ashmem->allocate(v->size(), [&](bool s, const hidl_memory& m) {
        success = s;
        if (success) *mem = m;
    });
    if (r.isOk() && success) {
        memory = hardware::mapMemory(*mem);
        if (memory != 0) {
            memory->update();
            memcpy(memory->getPointer(), v->data(), v->size());
            memory->commit();
            v->resize(0);
            return std::make_pair(true, memory);
        } else {
            ALOGE("Failed to map allocated ashmem");
        }
    } else {
        ALOGE("Failed to allocate %llu bytes from ashmem", (unsigned long long)v->size());
    }
    return std::make_pair(false, memory);
}

}  // namespace

/* static */
sp<SoundTriggerHalInterface> SoundTriggerHalInterface::connectModule(const char *moduleName)
{
    return new SoundTriggerHalHidl(moduleName);
}

int SoundTriggerHalHidl::getProperties(struct sound_trigger_properties *properties)
{
    sp<ISoundTriggerHw> soundtrigger = getService();
    if (soundtrigger == 0) {
        return -ENODEV;
    }

    ISoundTriggerHw::Properties halProperties;
    Return<void> hidlReturn;
    int ret;
    {
        AutoMutex lock(mHalLock);
        hidlReturn = soundtrigger->getProperties([&](int rc, auto res) {
            ret = rc;
            halProperties = res;
            ALOGI("getProperties res implementor %s", res.implementor.c_str());
        });
    }

    if (hidlReturn.isOk()) {
        if (ret == 0) {
            convertPropertiesFromHal(properties, &halProperties);
        }
    } else {
        ALOGE("getProperties error %s", hidlReturn.description().c_str());
        return FAILED_TRANSACTION;
    }
    ALOGI("getProperties ret %d", ret);
    return ret;
}

int SoundTriggerHalHidl::loadSoundModel(struct sound_trigger_sound_model *sound_model,
                        sound_model_callback_t callback,
                        void *cookie,
                        sound_model_handle_t *handle)
{
    if (handle == NULL) {
        return -EINVAL;
    }

    sp<ISoundTriggerHw> soundtrigger = getService();
    if (soundtrigger == 0) {
        return -ENODEV;
    }

    uint32_t modelId;
    {
        AutoMutex lock(mLock);
        do {
            modelId = nextUniqueId();
            ALOGI("loadSoundModel modelId %u", modelId);
            sp<SoundModel> model = mSoundModels.valueFor(modelId);
            ALOGI("loadSoundModel model %p", model.get());
        } while (mSoundModels.valueFor(modelId) != 0 && modelId != 0);
    }
    LOG_ALWAYS_FATAL_IF(modelId == 0,
                        "loadSoundModel(): wrap around in sound model IDs, num loaded models %zd",
                        mSoundModels.size());

    Return<void> hidlReturn;
    int ret;
    SoundModelHandle halHandle;
    sp<V2_1_ISoundTriggerHw> soundtrigger_2_1 = toService2_1(soundtrigger);
    if (sound_model->type == SOUND_MODEL_TYPE_KEYPHRASE) {
        if (!soundtrigger_2_1) {
            ISoundTriggerHw::PhraseSoundModel halSoundModel;
            convertPhraseSoundModelToHal(&halSoundModel, sound_model);
            AutoMutex lock(mHalLock);
            hidlReturn = soundtrigger->loadPhraseSoundModel(
                    halSoundModel,
                    this, modelId, [&](int32_t retval, auto res) {
                        ret = retval;
                        halHandle = res;
                    });
        } else {
            V2_1_ISoundTriggerHw::PhraseSoundModel halSoundModel;
            auto result = convertPhraseSoundModelToHal(&halSoundModel, sound_model);
            if (result.first) {
                AutoMutex lock(mHalLock);
                hidlReturn = soundtrigger_2_1->loadPhraseSoundModel_2_1(
                        halSoundModel,
                        this, modelId, [&](int32_t retval, auto res) {
                            ret = retval;
                            halHandle = res;
                        });
            } else {
                return NO_MEMORY;
            }
        }
    } else {
        if (!soundtrigger_2_1) {
            ISoundTriggerHw::SoundModel halSoundModel;
            convertSoundModelToHal(&halSoundModel, sound_model);
            AutoMutex lock(mHalLock);
            hidlReturn = soundtrigger->loadSoundModel(halSoundModel,
                    this, modelId, [&](int32_t retval, auto res) {
                        ret = retval;
                        halHandle = res;
                    });
        } else {
            V2_1_ISoundTriggerHw::SoundModel halSoundModel;
            auto result = convertSoundModelToHal(&halSoundModel, sound_model);
            if (result.first) {
                AutoMutex lock(mHalLock);
                hidlReturn = soundtrigger_2_1->loadSoundModel_2_1(halSoundModel,
                        this, modelId, [&](int32_t retval, auto res) {
                            ret = retval;
                            halHandle = res;
                        });
            } else {
                return NO_MEMORY;
            }
        }
    }

    if (hidlReturn.isOk()) {
        if (ret == 0) {
            AutoMutex lock(mLock);
            *handle = (sound_model_handle_t)modelId;
            sp<SoundModel> model = new SoundModel(*handle, callback, cookie, halHandle);
            mSoundModels.add(*handle, model);
        }
    } else {
        ALOGE("loadSoundModel error %s", hidlReturn.description().c_str());
        return FAILED_TRANSACTION;
    }

    return ret;
}

int SoundTriggerHalHidl::unloadSoundModel(sound_model_handle_t handle)
{
    sp<ISoundTriggerHw> soundtrigger = getService();
    if (soundtrigger == 0) {
        return -ENODEV;
    }

    sp<SoundModel> model = removeModel(handle);
    if (model == 0) {
        ALOGE("unloadSoundModel model not found for handle %u", handle);
        return -EINVAL;
    }

    Return<int32_t> hidlReturn(0);
    {
        AutoMutex lock(mHalLock);
        hidlReturn = soundtrigger->unloadSoundModel(model->mHalHandle);
    }

    if (!hidlReturn.isOk()) {
        ALOGE("unloadSoundModel error %s", hidlReturn.description().c_str());
        return FAILED_TRANSACTION;
    }

    return hidlReturn;
}

int SoundTriggerHalHidl::startRecognition(sound_model_handle_t handle,
                         const struct sound_trigger_recognition_config *config,
                         recognition_callback_t callback,
                         void *cookie)
{
    sp<ISoundTriggerHw> soundtrigger = getService();
    if (soundtrigger == 0) {
        return -ENODEV;
    }

    sp<SoundModel> model = getModel(handle);
    if (model == 0) {
        ALOGE("startRecognition model not found for handle %u", handle);
        return -EINVAL;
    }

    model->mRecognitionCallback = callback;
    model->mRecognitionCookie = cookie;

    sp<V2_1_ISoundTriggerHw> soundtrigger_2_1 = toService2_1(soundtrigger);
    Return<int32_t> hidlReturn(0);

    if (!soundtrigger_2_1) {
        ISoundTriggerHw::RecognitionConfig halConfig;
        convertRecognitionConfigToHal(&halConfig, config);
        {
            AutoMutex lock(mHalLock);
            hidlReturn = soundtrigger->startRecognition(model->mHalHandle, halConfig, this, handle);
        }
    } else {
        V2_1_ISoundTriggerHw::RecognitionConfig halConfig;
        auto result = convertRecognitionConfigToHal(&halConfig, config);
        if (result.first) {
            AutoMutex lock(mHalLock);
            hidlReturn = soundtrigger_2_1->startRecognition_2_1(
                    model->mHalHandle, halConfig, this, handle);
        } else {
            return NO_MEMORY;
        }
    }

    if (!hidlReturn.isOk()) {
        ALOGE("startRecognition error %s", hidlReturn.description().c_str());
        return FAILED_TRANSACTION;
    }
    return hidlReturn;
}

int SoundTriggerHalHidl::stopRecognition(sound_model_handle_t handle)
{
    sp<ISoundTriggerHw> soundtrigger = getService();
    if (soundtrigger == 0) {
        return -ENODEV;
    }

    sp<SoundModel> model = getModel(handle);
    if (model == 0) {
        ALOGE("stopRecognition model not found for handle %u", handle);
        return -EINVAL;
    }

    Return<int32_t> hidlReturn(0);
    {
        AutoMutex lock(mHalLock);
        hidlReturn = soundtrigger->stopRecognition(model->mHalHandle);
    }

    if (!hidlReturn.isOk()) {
        ALOGE("stopRecognition error %s", hidlReturn.description().c_str());
        return FAILED_TRANSACTION;
    }
    return hidlReturn;
}

int SoundTriggerHalHidl::stopAllRecognitions()
{
    sp<ISoundTriggerHw> soundtrigger = getService();
    if (soundtrigger == 0) {
        return -ENODEV;
    }

    Return<int32_t> hidlReturn(0);
    {
        AutoMutex lock(mHalLock);
        hidlReturn = soundtrigger->stopAllRecognitions();
    }

    if (!hidlReturn.isOk()) {
        ALOGE("stopAllRecognitions error %s", hidlReturn.description().c_str());
        return FAILED_TRANSACTION;
    }
    return hidlReturn;
}

SoundTriggerHalHidl::SoundTriggerHalHidl(const char *moduleName)
    : mModuleName(moduleName), mNextUniqueId(1)
{
    LOG_ALWAYS_FATAL_IF(strcmp(mModuleName, "primary") != 0,
            "Treble soundtrigger only supports primary module");
}

SoundTriggerHalHidl::~SoundTriggerHalHidl()
{
}

sp<ISoundTriggerHw> SoundTriggerHalHidl::getService()
{
    AutoMutex lock(mLock);
    if (mISoundTrigger == 0) {
        if (mModuleName == NULL) {
            mModuleName = "primary";
        }
        mISoundTrigger = ISoundTriggerHw::getService();
        if (mISoundTrigger != 0) {
            mISoundTrigger->linkToDeath(HalDeathHandler::getInstance(), 0 /*cookie*/);
        }
    }
    return mISoundTrigger;
}

sp<V2_1_ISoundTriggerHw> SoundTriggerHalHidl::toService2_1(const sp<ISoundTriggerHw>& s)
{
    auto castResult_2_1 = V2_1_ISoundTriggerHw::castFrom(s);
    return castResult_2_1.isOk() ? static_cast<sp<V2_1_ISoundTriggerHw>>(castResult_2_1) : nullptr;
}

sp<SoundTriggerHalHidl::SoundModel> SoundTriggerHalHidl::getModel(sound_model_handle_t handle)
{
    AutoMutex lock(mLock);
    return mSoundModels.valueFor(handle);
}

sp<SoundTriggerHalHidl::SoundModel> SoundTriggerHalHidl::removeModel(sound_model_handle_t handle)
{
    AutoMutex lock(mLock);
    sp<SoundModel> model = mSoundModels.valueFor(handle);
    mSoundModels.removeItem(handle);
    return model;
}

uint32_t SoundTriggerHalHidl::nextUniqueId()
{
    return (uint32_t) atomic_fetch_add_explicit(&mNextUniqueId,
                (uint_fast32_t) 1, memory_order_acq_rel);
}

void SoundTriggerHalHidl::convertUuidToHal(Uuid *halUuid,
                                           const sound_trigger_uuid_t *uuid)
{
    halUuid->timeLow = uuid->timeLow;
    halUuid->timeMid = uuid->timeMid;
    halUuid->versionAndTimeHigh = uuid->timeHiAndVersion;
    halUuid->variantAndClockSeqHigh = uuid->clockSeq;
    memcpy(halUuid->node.data(), &uuid->node[0], sizeof(uuid->node));
}

void SoundTriggerHalHidl::convertUuidFromHal(sound_trigger_uuid_t *uuid,
                                             const Uuid *halUuid)
{
    uuid->timeLow = halUuid->timeLow;
    uuid->timeMid = halUuid->timeMid;
    uuid->timeHiAndVersion = halUuid->versionAndTimeHigh;
    uuid->clockSeq = halUuid->variantAndClockSeqHigh;
    memcpy(&uuid->node[0], halUuid->node.data(), sizeof(uuid->node));
}

void SoundTriggerHalHidl::convertPropertiesFromHal(
        struct sound_trigger_properties *properties,
        const ISoundTriggerHw::Properties *halProperties)
{
    strlcpy(properties->implementor,
            halProperties->implementor.c_str(), SOUND_TRIGGER_MAX_STRING_LEN);
    strlcpy(properties->description,
            halProperties->description.c_str(), SOUND_TRIGGER_MAX_STRING_LEN);
    properties->version = halProperties->version;
    convertUuidFromHal(&properties->uuid, &halProperties->uuid);
    properties->max_sound_models = halProperties->maxSoundModels;
    properties->max_key_phrases = halProperties->maxKeyPhrases;
    properties->max_users = halProperties->maxUsers;
    properties->recognition_modes = halProperties->recognitionModes;
    properties->capture_transition = (bool)halProperties->captureTransition;
    properties->max_buffer_ms = halProperties->maxBufferMs;
    properties->concurrent_capture = (bool)halProperties->concurrentCapture;
    properties->trigger_in_event = (bool)halProperties->triggerInEvent;
    properties->power_consumption_mw = halProperties->powerConsumptionMw;
}

void SoundTriggerHalHidl::convertTriggerPhraseToHal(
        ISoundTriggerHw::Phrase *halTriggerPhrase,
        const struct sound_trigger_phrase *triggerPhrase)
{
    halTriggerPhrase->id = triggerPhrase->id;
    halTriggerPhrase->recognitionModes = triggerPhrase->recognition_mode;
    halTriggerPhrase->users.setToExternal((uint32_t *)&triggerPhrase->users[0], triggerPhrase->num_users);
    halTriggerPhrase->locale = triggerPhrase->locale;
    halTriggerPhrase->text = triggerPhrase->text;
}


void SoundTriggerHalHidl::convertTriggerPhrasesToHal(
        hidl_vec<ISoundTriggerHw::Phrase> *halTriggerPhrases,
        struct sound_trigger_phrase_sound_model *keyPhraseModel)
{
    halTriggerPhrases->resize(keyPhraseModel->num_phrases);
    for (unsigned int i = 0; i < keyPhraseModel->num_phrases; i++) {
        convertTriggerPhraseToHal(&(*halTriggerPhrases)[i], &keyPhraseModel->phrases[i]);
    }
}

void SoundTriggerHalHidl::convertSoundModelToHal(ISoundTriggerHw::SoundModel *halModel,
        const struct sound_trigger_sound_model *soundModel)
{
    halModel->type = (SoundModelType)soundModel->type;
    convertUuidToHal(&halModel->uuid, &soundModel->uuid);
    convertUuidToHal(&halModel->vendorUuid, &soundModel->vendor_uuid);
    halModel->data.setToExternal((uint8_t *)soundModel + soundModel->data_offset, soundModel->data_size);
}

std::pair<bool, sp<IMemory>> SoundTriggerHalHidl::convertSoundModelToHal(
        V2_1_ISoundTriggerHw::SoundModel *halModel,
        const struct sound_trigger_sound_model *soundModel)
{
    convertSoundModelToHal(&halModel->header, soundModel);
    return moveVectorToMemory(&halModel->header.data, &halModel->data);
}

void SoundTriggerHalHidl::convertPhraseSoundModelToHal(
        ISoundTriggerHw::PhraseSoundModel *halKeyPhraseModel,
        const struct sound_trigger_sound_model *soundModel)
{
    struct sound_trigger_phrase_sound_model *keyPhraseModel =
            (struct sound_trigger_phrase_sound_model *)soundModel;
    convertTriggerPhrasesToHal(&halKeyPhraseModel->phrases, keyPhraseModel);
    convertSoundModelToHal(&halKeyPhraseModel->common, soundModel);
}

std::pair<bool, sp<IMemory>> SoundTriggerHalHidl::convertPhraseSoundModelToHal(
        V2_1_ISoundTriggerHw::PhraseSoundModel *halKeyPhraseModel,
        const struct sound_trigger_sound_model *soundModel)
{
    struct sound_trigger_phrase_sound_model *keyPhraseModel =
            (struct sound_trigger_phrase_sound_model *)soundModel;
    convertTriggerPhrasesToHal(&halKeyPhraseModel->phrases, keyPhraseModel);
    return convertSoundModelToHal(&halKeyPhraseModel->common, soundModel);
}

void SoundTriggerHalHidl::convertPhraseRecognitionExtraToHal(
        PhraseRecognitionExtra *halExtra,
        const struct sound_trigger_phrase_recognition_extra *extra)
{
    halExtra->id = extra->id;
    halExtra->recognitionModes = extra->recognition_modes;
    halExtra->confidenceLevel = extra->confidence_level;
    halExtra->levels.resize(extra->num_levels);
    for (unsigned int i = 0; i < extra->num_levels; i++) {
        halExtra->levels[i].userId = extra->levels[i].user_id;
        halExtra->levels[i].levelPercent = extra->levels[i].level;
    }
}

void SoundTriggerHalHidl::convertRecognitionConfigToHal(
        ISoundTriggerHw::RecognitionConfig *halConfig,
        const struct sound_trigger_recognition_config *config)
{
    halConfig->captureHandle = config->capture_handle;
    halConfig->captureDevice = (AudioDevice)config->capture_device;
    halConfig->captureRequested = (uint32_t)config->capture_requested;

    halConfig->phrases.resize(config->num_phrases);
    for (unsigned int i = 0; i < config->num_phrases; i++) {
        convertPhraseRecognitionExtraToHal(&halConfig->phrases[i],
                                  &config->phrases[i]);
    }

    halConfig->data.setToExternal((uint8_t *)config + config->data_offset, config->data_size);
}

std::pair<bool, sp<IMemory>> SoundTriggerHalHidl::convertRecognitionConfigToHal(
        V2_1_ISoundTriggerHw::RecognitionConfig *halConfig,
        const struct sound_trigger_recognition_config *config)
{
    convertRecognitionConfigToHal(&halConfig->header, config);
    return moveVectorToMemory(&halConfig->header.data, &halConfig->data);
}


// ISoundTriggerHwCallback
::android::hardware::Return<void> SoundTriggerHalHidl::recognitionCallback(
        const V2_0_ISoundTriggerHwCallback::RecognitionEvent& halEvent,
        CallbackCookie cookie)
{
    sp<SoundModel> model;
    {
        AutoMutex lock(mLock);
        model = mSoundModels.valueFor((SoundModelHandle)cookie);
        if (model == 0) {
            return Return<void>();
        }
    }
    struct sound_trigger_recognition_event *event = convertRecognitionEventFromHal(&halEvent);
    if (event == NULL) {
        return Return<void>();
    }
    event->model = model->mHandle;
    model->mRecognitionCallback(event, model->mRecognitionCookie);

    free(event);

    return Return<void>();
}

::android::hardware::Return<void> SoundTriggerHalHidl::phraseRecognitionCallback(
        const V2_0_ISoundTriggerHwCallback::PhraseRecognitionEvent& halEvent,
        CallbackCookie cookie)
{
    sp<SoundModel> model;
    {
        AutoMutex lock(mLock);
        model = mSoundModels.valueFor((SoundModelHandle)cookie);
        if (model == 0) {
            return Return<void>();
        }
    }

    struct sound_trigger_phrase_recognition_event *event =
            convertPhraseRecognitionEventFromHal(&halEvent);
    if (event == NULL) {
        return Return<void>();
    }
    event->common.model = model->mHandle;
    model->mRecognitionCallback(&event->common, model->mRecognitionCookie);

    free(event);

    return Return<void>();
}

::android::hardware::Return<void> SoundTriggerHalHidl::soundModelCallback(
        const V2_0_ISoundTriggerHwCallback::ModelEvent& halEvent,
        CallbackCookie cookie)
{
    sp<SoundModel> model;
    {
        AutoMutex lock(mLock);
        model = mSoundModels.valueFor((SoundModelHandle)cookie);
        if (model == 0) {
            return Return<void>();
        }
    }

    struct sound_trigger_model_event *event = convertSoundModelEventFromHal(&halEvent);
    if (event == NULL) {
        return Return<void>();
    }

    event->model = model->mHandle;
    model->mSoundModelCallback(event, model->mSoundModelCookie);

    free(event);

    return Return<void>();
}

::android::hardware::Return<void> SoundTriggerHalHidl::recognitionCallback_2_1(
        const ISoundTriggerHwCallback::RecognitionEvent& event, CallbackCookie cookie) {
    // The data vector in the 'header' part of V2.1 structure is empty, thus copying is cheap.
    V2_0_ISoundTriggerHwCallback::RecognitionEvent event_2_0 = event.header;
    auto result = memoryAsVector(event.data, &event_2_0.data);
    return result.first ? recognitionCallback(event_2_0, cookie) : Void();
}

::android::hardware::Return<void> SoundTriggerHalHidl::phraseRecognitionCallback_2_1(
        const ISoundTriggerHwCallback::PhraseRecognitionEvent& event, int32_t cookie) {
    V2_0_ISoundTriggerHwCallback::PhraseRecognitionEvent event_2_0;
    // The data vector in the 'header' part of V2.1 structure is empty, thus copying is cheap.
    event_2_0.common = event.common.header;
    event_2_0.phraseExtras.setToExternal(
            const_cast<PhraseRecognitionExtra*>(event.phraseExtras.data()),
            event.phraseExtras.size());
    auto result = memoryAsVector(event.common.data, &event_2_0.common.data);
    return result.first ? phraseRecognitionCallback(event_2_0, cookie) : Void();
}

::android::hardware::Return<void> SoundTriggerHalHidl::soundModelCallback_2_1(
        const ISoundTriggerHwCallback::ModelEvent& event, CallbackCookie cookie) {
    // The data vector in the 'header' part of V2.1 structure is empty, thus copying is cheap.
    V2_0_ISoundTriggerHwCallback::ModelEvent event_2_0 = event.header;
    auto result = memoryAsVector(event.data, &event_2_0.data);
    return result.first ? soundModelCallback(event_2_0, cookie) : Void();
}


struct sound_trigger_model_event *SoundTriggerHalHidl::convertSoundModelEventFromHal(
                                              const V2_0_ISoundTriggerHwCallback::ModelEvent *halEvent)
{
    struct sound_trigger_model_event *event = (struct sound_trigger_model_event *)malloc(
            sizeof(struct sound_trigger_model_event) +
            halEvent->data.size());
    if (event == NULL) {
        return NULL;
    }

    event->status = (int)halEvent->status;
    // event->model to be set by caller
    event->data_offset = sizeof(struct sound_trigger_model_event);
    event->data_size = halEvent->data.size();
    uint8_t *dst = (uint8_t *)event + event->data_offset;
    uint8_t *src = (uint8_t *)&halEvent->data[0];
    memcpy(dst, src, halEvent->data.size());

    return event;
}

void SoundTriggerHalHidl::convertPhraseRecognitionExtraFromHal(
        struct sound_trigger_phrase_recognition_extra *extra,
        const PhraseRecognitionExtra *halExtra)
{
    extra->id = halExtra->id;
    extra->recognition_modes = halExtra->recognitionModes;
    extra->confidence_level = halExtra->confidenceLevel;

    size_t i;
    for (i = 0; i < halExtra->levels.size() && i < SOUND_TRIGGER_MAX_USERS; i++) {
        extra->levels[i].user_id = halExtra->levels[i].userId;
        extra->levels[i].level = halExtra->levels[i].levelPercent;
    }
    extra->num_levels = (unsigned int)i;
}


struct sound_trigger_phrase_recognition_event* SoundTriggerHalHidl::convertPhraseRecognitionEventFromHal(
        const V2_0_ISoundTriggerHwCallback::PhraseRecognitionEvent *halPhraseEvent)
{
    if (halPhraseEvent->common.type != SoundModelType::KEYPHRASE) {
        ALOGE("Received non-keyphrase event type as PhraseRecognitionEvent");
        return NULL;
    }
    struct sound_trigger_phrase_recognition_event *phraseEvent =
            (struct sound_trigger_phrase_recognition_event *)malloc(
                    sizeof(struct sound_trigger_phrase_recognition_event) +
                    halPhraseEvent->common.data.size());
    if (phraseEvent == NULL) {
        return NULL;
    }
    phraseEvent->common.data_offset = sizeof(sound_trigger_phrase_recognition_event);

    for (unsigned int i = 0; i < halPhraseEvent->phraseExtras.size(); i++) {
        convertPhraseRecognitionExtraFromHal(&phraseEvent->phrase_extras[i],
                                             &halPhraseEvent->phraseExtras[i]);
    }
    phraseEvent->num_phrases = halPhraseEvent->phraseExtras.size();

    fillRecognitionEventFromHal(&phraseEvent->common, &halPhraseEvent->common);
    return phraseEvent;
}

struct sound_trigger_recognition_event *SoundTriggerHalHidl::convertRecognitionEventFromHal(
        const V2_0_ISoundTriggerHwCallback::RecognitionEvent *halEvent)
{
    if (halEvent->type == SoundModelType::KEYPHRASE) {
        ALOGE("Received keyphrase event type as RecognitionEvent");
        return NULL;
    }
    struct sound_trigger_recognition_event *event;
    event = (struct sound_trigger_recognition_event *)malloc(
            sizeof(struct sound_trigger_recognition_event) + halEvent->data.size());
    if (event == NULL) {
        return NULL;
    }
    event->data_offset = sizeof(sound_trigger_recognition_event);

    fillRecognitionEventFromHal(event, halEvent);
    return event;
}

void SoundTriggerHalHidl::fillRecognitionEventFromHal(
        struct sound_trigger_recognition_event *event,
        const V2_0_ISoundTriggerHwCallback::RecognitionEvent *halEvent)
{
    event->status = (int)halEvent->status;
    event->type = (sound_trigger_sound_model_type_t)halEvent->type;
    // event->model to be set by caller
    event->capture_available = (bool)halEvent->captureAvailable;
    event->capture_session = halEvent->captureSession;
    event->capture_delay_ms = halEvent->captureDelayMs;
    event->capture_preamble_ms = halEvent->capturePreambleMs;
    event->trigger_in_data = (bool)halEvent->triggerInData;
    event->audio_config.sample_rate = halEvent->audioConfig.sampleRateHz;
    event->audio_config.channel_mask = (audio_channel_mask_t)halEvent->audioConfig.channelMask;
    event->audio_config.format = (audio_format_t)halEvent->audioConfig.format;

    event->data_size = halEvent->data.size();
    uint8_t *dst = (uint8_t *)event + event->data_offset;
    uint8_t *src = (uint8_t *)&halEvent->data[0];
    memcpy(dst, src, halEvent->data.size());
}

} // namespace android