diff --git a/media/audioaidlconversion/AidlConversionNdk.cpp b/media/audioaidlconversion/AidlConversionNdk.cpp
index a3e39c7..9981435 100644
--- a/media/audioaidlconversion/AidlConversionNdk.cpp
+++ b/media/audioaidlconversion/AidlConversionNdk.cpp
@@ -29,13 +29,24 @@
 namespace aidl {
 namespace android {
 
+using ::aidl::android::hardware::audio::effect::AcousticEchoCanceler;
 using ::aidl::android::hardware::audio::effect::Descriptor;
 using ::aidl::android::hardware::audio::effect::Flags;
+using ::aidl::android::hardware::audio::effect::Parameter;
+using ::aidl::android::media::audio::common::AudioDeviceDescription;
 
 using ::android::BAD_VALUE;
 using ::android::base::unexpected;
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
+// Utils
+
+ConversionResult<AcousticEchoCanceler> getParameterSpecificAec(const Parameter& aidl) {
+    const auto& specific = VALUE_OR_RETURN(UNION_GET(aidl, specific));
+    return VALUE_OR_RETURN(UNION_GET(specific, acousticEchoCanceler));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
 // Converters
 
 ConversionResult<uint32_t> aidl2legacy_Flags_Type_uint32(Flags::Type type) {
@@ -238,7 +249,7 @@
 }
 
 ConversionResult<media::audio::common::AudioConfigBase>
-legacy2aidl_AudioConfigBase_buffer_config_t(const buffer_config_t& legacy, bool isInput) {
+legacy2aidl_buffer_config_t_AudioConfigBase(const buffer_config_t& legacy, bool isInput) {
     media::audio::common::AudioConfigBase aidl;
 
     if (legacy.mask & EFFECT_CONFIG_SMP_RATE) {
@@ -255,5 +266,35 @@
     return aidl;
 }
 
+ConversionResult<uint32_t> aidl2legacy_Parameter_uint32_echoDelay(const Parameter& aidl) {
+    const auto& aec = VALUE_OR_RETURN(getParameterSpecificAec(aidl));
+    const auto& echoDelay = VALUE_OR_RETURN(UNION_GET(aec, echoDelayUs));
+    return VALUE_OR_RETURN(convertIntegral<uint32_t>(echoDelay));
+}
+
+ConversionResult<Parameter> legacy2aidl_uint32_echoDelay_Parameter(const uint32_t& legacy) {
+    int delay = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy));
+    AcousticEchoCanceler aec = AcousticEchoCanceler::make<AcousticEchoCanceler::echoDelayUs>(delay);
+    Parameter::Specific specific =
+            Parameter::Specific::make<Parameter::Specific::acousticEchoCanceler>(aec);
+
+    return Parameter::make<Parameter::specific>(specific);
+}
+
+ConversionResult<uint32_t> aidl2legacy_Parameter_uint32_mobileMode(const Parameter& aidl) {
+    const auto& aec = VALUE_OR_RETURN(getParameterSpecificAec(aidl));
+    const auto& mobileMode = VALUE_OR_RETURN(UNION_GET(aec, mobileMode));
+    return VALUE_OR_RETURN(convertIntegral<uint32_t>(mobileMode));
+}
+
+ConversionResult<Parameter> legacy2aidl_uint32_mobileMode_Parameter(const uint32_t& legacy) {
+    bool mode = VALUE_OR_RETURN(convertIntegral<bool>(legacy));
+    AcousticEchoCanceler aec = AcousticEchoCanceler::make<AcousticEchoCanceler::mobileMode>(mode);
+    Parameter::Specific specific =
+            Parameter::Specific::make<Parameter::Specific::acousticEchoCanceler>(aec);
+
+    return Parameter::make<Parameter::specific>(specific);
+}
+
 }  // namespace android
 }  // aidl
diff --git a/media/audioaidlconversion/include/media/AidlConversionNdk.h b/media/audioaidlconversion/include/media/AidlConversionNdk.h
index a3176f6..a1c0da7 100644
--- a/media/audioaidlconversion/include/media/AidlConversionNdk.h
+++ b/media/audioaidlconversion/include/media/AidlConversionNdk.h
@@ -32,6 +32,9 @@
 namespace aidl {
 namespace android {
 
+ConversionResult<::aidl::android::hardware::audio::effect::AcousticEchoCanceler>
+getParameterSpecificAec(const ::aidl::android::hardware::audio::effect::Parameter& aidl);
+
 ConversionResult<uint32_t> aidl2legacy_Flags_Type_uint32(
         ::aidl::android::hardware::audio::effect::Flags::Type type);
 ConversionResult<uint32_t> aidl2legacy_Flags_Insert_uint32(
@@ -61,8 +64,19 @@
 
 ConversionResult<buffer_config_t> aidl2legacy_AudioConfigBase_buffer_config_t(
         const media::audio::common::AudioConfigBase& aidl, bool isInput);
-ConversionResult<media::audio::common::AudioConfigBase> legacy2aidl_AudioConfigBase_buffer_config_t(
+ConversionResult<media::audio::common::AudioConfigBase> legacy2aidl_buffer_config_t_AudioConfigBase(
         const buffer_config_t& legacy, bool isInput);
 
+ConversionResult<uint32_t> aidl2legacy_Parameter_uint32_echoDelay(
+        const ::aidl::android::hardware::audio::effect::Parameter& aidl);
+ConversionResult<::aidl::android::hardware::audio::effect::Parameter>
+legacy2aidl_uint32_echoDelay_Parameter(const uint32_t& legacy);
+
+ConversionResult<uint32_t> aidl2legacy_Parameter_uint32_mobileMode(
+        const ::aidl::android::hardware::audio::effect::Parameter& aidl);
+ConversionResult<::aidl::android::hardware::audio::effect::Parameter>
+legacy2aidl_uint32_mobileMode_Parameter(const uint32_t& legacy);
+
+
 }  // namespace android
 }  // namespace aidl
diff --git a/media/audioaidlconversion/include/media/AidlConversionUtil.h b/media/audioaidlconversion/include/media/AidlConversionUtil.h
index a7a96b8..a0830fc 100644
--- a/media/audioaidlconversion/include/media/AidlConversionUtil.h
+++ b/media/audioaidlconversion/include/media/AidlConversionUtil.h
@@ -411,7 +411,6 @@
     return Status::fromServiceSpecificError(status, emptyIfNull);
 }
 
-
 } // namespace aidl_utils
 
 }  // namespace android
diff --git a/media/libaudiohal/impl/Android.bp b/media/libaudiohal/impl/Android.bp
index 8cbe3ea..829a79a 100644
--- a/media/libaudiohal/impl/Android.bp
+++ b/media/libaudiohal/impl/Android.bp
@@ -248,6 +248,7 @@
         "DeviceHalAidl.cpp",
         "DevicesFactoryHalEntry.cpp",
         "DevicesFactoryHalAidl.cpp",
+        "EffectConversionHelperAidl.cpp",
         "EffectBufferHalAidl.cpp",
         "EffectHalAidl.cpp",
         "EffectsFactoryHalAidl.cpp",
diff --git a/media/libaudiohal/impl/EffectConversionHelperAidl.cpp b/media/libaudiohal/impl/EffectConversionHelperAidl.cpp
new file mode 100644
index 0000000..493d1ee
--- /dev/null
+++ b/media/libaudiohal/impl/EffectConversionHelperAidl.cpp
@@ -0,0 +1,345 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#include <cstdint>
+#include <cstring>
+#define LOG_TAG "EffectConversionHelperAidl"
+//#define LOG_NDEBUG 0
+
+#include <error/expected_utils.h>
+#include <media/audiohal/AudioEffectUuid.h>
+#include <system/audio_effects/audio_effects_utils.h>
+#include <utils/Log.h>
+
+#include "EffectConversionHelperAidl.h"
+
+namespace android {
+namespace effect {
+
+using ::aidl::android::aidl_utils::statusTFromBinderStatus;
+using ::aidl::android::hardware::audio::effect::AcousticEchoCanceler;
+using ::aidl::android::hardware::audio::effect::CommandId;
+using ::aidl::android::hardware::audio::effect::Parameter;
+using ::aidl::android::media::audio::common::AudioDeviceDescription;
+using ::aidl::android::media::audio::common::AudioUuid;
+
+using ::android::status_t;
+
+const std::map<uint32_t /* effect_command_e */, EffectConversionHelperAidl::CommandHandler>
+        EffectConversionHelperAidl::mCommandHandlerMap = {
+                {EFFECT_CMD_INIT, &EffectConversionHelperAidl::handleInit},
+                {EFFECT_CMD_SET_PARAM, &EffectConversionHelperAidl::handleSetParameter},
+                {EFFECT_CMD_GET_PARAM, &EffectConversionHelperAidl::handleGetParameter},
+                {EFFECT_CMD_SET_CONFIG, &EffectConversionHelperAidl::handleSetConfig},
+                {EFFECT_CMD_GET_CONFIG, &EffectConversionHelperAidl::handleGetConfig},
+                {EFFECT_CMD_RESET, &EffectConversionHelperAidl::handleReset},
+                {EFFECT_CMD_ENABLE, &EffectConversionHelperAidl::handleEnable},
+                {EFFECT_CMD_DISABLE, &EffectConversionHelperAidl::handleDisable},
+                {EFFECT_CMD_SET_DEVICE, &EffectConversionHelperAidl::handleSetDevice},
+                {EFFECT_CMD_SET_INPUT_DEVICE, &EffectConversionHelperAidl::handleSetDevice},
+                {EFFECT_CMD_SET_VOLUME, &EffectConversionHelperAidl::handleSetVolume},
+                {EFFECT_CMD_OFFLOAD, &EffectConversionHelperAidl::handleSetOffload},
+                {EFFECT_CMD_FIRST_PROPRIETARY, &EffectConversionHelperAidl::handleFirstPriority}};
+
+const std::map<AudioUuid /* TypeUUID */, std::pair<EffectConversionHelperAidl::SetParameter,
+                                                   EffectConversionHelperAidl::GetParameter>>
+        EffectConversionHelperAidl::mParameterHandlerMap = {
+                {kAcousticEchoCancelerTypeUUID,
+                 {&EffectConversionHelperAidl::setAecParameter,
+                  &EffectConversionHelperAidl::getAecParameter}}};
+
+
+status_t EffectConversionHelperAidl::handleCommand(uint32_t cmdCode, uint32_t cmdSize,
+                                                   void* pCmdData, uint32_t* replySize,
+                                                   void* pReplyData) {
+    const auto& handler = mCommandHandlerMap.find(cmdCode);
+    if (handler == mCommandHandlerMap.end() || !handler->second) {
+        ALOGE("%s handler for command %u doesn't exist", __func__, cmdCode);
+        return BAD_VALUE;
+    }
+    return (this->*handler->second)(cmdSize, pCmdData, replySize, pReplyData);
+}
+
+status_t EffectConversionHelperAidl::handleInit(uint32_t cmdSize __unused,
+                                                const void* pCmdData __unused, uint32_t* replySize,
+                                                void* pReplyData) {
+    if (!replySize || *replySize < sizeof(int) || !pReplyData) {
+        return BAD_VALUE;
+    }
+
+    return *(status_t*)pReplyData = OK;
+}
+
+status_t EffectConversionHelperAidl::handleSetParameter(uint32_t cmdSize, const void* pCmdData,
+                                                        uint32_t* replySize, void* pReplyData) {
+    if (cmdSize < kEffectParamSize || !pCmdData || !replySize || *replySize < sizeof(int) ||
+        !pReplyData) {
+        return BAD_VALUE;
+    }
+
+    const effect_param_t* param = (effect_param_t*)pCmdData;
+    if (!validateCommandSize(*param, cmdSize)) {
+        ALOGE("%s illegal param %s size %u", __func__, utils::toString(*param).c_str(), cmdSize);
+        return BAD_VALUE;
+    }
+
+    const auto& handler = mParameterHandlerMap.find(mTypeUuid);
+    if (handler == mParameterHandlerMap.end() || !handler->second.first) {
+        ALOGE("%s handler for uuid %s not found", __func__, mTypeUuid.toString().c_str());
+        return BAD_VALUE;
+    }
+    const SetParameter& functor = handler->second.first;
+    return *(status_t*)pReplyData = (this->*functor)(*(const effect_param_t*)param);
+}
+
+status_t EffectConversionHelperAidl::handleGetParameter(uint32_t cmdSize, const void* pCmdData,
+                                                        uint32_t* replySize, void* pReplyData) {
+    if (cmdSize < kEffectParamSize || !pCmdData || !replySize || !pReplyData) {
+        return BAD_VALUE;
+    }
+
+    const effect_param_t* param = (effect_param_t*)pCmdData;
+    if (!validateCommandSize(*param, *replySize)) {
+        ALOGE("%s illegal param %s, replysize %u", __func__, utils::toString(*param).c_str(),
+              *replySize);
+        return BAD_VALUE;
+    }
+
+    const auto& handler = mParameterHandlerMap.find(mTypeUuid);
+    if (handler == mParameterHandlerMap.end() || !handler->second.second) {
+        ALOGE("%s handler for uuid %s not found", __func__, mTypeUuid.toString().c_str());
+        return BAD_VALUE;
+    }
+    const GetParameter& functor = handler->second.second;
+    memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + param->psize);
+    effect_param_t* reply = (effect_param_t *)pReplyData;
+    (this->*functor)(*reply);
+    *replySize = kEffectParamSize + padding(reply->psize) + reply->vsize;
+    return reply->status;
+}
+
+status_t EffectConversionHelperAidl::handleSetConfig(uint32_t cmdSize, const void* pCmdData,
+                                                     uint32_t* replySize, void* pReplyData) {
+    if (!replySize || *replySize != sizeof(int) || !pReplyData || cmdSize != kEffectConfigSize) {
+        return BAD_VALUE;
+    }
+
+    const auto& legacyConfig = static_cast<const effect_config_t*>(pCmdData);
+    // already open, apply latest settings
+    Parameter::Common common;
+    common.input.base =
+            VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_buffer_config_t_AudioConfigBase(
+                    legacyConfig->inputCfg, true /* isInput */));
+    common.output.base =
+            VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_buffer_config_t_AudioConfigBase(
+                    legacyConfig->outputCfg, false /* isInput */));
+    common.session = mSessionId;
+    common.ioHandle = mIoId;
+    // TODO: add access mode support
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            mEffect->setParameter(Parameter::make<Parameter::common>(common))));
+    return *static_cast<int32_t*>(pReplyData) = OK;
+}
+
+status_t EffectConversionHelperAidl::handleGetConfig(uint32_t cmdSize __unused,
+                                                     const void* pCmdData __unused,
+                                                     uint32_t* replySize, void* pReplyData) {
+    if (!replySize || *replySize != kEffectConfigSize || !pReplyData) {
+        ALOGE("%s parameter invalid %p %p", __func__, replySize, pReplyData);
+        return BAD_VALUE;
+    }
+
+    Parameter param;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(
+            Parameter::Id::make<Parameter::Id::commonTag>(Parameter::common), &param)));
+
+    const auto& common = param.get<Parameter::common>();
+    effect_config_t* pConfig = (effect_config_t*)pReplyData;
+    pConfig->inputCfg = VALUE_OR_RETURN_STATUS(
+            ::aidl::android::aidl2legacy_AudioConfigBase_buffer_config_t(common.input.base, true));
+    pConfig->outputCfg =
+            VALUE_OR_RETURN_STATUS(::aidl::android::aidl2legacy_AudioConfigBase_buffer_config_t(
+                    common.output.base, false));
+    return OK;
+}
+
+status_t EffectConversionHelperAidl::handleReset(uint32_t cmdSize __unused,
+                                                 const void* pCmdData __unused, uint32_t* replySize,
+                                                 void* pReplyData) {
+    if (!replySize || *replySize != kEffectConfigSize || !pReplyData) {
+        ALOGE("%s parameter invalid %p %p", __func__, replySize, pReplyData);
+        return BAD_VALUE;
+    }
+
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->command(CommandId::RESET)));
+    return OK;
+}
+
+status_t EffectConversionHelperAidl::handleEnable(uint32_t cmdSize __unused,
+                                                 const void* pCmdData __unused, uint32_t* replySize,
+                                                 void* pReplyData) {
+    if (!replySize || *replySize != kEffectConfigSize || !pReplyData) {
+        ALOGE("%s parameter invalid %p %p", __func__, replySize, pReplyData);
+        return BAD_VALUE;
+    }
+
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->command(CommandId::START)));
+    return OK;
+}
+
+status_t EffectConversionHelperAidl::handleDisable(uint32_t cmdSize __unused,
+                                                   const void* pCmdData __unused,
+                                                   uint32_t* replySize, void* pReplyData) {
+    if (!replySize || *replySize != kEffectConfigSize || !pReplyData) {
+        ALOGE("%s parameter invalid %p %p", __func__, replySize, pReplyData);
+        return BAD_VALUE;
+    }
+
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->command(CommandId::STOP)));
+    return OK;
+}
+
+status_t EffectConversionHelperAidl::handleSetDevice(uint32_t cmdSize, const void* pCmdData,
+                                                     uint32_t* replySize, void* pReplyData) {
+    if (cmdSize != sizeof(uint32_t) || !pCmdData || !replySize || *replySize != kEffectConfigSize ||
+        !pReplyData) {
+        ALOGE("%s parameter invalid %u %p %p %p", __func__, cmdSize, pCmdData, replySize,
+              pReplyData);
+        return BAD_VALUE;
+    }
+    // TODO: convert from audio_devices_t to std::vector<AudioDeviceDescription>
+    // const auto& legacyDevice = *(uint32_t*)(pCmdData);
+    std::vector<AudioDeviceDescription> aidlDevices;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            mEffect->setParameter(Parameter::make<Parameter::deviceDescription>(aidlDevices))));
+    return *static_cast<int32_t*>(pReplyData) = OK;
+}
+
+status_t EffectConversionHelperAidl::handleSetVolume(uint32_t cmdSize, const void* pCmdData,
+                                                     uint32_t* replySize, void* pReplyData) {
+    if (cmdSize != 2 * sizeof(uint32_t) || !pCmdData || !replySize ||
+        *replySize != kEffectConfigSize || !pReplyData) {
+        ALOGE("%s parameter invalid %u %p %p %p", __func__, cmdSize, pCmdData, replySize,
+              pReplyData);
+        return BAD_VALUE;
+    }
+    Parameter::VolumeStereo volume = {.left = (float)(*(uint32_t*)pCmdData) / (1 << 24),
+                                      .right = (float)(*(uint32_t*)pCmdData + 1) / (1 << 24)};
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            mEffect->setParameter(Parameter::make<Parameter::volumeStereo>(volume))));
+    return *static_cast<int32_t*>(pReplyData) = OK;
+}
+
+status_t EffectConversionHelperAidl::handleSetOffload(uint32_t cmdSize, const void* pCmdData,
+                                                      uint32_t* replySize, void* pReplyData) {
+    if (cmdSize < sizeof(effect_offload_param_t) || !pCmdData || !replySize ||
+        *replySize != kEffectConfigSize || !pReplyData) {
+        ALOGE("%s parameter invalid %u %p %p %p", __func__, cmdSize, pCmdData, replySize,
+              pReplyData);
+        return BAD_VALUE;
+    }
+    // TODO: handle this after effectproxy implemented in libaudiohal
+    return *static_cast<int32_t*>(pReplyData) = OK;
+}
+
+status_t EffectConversionHelperAidl::handleFirstPriority(uint32_t cmdSize __unused,
+                                                         const void* pCmdData __unused,
+                                                         uint32_t* replySize, void* pReplyData) {
+    if (!replySize || *replySize != kEffectConfigSize || !pReplyData) {
+        ALOGE("%s parameter invalid %p %p", __func__, replySize, pReplyData);
+        return BAD_VALUE;
+    }
+
+    // TODO
+    return OK;
+}
+
+status_t EffectConversionHelperAidl::setAecParameter(const effect_param_t& param) {
+    const auto psize = sizeof(uint32_t);
+    const auto vsize = sizeof(uint32_t);
+    if (!validatePVsize(param, psize, vsize)) {
+        return BAD_VALUE;
+    }
+
+    const auto& type = *(uint32_t*)param.data;
+    const auto& value = *(uint32_t*)(param.data + psize);
+    Parameter aidlParam;
+    switch (type) {
+        case AEC_PARAM_ECHO_DELAY:
+            FALLTHROUGH_INTENDED;
+        case AEC_PARAM_PROPERTIES: {
+            aidlParam = VALUE_OR_RETURN_STATUS(
+                    aidl::android::legacy2aidl_uint32_echoDelay_Parameter(value));
+            break;
+        }
+        case AEC_PARAM_MOBILE_MODE: {
+            aidlParam = VALUE_OR_RETURN_STATUS(
+                    aidl::android::legacy2aidl_uint32_mobileMode_Parameter(value));
+            break;
+        }
+        default: {
+            ALOGW("%s unknown param %08x value %08x", __func__, type, value);
+            return BAD_VALUE;
+        }
+    }
+
+    return mEffect->setParameter(aidlParam).getStatus();
+}
+
+status_t EffectConversionHelperAidl::getAecParameter(effect_param_t& param) {
+    const auto psize = sizeof(uint32_t);
+    const auto vsize = sizeof(uint32_t);
+    if (!validatePVsize(param, psize, vsize)) {
+        return param.status = BAD_VALUE;
+    }
+
+    uint32_t value = 0;
+    status_t status = BAD_VALUE;
+    const auto& type = *(uint32_t*)param.data;
+    switch (type) {
+        case AEC_PARAM_ECHO_DELAY:
+            FALLTHROUGH_INTENDED;
+        case AEC_PARAM_PROPERTIES: {
+            Parameter aidlParam;
+            Parameter::Id id = Parameter::Id::make<Parameter::Id::acousticEchoCancelerTag>(
+                    AcousticEchoCanceler::Id::make<AcousticEchoCanceler::Id::commonTag>(
+                            AcousticEchoCanceler::echoDelayUs));
+            RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));
+            value = VALUE_OR_RETURN_STATUS(
+                    aidl::android::aidl2legacy_Parameter_uint32_echoDelay(aidlParam));
+            break;
+        }
+        case AEC_PARAM_MOBILE_MODE: {
+            Parameter aidlParam;
+            Parameter::Id id = Parameter::Id::make<Parameter::Id::acousticEchoCancelerTag>(
+                    AcousticEchoCanceler::Id::make<AcousticEchoCanceler::Id::commonTag>(
+                            AcousticEchoCanceler::mobileMode));
+            RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));
+            value = VALUE_OR_RETURN_STATUS(
+                    aidl::android::aidl2legacy_Parameter_uint32_mobileMode(aidlParam));
+            break;
+        }
+        default:
+            ALOGW("%s unknown param %08x", __func__, type);
+            break;
+    }
+
+    *(uint32_t*)(param.data + psize) = value;
+    return param.status = status;
+}
+
+} // namespace effect
+} // namespace android
diff --git a/media/libaudiohal/impl/EffectConversionHelperAidl.h b/media/libaudiohal/impl/EffectConversionHelperAidl.h
new file mode 100644
index 0000000..5d7c1d6
--- /dev/null
+++ b/media/libaudiohal/impl/EffectConversionHelperAidl.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <map>
+#include <memory>
+#include <utils/Errors.h>
+
+#include <aidl/android/hardware/audio/effect/IEffect.h>
+
+#include <media/AidlConversionNdk.h>
+#include <system/audio_effect.h>
+#include <system/audio_effects/effect_aec.h>
+#include <system/audio_effects/effect_downmix.h>
+#include <system/audio_effects/effect_dynamicsprocessing.h>
+#include <system/audio_effects/effect_hapticgenerator.h>
+#include <system/audio_effects/effect_ns.h>
+#include <system/audio_effects/effect_visualizer.h>
+
+namespace android {
+namespace effect {
+
+static const size_t kEffectParamSize = sizeof(effect_param_t);
+static const size_t kEffectConfigSize = sizeof(effect_config_t);
+
+class EffectConversionHelperAidl {
+  protected:
+    EffectConversionHelperAidl(
+            std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect> effect,
+            int32_t sessionId, int32_t ioId, ::aidl::android::media::audio::common::AudioUuid uuid)
+        : mSessionId(sessionId),
+          mIoId(ioId),
+          mTypeUuid(std::move(uuid)),
+          mEffect(std::move(effect)) {}
+
+    status_t handleCommand(uint32_t cmdCode, uint32_t cmdSize, void* pCmdData, uint32_t* replySize,
+                           void* pReplyData);
+
+  private:
+    const int32_t mSessionId;
+    const int32_t mIoId;
+    ::aidl::android::media::audio::common::AudioUuid mTypeUuid;
+    const std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect> mEffect;
+
+    // command handler map
+    typedef status_t (EffectConversionHelperAidl::*CommandHandler)(uint32_t /* cmdSize */,
+                                                                   const void* /* pCmdData */,
+                                                                   uint32_t* /* replySize */,
+                                                                   void* /* pReplyData */);
+    static const std::map<uint32_t /* effect_command_e */, CommandHandler> mCommandHandlerMap;
+
+    // parameter set/get handler map
+    typedef status_t (EffectConversionHelperAidl::*SetParameter)(const effect_param_t& param);
+    typedef status_t (EffectConversionHelperAidl::*GetParameter)(effect_param_t& param);
+    static const std::map<::aidl::android::media::audio::common::AudioUuid /* TypeUUID */,
+                          std::pair<SetParameter, GetParameter>>
+            mParameterHandlerMap;
+
+    // align to 32 bit boundary
+    static constexpr size_t padding(size_t size) {
+        return ((size - 1) / sizeof(int) + 1) * sizeof(int);
+    }
+    static constexpr bool validatePVsize(const effect_param_t& param, size_t p, size_t v) {
+        return padding(param.psize) == p && param.vsize == v;
+    }
+    static constexpr bool validateCommandSize(const effect_param_t& param, size_t size) {
+        return padding(param.psize) + param.vsize + kEffectParamSize <= size;
+    }
+
+    status_t handleInit(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
+                        void* pReplyData);
+    status_t handleSetParameter(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
+                                void* pReplyData);
+    status_t handleGetParameter(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
+                                void* pReplyData);
+    status_t handleSetConfig(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
+                             void* pReplyData);
+    status_t handleGetConfig(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
+                             void* pReplyData);
+    status_t handleEnable(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
+                          void* pReplyData);
+    status_t handleDisable(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
+                           void* pReplyData);
+    status_t handleReset(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
+                         void* pReplyData);
+    status_t handleSetDevice(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
+                             void* pReplyData);
+    status_t handleSetVolume(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
+                             void* pReplyData);
+    status_t handleSetOffload(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
+                              void* pReplyData);
+    status_t handleFirstPriority(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
+                                 void* pReplyData);
+
+    // AEC parameter handler
+    status_t setAecParameter(const effect_param_t& param);
+    status_t getAecParameter(effect_param_t& param);
+};
+
+}  // namespace effect
+}  // namespace android
diff --git a/media/libaudiohal/impl/EffectHalAidl.cpp b/media/libaudiohal/impl/EffectHalAidl.cpp
index daa68a1..3346459 100644
--- a/media/libaudiohal/impl/EffectHalAidl.cpp
+++ b/media/libaudiohal/impl/EffectHalAidl.cpp
@@ -25,25 +25,36 @@
 #include <mediautils/TimeCheck.h>
 #include <utils/Log.h>
 
+#include <system/audio_effects/effect_aec.h>
+#include <system/audio_effects/effect_downmix.h>
+#include <system/audio_effects/effect_dynamicsprocessing.h>
+#include <system/audio_effects/effect_hapticgenerator.h>
+#include <system/audio_effects/effect_ns.h>
+#include <system/audio_effects/effect_spatializer.h>
+#include <system/audio_effects/effect_visualizer.h>
+
 #include "EffectHalAidl.h"
 
 #include <system/audio.h>
-
 #include <aidl/android/hardware/audio/effect/IEffect.h>
 
 using ::aidl::android::aidl_utils::statusTFromBinderStatus;
 using ::aidl::android::hardware::audio::effect::CommandId;
 using ::aidl::android::hardware::audio::effect::Descriptor;
 using ::aidl::android::hardware::audio::effect::IEffect;
-using ::aidl::android::hardware::audio::effect::State;
 using ::aidl::android::hardware::audio::effect::Parameter;
 
 namespace android {
 namespace effect {
 
 EffectHalAidl::EffectHalAidl(const std::shared_ptr<IEffect>& effect, uint64_t effectId,
-                             int32_t sessionId, int32_t ioId)
-    : mEffectId(effectId), mSessionId(sessionId), mIoId(ioId), mEffect(effect) {}
+                             int32_t sessionId, int32_t ioId, const Descriptor& desc)
+    : EffectConversionHelperAidl(effect, sessionId, ioId, desc.common.id.type),
+      mEffectId(effectId),
+      mSessionId(sessionId),
+      mIoId(ioId),
+      mEffect(effect),
+      mDesc(desc) {}
 
 EffectHalAidl::~EffectHalAidl() {}
 
@@ -65,7 +76,7 @@
 
 status_t EffectHalAidl::process() {
     ALOGW("%s not implemented yet", __func__);
-    // write to input FMQ here?
+    // write to input FMQ here, and wait for statusMQ STATUS_OK
     return OK;
 }
 
@@ -75,138 +86,9 @@
     return OK;
 }
 
-status_t EffectHalAidl::handleSetConfig(uint32_t cmdCode, uint32_t cmdSize, void* pCmdData,
-                                        uint32_t* replySize, void* pReplyData) {
-    if (pCmdData == NULL || cmdSize != sizeof(effect_config_t) || replySize == NULL ||
-        *replySize != sizeof(int32_t) || pReplyData == NULL) {
-        ALOGE("%s parameter error code %u", __func__, cmdCode);
-        return BAD_VALUE;
-    }
-
-    *static_cast<int32_t*>(pReplyData) = FAILED_TRANSACTION;
-    memcpy(&mConfig, pCmdData, cmdSize);
-
-    State state;
-    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getState(&state)));
-    // effect not open yet, save settings locally
-    if (state != State::INIT) {
-        effect_config_t* legacyConfig = static_cast<effect_config_t*>(pCmdData);
-        // already open, apply latest settings
-        Parameter aidlParam;
-        Parameter::Common aidlCommon;
-        aidlCommon.input.base =
-                VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_AudioConfigBase_buffer_config_t(
-                        legacyConfig->inputCfg, true /* isInput */));
-        aidlCommon.output.base =
-                VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_AudioConfigBase_buffer_config_t(
-                        legacyConfig->outputCfg, false /* isInput */));
-        aidlCommon.session = mSessionId;
-        aidlCommon.ioHandle = mIoId;
-        Parameter::Id id;
-        id.set<Parameter::Id::commonTag>(Parameter::common);
-        aidlParam.set<Parameter::common>(aidlCommon);
-        RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->setParameter(aidlParam)));
-    }
-    *(int*)pReplyData = 0;
-    *static_cast<int32_t*>(pReplyData) = OK;
-    return OK;
-}
-
-status_t EffectHalAidl::handleGetConfig(uint32_t cmdCode, uint32_t cmdSize, void* pCmdData,
-                                        uint32_t* replySize, void* pReplyData) {
-    if (pCmdData == NULL || cmdSize == 0 || replySize == NULL ||
-        *replySize != sizeof(effect_config_t) || pReplyData == NULL) {
-        ALOGE("%s parameter error with cmdCode %d", __func__, cmdCode);
-        return BAD_VALUE;
-    }
-
-    *(effect_config_t*)pReplyData = mConfig;
-    return OK;
-}
-
-status_t EffectHalAidl::handleSetParameter(uint32_t cmdCode, uint32_t cmdSize, void* pCmdData,
-                                           uint32_t* replySize, void* pReplyData) {
-    ALOGW("%s not implemented yet", __func__);
-    if (pCmdData == NULL || cmdSize == 0 || replySize == NULL ||
-        *replySize != sizeof(effect_config_t) || pReplyData == NULL) {
-        ALOGE("%s parameter error with cmdCode %d", __func__, cmdCode);
-        return BAD_VALUE;
-    }
-    return OK;
-}
-
-status_t EffectHalAidl::handleGetParameter(uint32_t cmdCode, uint32_t cmdSize, void* pCmdData,
-                                           uint32_t* replySize, void* pReplyData) {
-    ALOGW("%s not implemented yet", __func__);
-    if (pCmdData == NULL || cmdSize == 0 || replySize == NULL ||
-        *replySize != sizeof(effect_config_t) || pReplyData == NULL) {
-        ALOGE("%s parameter error with cmdCode %d", __func__, cmdCode);
-        return BAD_VALUE;
-    }
-    return OK;
-}
-
 status_t EffectHalAidl::command(uint32_t cmdCode, uint32_t cmdSize, void* pCmdData,
                                 uint32_t* replySize, void* pReplyData) {
-    ALOGW("%s code %d not implemented yet", __func__, cmdCode);
-    ::ndk::ScopedAStatus status;
-    switch (cmdCode) {
-        case EFFECT_CMD_INIT: {
-            // open with default effect_config_t (convert to Parameter.Common)
-            IEffect::OpenEffectReturn ret;
-            Parameter::Common common;
-            RETURN_STATUS_IF_ERROR(
-                    statusTFromBinderStatus(mEffect->open(common, std::nullopt, &ret)));
-            return OK;
-        }
-        case EFFECT_CMD_SET_CONFIG:
-            return handleSetConfig(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
-        case EFFECT_CMD_GET_CONFIG:
-            return handleGetConfig(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
-        case EFFECT_CMD_RESET:
-            return mEffect->command(CommandId::RESET).getStatus();
-        case EFFECT_CMD_ENABLE:
-            return mEffect->command(CommandId::START).getStatus();
-        case EFFECT_CMD_DISABLE:
-            return mEffect->command(CommandId::STOP).getStatus();
-        case EFFECT_CMD_SET_PARAM:
-            return handleSetParameter(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
-        case EFFECT_CMD_SET_PARAM_DEFERRED:
-        case EFFECT_CMD_SET_PARAM_COMMIT:
-            // TODO
-            return OK;
-        case EFFECT_CMD_GET_PARAM:
-            return handleGetParameter(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
-        case EFFECT_CMD_SET_DEVICE:
-            return OK;
-        case EFFECT_CMD_SET_VOLUME:
-            return OK;
-        case EFFECT_CMD_SET_AUDIO_MODE:
-            return OK;
-        case EFFECT_CMD_SET_CONFIG_REVERSE:
-            return OK;
-        case EFFECT_CMD_SET_INPUT_DEVICE:
-            return OK;
-        case EFFECT_CMD_GET_CONFIG_REVERSE:
-            return OK;
-        case EFFECT_CMD_GET_FEATURE_SUPPORTED_CONFIGS:
-            return OK;
-        case EFFECT_CMD_GET_FEATURE_CONFIG:
-            return OK;
-        case EFFECT_CMD_SET_FEATURE_CONFIG:
-            return OK;
-        case EFFECT_CMD_SET_AUDIO_SOURCE:
-            return OK;
-        case EFFECT_CMD_OFFLOAD:
-            return OK;
-        case EFFECT_CMD_DUMP:
-            return OK;
-        case EFFECT_CMD_FIRST_PROPRIETARY:
-            return OK;
-        default:
-            return INVALID_OPERATION;
-    }
-    return INVALID_OPERATION;
+    return handleCommand(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
 }
 
 status_t EffectHalAidl::getDescriptor(effect_descriptor_t* pDescriptor) {
@@ -223,9 +105,8 @@
 }
 
 status_t EffectHalAidl::close() {
-    auto ret = mEffect->close();
-    ALOGI("%s %s", __func__, ret.getMessage());
-    return ret.getStatus();
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->close()));
+    return OK;
 }
 
 status_t EffectHalAidl::dump(int fd) {
diff --git a/media/libaudiohal/impl/EffectHalAidl.h b/media/libaudiohal/impl/EffectHalAidl.h
index 76bb240..1ba262c 100644
--- a/media/libaudiohal/impl/EffectHalAidl.h
+++ b/media/libaudiohal/impl/EffectHalAidl.h
@@ -20,10 +20,12 @@
 #include <media/audiohal/EffectHalInterface.h>
 #include <system/audio_effect.h>
 
+#include "EffectConversionHelperAidl.h"
+
 namespace android {
 namespace effect {
 
-class EffectHalAidl : public EffectHalInterface {
+class EffectHalAidl : public EffectHalInterface, public EffectConversionHelperAidl {
   public:
     // Set the input buffer.
     status_t setInBuffer(const sp<EffectBufferHalInterface>& buffer) override;
@@ -55,28 +57,27 @@
 
     uint64_t effectId() const override { return mEffectId; }
 
+    const std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect> getIEffect() const {
+        return mEffect;
+    }
+
   private:
-    friend class EffectsFactoryHalAidl;
+    friend class sp<EffectHalAidl>;
 
     const uint64_t mEffectId;
     const int32_t mSessionId;
     const int32_t mIoId;
+    const std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect> mEffect;
+    const ::aidl::android::hardware::audio::effect::Descriptor mDesc;
+
     sp<EffectBufferHalInterface> mInBuffer, mOutBuffer;
     effect_config_t mConfig;
-    std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect> mEffect;
 
     // Can not be constructed directly by clients.
     EffectHalAidl(const std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect>& effect,
-                  uint64_t effectId, int32_t sessionId, int32_t ioId);
-
-    status_t handleSetConfig(uint32_t cmdCode, uint32_t cmdSize, void* pCmdData,
-                             uint32_t* replySize, void* pReplyData);
-    status_t handleGetConfig(uint32_t cmdCode, uint32_t cmdSize, void* pCmdData,
-                             uint32_t* replySize, void* pReplyData);
-    status_t handleSetParameter(uint32_t cmdCode, uint32_t cmdSize, void* pCmdData,
-                                uint32_t* replySize, void* pReplyData);
-    status_t handleGetParameter(uint32_t cmdCode, uint32_t cmdSize, void* pCmdData,
-                                uint32_t* replySize, void* pReplyData);
+                  uint64_t effectId, int32_t sessionId, int32_t ioId,
+                  const ::aidl::android::hardware::audio::effect::Descriptor& desc);
+    bool setEffectReverse(bool reverse);
 
     // The destructor automatically releases the effect.
     virtual ~EffectHalAidl();
diff --git a/media/libaudiohal/impl/EffectsFactoryHalAidl.cpp b/media/libaudiohal/impl/EffectsFactoryHalAidl.cpp
index c6234e4..96ea861 100644
--- a/media/libaudiohal/impl/EffectsFactoryHalAidl.cpp
+++ b/media/libaudiohal/impl/EffectsFactoryHalAidl.cpp
@@ -21,15 +21,19 @@
 //#define LOG_NDEBUG 0
 
 #include <aidl/android/hardware/audio/effect/IFactory.h>
+#include <error/expected_utils.h>
 #include <android/binder_manager.h>
 #include <media/AidlConversionCppNdk.h>
 #include <media/AidlConversionNdk.h>
+#include <system/audio.h>
 #include <utils/Log.h>
 
 #include "EffectBufferHalAidl.h"
 #include "EffectHalAidl.h"
 #include "EffectsFactoryHalAidl.h"
 
+using ::aidl::android::legacy2aidl_audio_uuid_t_AudioUuid;
+using aidl::android::aidl_utils::statusTFromBinderStatus;
 using aidl::android::hardware::audio::effect::IFactory;
 using aidl::android::media::audio::common::AudioUuid;
 using android::detail::AudioHalVersionInfo;
@@ -86,8 +90,7 @@
         return BAD_VALUE;
     }
 
-    AudioUuid uuid =
-            VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_audio_uuid_t_AudioUuid(*halUuid));
+    AudioUuid uuid = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(*halUuid));
     std::lock_guard lg(mLock);
     return getHalDescriptorWithImplUuid_l(uuid, pDescriptor);
 }
@@ -98,8 +101,7 @@
         return BAD_VALUE;
     }
 
-    AudioUuid type =
-            VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_audio_uuid_t_AudioUuid(*halType));
+    AudioUuid type = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(*halType));
     std::lock_guard lg(mLock);
     return getHalDescriptorWithTypeUuid_l(type, descriptors);
 }
@@ -110,24 +112,29 @@
     if (uuid == nullptr || effect == nullptr) {
         return BAD_VALUE;
     }
-    ALOGI("%s session %d ioId %d", __func__, sessionId, ioId);
-
-    AudioUuid aidlUuid =
-            VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_audio_uuid_t_AudioUuid(*uuid));
-    std::shared_ptr<IEffect> aidlEffect;
-    ndk::ScopedAStatus status = mFactory->createEffect(aidlUuid, &aidlEffect);
-    if (!status.isOk() || aidlEffect == nullptr) {
-        ALOGE("%s IFactory::createFactory failed %s UUID %s", __func__,
-              status.getDescription().c_str(), aidlUuid.toString().c_str());
+    if (sessionId == AUDIO_SESSION_DEVICE && ioId == AUDIO_IO_HANDLE_NONE) {
         return INVALID_OPERATION;
     }
+
+    ALOGI("%s session %d ioId %d", __func__, sessionId, ioId);
+
+    AudioUuid aidlUuid = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(*uuid));
+    std::shared_ptr<IEffect> aidlEffect;
+    Descriptor desc;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mFactory->createEffect(aidlUuid, &aidlEffect)));
+    if (aidlEffect == nullptr) {
+        ALOGE("%s IFactory::createFactory failed UUID %s", __func__, aidlUuid.toString().c_str());
+        return NAME_NOT_FOUND;
+    }
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(aidlEffect->getDescriptor(&desc)));
+
     uint64_t effectId;
     {
         std::lock_guard lg(mLock);
         effectId = ++mEffectIdCounter;
     }
 
-    *effect = new EffectHalAidl(aidlEffect, effectId, sessionId, ioId);
+    *effect = sp<EffectHalAidl>::make(aidlEffect, effectId, sessionId, ioId, desc);
     return OK;
 }
 
diff --git a/media/libaudiohal/include/media/audiohal/AudioEffectUuid.h b/media/libaudiohal/include/media/audiohal/AudioEffectUuid.h
new file mode 100644
index 0000000..20a10f6
--- /dev/null
+++ b/media/libaudiohal/include/media/audiohal/AudioEffectUuid.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#pragma once
+
+#include <aidl/android/media/audio/common/AudioUuid.h>
+
+namespace android {
+namespace effect {
+
+using ::aidl::android::media::audio::common::AudioUuid;
+
+// 7b491460-8d4d-11e0-bd61-0002a5d5c51b.
+static const AudioUuid kAcousticEchoCancelerTypeUUID = {static_cast<int32_t>(0x7b491460),
+                                                        0x8d4d,
+                                                        0x11e0,
+                                                        0xbd61,
+                                                        {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
+// 0xae3c653b-be18-4ab8-8938-418f0a7f06ac
+static const AudioUuid kAutomaticGainControlTypeUUID = {static_cast<int32_t>(0xae3c653b),
+                                                        0xbe18,
+                                                        0x4ab8,
+                                                        0x8938,
+                                                        {0x41, 0x8f, 0x0a, 0x7f, 0x06, 0xac}};
+// 0634f220-ddd4-11db-a0fc-0002a5d5c51b
+static const AudioUuid kBassBoostTypeUUID = {static_cast<int32_t>(0x0634f220),
+                                             0xddd4,
+                                             0x11db,
+                                             0xa0fc,
+                                             {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
+// fa81862a-588b-11ed-9b6a-0242ac120002
+static const AudioUuid kDownmixTypeUUID = {static_cast<int32_t>(0xfa81862a),
+                                           0x588b,
+                                           0x11ed,
+                                           0x9b6a,
+                                           {0x02, 0x42, 0xac, 0x12, 0x00, 0x02}};
+// 0bed4300-ddd6-11db-8f34-0002a5d5c51b.
+static const AudioUuid kEqualizerTypeUUID = {static_cast<int32_t>(0x0bed4300),
+                                             0xddd6,
+                                             0x11db,
+                                             0x8f34,
+                                             {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
+// 7261676f-6d75-7369-6364-28e2fd3ac39e
+static const AudioUuid kDynamicsProcessingTypeUUID = {static_cast<int32_t>(0x7261676f),
+                                                      0x6d75,
+                                                      0x7369,
+                                                      0x6364,
+                                                      {0x28, 0xe2, 0xfd, 0x3a, 0xc3, 0x9e}};
+// 1411e6d6-aecd-4021-a1cf-a6aceb0d71e5
+static const AudioUuid kHapticGeneratorTypeUUID = {static_cast<int32_t>(0x1411e6d6),
+                                                   0xaecd,
+                                                   0x4021,
+                                                   0xa1cf,
+                                                   {0xa6, 0xac, 0xeb, 0x0d, 0x71, 0xe5}};
+// fe3199be-aed0-413f-87bb-11260eb63cf1
+static const AudioUuid kLoudnessEnhancerTypeUUID = {static_cast<int32_t>(0xfe3199be),
+                                                    0xaed0,
+                                                    0x413f,
+                                                    0x87bb,
+                                                    {0x11, 0x26, 0x0e, 0xb6, 0x3c, 0xf1}};
+// c2e5d5f0-94bd-4763-9cac-4e234d06839e
+static const AudioUuid kEnvReverbTypeUUID = {static_cast<int32_t>(0xc2e5d5f0),
+                                             0x94bd,
+                                             0x4763,
+                                             0x9cac,
+                                             {0x4e, 0x23, 0x4d, 0x06, 0x83, 0x9e}};
+// 58b4b260-8e06-11e0-aa8e-0002a5d5c51b
+static const AudioUuid kNoiseSuppressionTypeUUID = {static_cast<int32_t>(0x58b4b260),
+                                                    0x8e06,
+                                                    0x11e0,
+                                                    0xaa8e,
+                                                    {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
+// 47382d60-ddd8-11db-bf3a-0002a5d5c51b
+static const AudioUuid kPresetReverbTypeUUID = {static_cast<int32_t>(0x47382d60),
+                                                0xddd8,
+                                                0x11db,
+                                                0xbf3a,
+                                                {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
+// 37cc2c00-dddd-11db-8577-0002a5d5c51b
+static const AudioUuid kVirtualizerTypeUUID = {static_cast<int32_t>(0x37cc2c00),
+                                               0xdddd,
+                                               0x11db,
+                                               0x8577,
+                                               {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
+// fa819f3e-588b-11ed-9b6a-0242ac120002
+static const AudioUuid kVisualizerTypeUUID = {static_cast<int32_t>(0xfa819f3e),
+                                              0x588b,
+                                              0x11ed,
+                                              0x9b6a,
+                                              {0x02, 0x42, 0xac, 0x12, 0x00, 0x02}};
+// fa81a2b8-588b-11ed-9b6a-0242ac120002
+static const AudioUuid kVolumeTypeUUID = {static_cast<int32_t>(0xfa81a2b8),
+                                          0x588b,
+                                          0x11ed,
+                                          0x9b6a,
+                                          {0x02, 0x42, 0xac, 0x12, 0x00, 0x02}};
+
+}  // namespace effect
+}  // namespace android