diff --git a/media/codecs/amrnb/enc/src/cor_h_x2.cpp b/media/codecs/amrnb/enc/src/cor_h_x2.cpp
index b4fd867..e32eb4a 100644
--- a/media/codecs/amrnb/enc/src/cor_h_x2.cpp
+++ b/media/codecs/amrnb/enc/src/cor_h_x2.cpp
@@ -240,7 +240,7 @@
     Word16 j;
     Word16 k;
     Word32 s;
-    Word32 y32[L_CODE];
+    Word32 y32[L_CODE]{};
     Word32 max;
     Word32 tot;
 
diff --git a/media/codecs/m4v_h263/enc/src/mp4enc_api.cpp b/media/codecs/m4v_h263/enc/src/mp4enc_api.cpp
index 30e4fda..4ea3c69 100644
--- a/media/codecs/m4v_h263/enc/src/mp4enc_api.cpp
+++ b/media/codecs/m4v_h263/enc/src/mp4enc_api.cpp
@@ -1582,7 +1582,7 @@
         if (currLayer == 0)
         {
             video->forwardRefVop = tempForwRefVop; /* For P-Vop base only */
-            video->forwardRefVop->refSelectCode = tempRefSelCode;
+            if (video->forwardRefVop != NULL) video->forwardRefVop->refSelectCode = tempRefSelCode;
         }
 
         return status;
diff --git a/media/libaudioclient/AidlConversion.cpp b/media/libaudioclient/AidlConversion.cpp
index 31c071e..1ff4678 100644
--- a/media/libaudioclient/AidlConversion.cpp
+++ b/media/libaudioclient/AidlConversion.cpp
@@ -31,86 +31,6 @@
 
 namespace {
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// The code below establishes:
-// IntegralTypeOf<T>, which works for either integral types (in which case it evaluates to T), or
-// enum types (in which case it evaluates to std::underlying_type_T<T>).
-
-template<typename T, typename = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>>
-struct IntegralTypeOfStruct {
-    using Type = T;
-};
-
-template<typename T>
-struct IntegralTypeOfStruct<T, std::enable_if_t<std::is_enum_v<T>>> {
-    using Type = std::underlying_type_t<T>;
-};
-
-template<typename T>
-using IntegralTypeOf = typename IntegralTypeOfStruct<T>::Type;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Utilities for handling bitmasks.
-
-template<typename Enum>
-Enum index2enum_index(int index) {
-    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
-    return static_cast<Enum>(index);
-}
-
-template<typename Enum>
-Enum index2enum_bitmask(int index) {
-    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
-    return static_cast<Enum>(1 << index);
-}
-
-template<typename Mask, typename Enum>
-Mask enumToMask_bitmask(Enum e) {
-    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
-    static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);
-    return static_cast<Mask>(e);
-}
-
-template<typename Mask, typename Enum>
-Mask enumToMask_index(Enum e) {
-    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
-    static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);
-    return static_cast<Mask>(static_cast<std::make_unsigned_t<IntegralTypeOf<Mask>>>(1)
-            << static_cast<int>(e));
-}
-
-template<typename DestMask, typename SrcMask, typename DestEnum, typename SrcEnum>
-ConversionResult<DestMask> convertBitmask(
-        SrcMask src, const std::function<ConversionResult<DestEnum>(SrcEnum)>& enumConversion,
-        const std::function<SrcEnum(int)>& srcIndexToEnum,
-        const std::function<DestMask(DestEnum)>& destEnumToMask) {
-    using UnsignedDestMask = std::make_unsigned_t<IntegralTypeOf<DestMask>>;
-    using UnsignedSrcMask = std::make_unsigned_t<IntegralTypeOf<SrcMask>>;
-
-    UnsignedDestMask dest = static_cast<UnsignedDestMask>(0);
-    UnsignedSrcMask usrc = static_cast<UnsignedSrcMask>(src);
-
-    int srcBitIndex = 0;
-    while (usrc != 0) {
-        if (usrc & 1) {
-            SrcEnum srcEnum = srcIndexToEnum(srcBitIndex);
-            DestEnum destEnum = VALUE_OR_RETURN(enumConversion(srcEnum));
-            DestMask destMask = destEnumToMask(destEnum);
-            dest |= destMask;
-        }
-        ++srcBitIndex;
-        usrc >>= 1;
-    }
-    return static_cast<DestMask>(dest);
-}
-
-template<typename Mask, typename Enum>
-bool bitmaskIsSet(Mask mask, Enum index) {
-    return (mask & enumToMask_index<Mask, Enum>(index)) != 0;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
 enum class Direction {
     INPUT, OUTPUT
 };
@@ -318,7 +238,7 @@
     return convertBitmask<unsigned int, int32_t, int, media::AudioPortConfigType>(
             aidl, aidl2legacy_AudioPortConfigType_int32_t,
             // AudioPortConfigType enum is index-based.
-            index2enum_index<media::AudioPortConfigType>,
+            indexToEnum_index<media::AudioPortConfigType>,
             // AUDIO_PORT_CONFIG_* flags are mask-based.
             enumToMask_bitmask<unsigned int, int>);
 }
@@ -327,7 +247,7 @@
     return convertBitmask<int32_t, unsigned int, media::AudioPortConfigType, int>(
             legacy, legacy2aidl_int32_t_AudioPortConfigType,
             // AUDIO_PORT_CONFIG_* flags are mask-based.
-            index2enum_bitmask<unsigned>,
+            indexToEnum_bitmask<unsigned>,
             // AudioPortConfigType enum is index-based.
             enumToMask_index<int32_t, media::AudioPortConfigType>);
 }
@@ -494,7 +414,7 @@
     return convertBitmask<audio_gain_mode_t, int32_t, audio_gain_mode_t, media::AudioGainMode>(
             aidl, aidl2legacy_AudioGainMode_audio_gain_mode_t,
             // AudioGainMode is index-based.
-            index2enum_index<media::AudioGainMode>,
+            indexToEnum_index<media::AudioGainMode>,
             // AUDIO_GAIN_MODE_* constants are mask-based.
             enumToMask_bitmask<audio_gain_mode_t, audio_gain_mode_t>);
 }
@@ -503,7 +423,7 @@
     return convertBitmask<int32_t, audio_gain_mode_t, media::AudioGainMode, audio_gain_mode_t>(
             legacy, legacy2aidl_audio_gain_mode_t_AudioGainMode,
             // AUDIO_GAIN_MODE_* constants are mask-based.
-            index2enum_bitmask<audio_gain_mode_t>,
+            indexToEnum_bitmask<audio_gain_mode_t>,
             // AudioGainMode is index-based.
             enumToMask_index<int32_t, media::AudioGainMode>);
 }
@@ -695,7 +615,7 @@
     LegacyMask converted = VALUE_OR_RETURN(
             (convertBitmask<LegacyMask, int32_t, audio_input_flags_t, media::AudioInputFlags>(
                     aidl, aidl2legacy_AudioInputFlags_audio_input_flags_t,
-                    index2enum_index<media::AudioInputFlags>,
+                    indexToEnum_index<media::AudioInputFlags>,
                     enumToMask_bitmask<LegacyMask, audio_input_flags_t>)));
     return static_cast<audio_input_flags_t>(converted);
 }
@@ -707,18 +627,18 @@
     LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
     return convertBitmask<int32_t, LegacyMask, media::AudioInputFlags, audio_input_flags_t>(
             legacyMask, legacy2aidl_audio_input_flags_t_AudioInputFlags,
-            index2enum_bitmask<audio_input_flags_t>,
+            indexToEnum_bitmask<audio_input_flags_t>,
             enumToMask_index<int32_t, media::AudioInputFlags>);
 }
 
 ConversionResult<audio_output_flags_t> aidl2legacy_int32_t_audio_output_flags_t_mask(
         int32_t aidl) {
     return convertBitmask<audio_output_flags_t,
-                          int32_t,
-                          audio_output_flags_t,
-                          media::AudioOutputFlags>(
+            int32_t,
+            audio_output_flags_t,
+            media::AudioOutputFlags>(
             aidl, aidl2legacy_AudioOutputFlags_audio_output_flags_t,
-            index2enum_index<media::AudioOutputFlags>,
+            indexToEnum_index<media::AudioOutputFlags>,
             enumToMask_bitmask<audio_output_flags_t, audio_output_flags_t>);
 }
 
@@ -729,7 +649,7 @@
     LegacyMask legacyMask = static_cast<LegacyMask>(legacy);
     return convertBitmask<int32_t, LegacyMask, media::AudioOutputFlags, audio_output_flags_t>(
             legacyMask, legacy2aidl_audio_output_flags_t_AudioOutputFlags,
-            index2enum_bitmask<audio_output_flags_t>,
+            indexToEnum_bitmask<audio_output_flags_t>,
             enumToMask_index<int32_t, media::AudioOutputFlags>);
 }
 
@@ -1468,7 +1388,7 @@
 ConversionResult<audio_flags_mask_t>
 aidl2legacy_int32_t_audio_flags_mask_t_mask(int32_t aidl) {
     return convertBitmask<audio_flags_mask_t, int32_t, audio_flags_mask_t, media::AudioFlag>(
-            aidl, aidl2legacy_AudioFlag_audio_flags_mask_t, index2enum_index<media::AudioFlag>,
+            aidl, aidl2legacy_AudioFlag_audio_flags_mask_t, indexToEnum_index<media::AudioFlag>,
             enumToMask_bitmask<audio_flags_mask_t, audio_flags_mask_t>);
 }
 
@@ -1476,7 +1396,7 @@
 legacy2aidl_audio_flags_mask_t_int32_t_mask(audio_flags_mask_t legacy) {
     return convertBitmask<int32_t, audio_flags_mask_t, media::AudioFlag, audio_flags_mask_t>(
             legacy, legacy2aidl_audio_flags_mask_t_AudioFlag,
-            index2enum_bitmask<audio_flags_mask_t>,
+            indexToEnum_bitmask<audio_flags_mask_t>,
             enumToMask_index<int32_t, media::AudioFlag>);
 }
 
@@ -1779,44 +1699,44 @@
 ConversionResult<uint32_t>
 aidl2legacy_AudioEncapsulationMode_mask(int32_t aidl) {
     return convertBitmask<uint32_t,
-                          int32_t,
-                          audio_encapsulation_mode_t,
-                          media::AudioEncapsulationMode>(
+            int32_t,
+            audio_encapsulation_mode_t,
+            media::AudioEncapsulationMode>(
             aidl, aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t,
-            index2enum_index<media::AudioEncapsulationMode>,
+            indexToEnum_index<media::AudioEncapsulationMode>,
             enumToMask_index<uint32_t, audio_encapsulation_mode_t>);
 }
 
 ConversionResult<int32_t>
 legacy2aidl_AudioEncapsulationMode_mask(uint32_t legacy) {
     return convertBitmask<int32_t,
-                          uint32_t,
-                          media::AudioEncapsulationMode,
-                          audio_encapsulation_mode_t>(
+            uint32_t,
+            media::AudioEncapsulationMode,
+            audio_encapsulation_mode_t>(
             legacy, legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode,
-            index2enum_index<audio_encapsulation_mode_t>,
+            indexToEnum_index<audio_encapsulation_mode_t>,
             enumToMask_index<int32_t, media::AudioEncapsulationMode>);
 }
 
 ConversionResult<uint32_t>
 aidl2legacy_AudioEncapsulationMetadataType_mask(int32_t aidl) {
     return convertBitmask<uint32_t,
-                          int32_t,
-                          audio_encapsulation_metadata_type_t,
-                          media::AudioEncapsulationMetadataType>(
+            int32_t,
+            audio_encapsulation_metadata_type_t,
+            media::AudioEncapsulationMetadataType>(
             aidl, aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t,
-            index2enum_index<media::AudioEncapsulationMetadataType>,
+            indexToEnum_index<media::AudioEncapsulationMetadataType>,
             enumToMask_index<uint32_t, audio_encapsulation_metadata_type_t>);
 }
 
 ConversionResult<int32_t>
 legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy) {
     return convertBitmask<int32_t,
-                          uint32_t,
-                          media::AudioEncapsulationMetadataType,
-                          audio_encapsulation_metadata_type_t>(
+            uint32_t,
+            media::AudioEncapsulationMetadataType,
+            audio_encapsulation_metadata_type_t>(
             legacy, legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType,
-            index2enum_index<audio_encapsulation_metadata_type_t>,
+            indexToEnum_index<audio_encapsulation_metadata_type_t>,
             enumToMask_index<int32_t, media::AudioEncapsulationMetadataType>);
 }
 
@@ -2197,4 +2117,14 @@
     return convertReinterpret<int32_t>(legacy);
 }
 
+ConversionResult<product_strategy_t>
+aidl2legacy_int32_t_product_strategy_t(int32_t aidl) {
+    return convertReinterpret<product_strategy_t>(aidl);
+}
+
+ConversionResult<int32_t>
+legacy2aidl_product_strategy_t_int32_t(product_strategy_t legacy) {
+    return convertReinterpret<int32_t>(legacy);
+}
+
 }  // namespace android
diff --git a/media/libaudioclient/Android.bp b/media/libaudioclient/Android.bp
index aa740a7..a1708ee 100644
--- a/media/libaudioclient/Android.bp
+++ b/media/libaudioclient/Android.bp
@@ -37,11 +37,16 @@
         "AudioPolicy.cpp",
         "AudioProductStrategy.cpp",
         "AudioVolumeGroup.cpp",
+        "PolicyAidlConversion.cpp"
     ],
     shared_libs: [
+        "audioclient-types-aidl-unstable-cpp",
         "audioflinger-aidl-unstable-cpp",
-        "capture_state_listener-aidl-cpp",
+        "audiopolicy-aidl-unstable-cpp",
+        "audiopolicy-types-aidl-unstable-cpp",
+        "capture_state_listener-aidl-unstable-cpp",
         "libaudiofoundation",
+        "libaudioclient_aidl_conversion",
         "libaudioutils",
         "libbinder",
         "libcutils",
@@ -55,8 +60,13 @@
     include_dirs: ["system/media/audio_utils/include"],
     export_include_dirs: ["include"],
     export_shared_lib_headers: [
+        "audioclient-types-aidl-unstable-cpp",
         "audioflinger-aidl-unstable-cpp",
-        "capture_state_listener-aidl-cpp",
+        "audiopolicy-aidl-unstable-cpp",
+        "audiopolicy-types-aidl-unstable-cpp",
+        "capture_state_listener-aidl-unstable-cpp",
+        "libaudiofoundation",
+        "libaudioclient_aidl_conversion",
     ],
     header_libs: ["libaudioclient_headers"],
 }
@@ -84,7 +94,6 @@
         "AudioTrack.cpp",
         "AudioTrackShared.cpp",
         "IAudioFlinger.cpp",
-        "IAudioPolicyService.cpp",
         "ToneGenerator.cpp",
         "PlayerBase.cpp",
         "RecordingActivityTracker.cpp",
@@ -94,8 +103,9 @@
         "audioclient-types-aidl-unstable-cpp",
         "audioflinger-aidl-unstable-cpp",
         "audiopolicy-aidl-unstable-cpp",
+        "audiopolicy-types-aidl-unstable-cpp",
         "av-types-aidl-unstable-cpp",
-        "capture_state_listener-aidl-cpp",
+        "capture_state_listener-aidl-unstable-cpp",
         "libaudioclient_aidl_conversion",
         "libaudiofoundation",
         "libaudioutils",
@@ -247,6 +257,9 @@
     name: "capture_state_listener-aidl",
     unstable: true,
     local_include_dir: "aidl",
+    host_supported: true,
+    double_loadable: true,
+    vendor_available: true,
     srcs: [
         "aidl/android/media/ICaptureStateListener.aidl",
     ],
@@ -333,6 +346,44 @@
         },
     },
 }
+aidl_interface {
+    name: "audiopolicy-types-aidl",
+    unstable: true,
+    host_supported: true,
+    vendor_available: true,
+    double_loadable: true,
+    local_include_dir: "aidl",
+    srcs: [
+        "aidl/android/media/AudioAttributesEx.aidl",
+        "aidl/android/media/AudioMix.aidl",
+        "aidl/android/media/AudioMixCallbackFlag.aidl",
+        "aidl/android/media/AudioMixMatchCriterion.aidl",
+        "aidl/android/media/AudioMixMatchCriterionValue.aidl",
+        "aidl/android/media/AudioMixRouteFlag.aidl",
+        "aidl/android/media/AudioMixType.aidl",
+        "aidl/android/media/AudioOffloadMode.aidl",
+        "aidl/android/media/AudioPolicyDeviceState.aidl",
+        "aidl/android/media/AudioPolicyForceUse.aidl",
+        "aidl/android/media/AudioPolicyForcedConfig.aidl",
+        "aidl/android/media/AudioProductStrategy.aidl",
+        "aidl/android/media/AudioVolumeGroup.aidl",
+        "aidl/android/media/DeviceRole.aidl",
+        "aidl/android/media/SoundTriggerSession.aidl",
+    ],
+    imports: [
+        "audio_common-aidl",
+        "audioclient-types-aidl",
+    ],
+    backend: {
+        cpp: {
+            min_sdk_version: "29",
+            apex_available: [
+                "//apex_available:platform",
+                "com.android.media",
+            ],
+        },
+    },
+}
 
 aidl_interface {
     name: "audioflinger-aidl",
@@ -385,12 +436,19 @@
     host_supported: true,
     vendor_available: true,
     srcs: [
+        "aidl/android/media/GetInputForAttrResponse.aidl",
+        "aidl/android/media/GetOutputForAttrResponse.aidl",
+        "aidl/android/media/Int.aidl",
         "aidl/android/media/RecordClientInfo.aidl",
 
+        "aidl/android/media/IAudioPolicyService.aidl",
         "aidl/android/media/IAudioPolicyServiceClient.aidl",
     ],
     imports: [
+        "audio_common-aidl",
         "audioclient-types-aidl",
+        "audiopolicy-types-aidl",
+        "capture_state_listener-aidl",
     ],
     double_loadable: true,
     backend: {
diff --git a/media/libaudioclient/AudioAttributes.cpp b/media/libaudioclient/AudioAttributes.cpp
index ff4ba06..83bf5a7 100644
--- a/media/libaudioclient/AudioAttributes.cpp
+++ b/media/libaudioclient/AudioAttributes.cpp
@@ -20,48 +20,46 @@
 
 #include <binder/Parcel.h>
 
+#include <media/AidlConversion.h>
 #include <media/AudioAttributes.h>
+#include <media/PolicyAidlConversion.h>
+
+#define RETURN_STATUS_IF_ERROR(x) \
+    { auto _tmp = (x); if (_tmp != OK) return _tmp; }
 
 namespace android {
 
-status_t AudioAttributes::readFromParcel(const Parcel *parcel)
-{
-    status_t ret = NO_ERROR;
-    mAttributes.content_type = static_cast<audio_content_type_t>(parcel->readInt32());
-    mAttributes.usage = static_cast<audio_usage_t>(parcel->readInt32());
-    mAttributes.source = static_cast<audio_source_t>(parcel->readInt32());
-    mAttributes.flags = static_cast<audio_flags_mask_t>(parcel->readInt32());
-    const bool hasFlattenedTag = (parcel->readInt32() == 1);
-    if (hasFlattenedTag) {
-        std::string tags;
-        ret = parcel->readUtf8FromUtf16(&tags);
-        if (ret != NO_ERROR) {
-            return ret;
-        }
-        std::strncpy(mAttributes.tags, tags.c_str(), AUDIO_ATTRIBUTES_TAGS_MAX_SIZE - 1);
-    } else {
-        strcpy(mAttributes.tags, "");
-    }
-    mStreamType = static_cast<audio_stream_type_t>(parcel->readInt32());
-    mGroupId = static_cast<volume_group_t>(parcel->readUint32());
-    return NO_ERROR;
+status_t AudioAttributes::readFromParcel(const Parcel* parcel) {
+    media::AudioAttributesEx aidl;
+    RETURN_STATUS_IF_ERROR(aidl.readFromParcel(parcel));
+    *this = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioAttributesEx_AudioAttributes(aidl));
+    return OK;
 }
 
-status_t AudioAttributes::writeToParcel(Parcel *parcel) const
-{
-    parcel->writeInt32(static_cast<int32_t>(mAttributes.content_type));
-    parcel->writeInt32(static_cast<int32_t>(mAttributes.usage));
-    parcel->writeInt32(static_cast<int32_t>(mAttributes.source));
-    parcel->writeInt32(static_cast<int32_t>(mAttributes.flags));
-    if (strlen(mAttributes.tags) == 0) {
-        parcel->writeInt32(0);
-    } else {
-        parcel->writeInt32(1);
-        parcel->writeUtf8AsUtf16(std::string(mAttributes.tags));
-    }
-    parcel->writeInt32(static_cast<int32_t>(mStreamType));
-    parcel->writeUint32(static_cast<uint32_t>(mGroupId));
-    return NO_ERROR;
+status_t AudioAttributes::writeToParcel(Parcel* parcel) const {
+    media::AudioAttributesEx aidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_AudioAttributes_AudioAttributesEx(*this));
+    return aidl.writeToParcel(parcel);
+}
+
+ConversionResult<media::AudioAttributesEx>
+legacy2aidl_AudioAttributes_AudioAttributesEx(const AudioAttributes& legacy) {
+    media::AudioAttributesEx aidl;
+    aidl.attributes = VALUE_OR_RETURN(
+            legacy2aidl_audio_attributes_t_AudioAttributesInternal(legacy.getAttributes()));
+    aidl.streamType = VALUE_OR_RETURN(
+            legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.getStreamType()));
+    aidl.groupId = VALUE_OR_RETURN(legacy2aidl_volume_group_t_int32_t(legacy.getGroupId()));
+    return aidl;
+}
+
+ConversionResult<AudioAttributes>
+aidl2legacy_AudioAttributesEx_AudioAttributes(const media::AudioAttributesEx& aidl) {
+    return AudioAttributes(VALUE_OR_RETURN(aidl2legacy_int32_t_volume_group_t(aidl.groupId)),
+                           VALUE_OR_RETURN(aidl2legacy_AudioStreamType_audio_stream_type_t(
+                                   aidl.streamType)),
+                           VALUE_OR_RETURN(aidl2legacy_AudioAttributesInternal_audio_attributes_t(
+                                   aidl.attributes)));
 }
 
 } // namespace android
diff --git a/media/libaudioclient/AudioEffect.cpp b/media/libaudioclient/AudioEffect.cpp
index 79ea1bb..ad8ad7b 100644
--- a/media/libaudioclient/AudioEffect.cpp
+++ b/media/libaudioclient/AudioEffect.cpp
@@ -23,15 +23,25 @@
 #include <sys/types.h>
 #include <limits.h>
 
+#include <android/media/IAudioPolicyService.h>
 #include <binder/IPCThreadState.h>
+#include <media/AidlConversion.h>
 #include <media/AudioEffect.h>
+#include <media/PolicyAidlConversion.h>
 #include <media/ShmemCompat.h>
 #include <private/media/AudioEffectShared.h>
 #include <utils/Log.h>
 
+#define RETURN_STATUS_IF_ERROR(x)    \
+    {                                \
+        auto _tmp = (x);             \
+        if (_tmp != OK) return _tmp; \
+    }
+
 namespace android {
 using aidl_utils::statusTFromBinderStatus;
 using binder::Status;
+using media::IAudioPolicyService;
 
 namespace {
 
@@ -539,9 +549,23 @@
                                           effect_descriptor_t *descriptors,
                                           uint32_t *count)
 {
+    if (descriptors == nullptr || count == nullptr) {
+        return BAD_VALUE;
+    }
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->queryDefaultPreProcessing(audioSession, descriptors, count);
+
+    int32_t audioSessionAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_session_t_int32_t(audioSession));
+    media::Int countAidl;
+    countAidl.value = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*count));
+    std::vector<media::EffectDescriptor> retAidl;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->queryDefaultPreProcessing(audioSessionAidl, &countAidl, &retAidl)));
+    *count = VALUE_OR_RETURN_STATUS(convertIntegral<uint32_t>(countAidl.value));
+    RETURN_STATUS_IF_ERROR(convertRange(retAidl.begin(), retAidl.end(), descriptors,
+                                        aidl2legacy_EffectDescriptor_effect_descriptor_t));
+    return OK;
 }
 
 status_t AudioEffect::newEffectUniqueId(audio_unique_id_t* id)
@@ -581,7 +605,18 @@
         uuid = *EFFECT_UUID_NULL;
     }
 
-    return aps->addSourceDefaultEffect(&type, opPackageName, &uuid, priority, source, id);
+    media::AudioUuid typeAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(type));
+    media::AudioUuid uuidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(uuid));
+    std::string opPackageNameAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_String16_string(opPackageName));
+    media::AudioSourceType sourceAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_source_t_AudioSourceType(source));
+    int32_t retAidl;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->addSourceDefaultEffect(typeAidl, opPackageNameAidl, uuidAidl, priority, sourceAidl,
+                                        &retAidl)));
+    *id = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_unique_id_t(retAidl));
+    return OK;
 }
 
 status_t AudioEffect::addStreamDefaultEffect(const char *typeStr,
@@ -613,7 +648,18 @@
         uuid = *EFFECT_UUID_NULL;
     }
 
-    return aps->addStreamDefaultEffect(&type, opPackageName, &uuid, priority, usage, id);
+    media::AudioUuid typeAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(type));
+    media::AudioUuid uuidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(uuid));
+    std::string opPackageNameAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_String16_string(opPackageName));
+    media::AudioUsage usageAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_usage_t_AudioUsage(usage));
+    int32_t retAidl;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->addStreamDefaultEffect(typeAidl, opPackageNameAidl, uuidAidl, priority, usageAidl,
+                                        &retAidl)));
+    *id = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_unique_id_t(retAidl));
+    return OK;
 }
 
 status_t AudioEffect::removeSourceDefaultEffect(audio_unique_id_t id)
@@ -621,7 +667,8 @@
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
 
-    return aps->removeSourceDefaultEffect(id);
+    int32_t idAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));
+    return statusTFromBinderStatus(aps->removeSourceDefaultEffect(idAidl));
 }
 
 status_t AudioEffect::removeStreamDefaultEffect(audio_unique_id_t id)
@@ -629,7 +676,8 @@
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
 
-    return aps->removeStreamDefaultEffect(id);
+    int32_t idAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));
+    return statusTFromBinderStatus(aps->removeStreamDefaultEffect(idAidl));
 }
 
 // -------------------------------------------------------------------------
diff --git a/media/libaudioclient/AudioProductStrategy.cpp b/media/libaudioclient/AudioProductStrategy.cpp
index cff72fd..f98027a 100644
--- a/media/libaudioclient/AudioProductStrategy.cpp
+++ b/media/libaudioclient/AudioProductStrategy.cpp
@@ -19,55 +19,47 @@
 #include <utils/Log.h>
 #include <media/AudioProductStrategy.h>
 #include <media/AudioAttributes.h>
-#include <media/AudioSystem.h>
+#include <media/PolicyAidlConversion.h>
+
+#define RETURN_STATUS_IF_ERROR(x) \
+    { auto _tmp = (x); if (_tmp != OK) return _tmp; }
 
 namespace android {
 
-status_t AudioProductStrategy::readFromParcel(const Parcel *parcel)
-{
-    mId = static_cast<product_strategy_t>(parcel->readInt32());
-    status_t ret = parcel->readUtf8FromUtf16(&mName);
-    if (ret != NO_ERROR) {
-        return ret;
-    }
-    size_t size = static_cast<size_t>(parcel->readInt32());
-    for (size_t i = 0; i < size; i++) {
-        AudioAttributes attribute;
-        ret = attribute.readFromParcel(parcel);
-        if (ret != NO_ERROR) {
-            mAudioAttributes.clear();
-            return ret;
-        }
-        mAudioAttributes.push_back(attribute);
-    }
-    return NO_ERROR;
+status_t AudioProductStrategy::readFromParcel(const Parcel* parcel) {
+    media::AudioProductStrategy aidl;
+    RETURN_STATUS_IF_ERROR(aidl.readFromParcel(parcel));
+    *this = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioProductStrategy(aidl));
+    return OK;
 }
 
-status_t AudioProductStrategy::writeToParcel(Parcel *parcel) const
-{
-    parcel->writeInt32(static_cast<int32_t>(mId));
-    parcel->writeUtf8AsUtf16(mName);
-    size_t size = mAudioAttributes.size();
-    size_t sizePosition = parcel->dataPosition();
-    parcel->writeInt32(size);
-    size_t finalSize = size;
+status_t AudioProductStrategy::writeToParcel(Parcel* parcel) const {
+    media::AudioProductStrategy aidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_AudioProductStrategy(*this));
+    return aidl.writeToParcel(parcel);
+}
 
-    for (size_t i = 0; i < size; i++) {
-        size_t position = parcel->dataPosition();
-        AudioAttributes attribute(mAudioAttributes[i]);
-        status_t ret = attribute.writeToParcel(parcel);
-        if (ret != NO_ERROR) {
-            parcel->setDataPosition(position);
-            finalSize--;
-        }
-    }
-    if (size != finalSize) {
-        size_t position = parcel->dataPosition();
-        parcel->setDataPosition(sizePosition);
-        parcel->writeInt32(finalSize);
-        parcel->setDataPosition(position);
-    }
-    return NO_ERROR;
+ConversionResult<media::AudioProductStrategy>
+legacy2aidl_AudioProductStrategy(const AudioProductStrategy& legacy) {
+    media::AudioProductStrategy aidl;
+    aidl.name = legacy.getName();
+    aidl.audioAttributes = VALUE_OR_RETURN(
+            convertContainer<std::vector<media::AudioAttributesEx>>(
+                    legacy.getAudioAttributes(),
+                    legacy2aidl_AudioAttributes_AudioAttributesEx));
+    aidl.id = VALUE_OR_RETURN(legacy2aidl_product_strategy_t_int32_t(legacy.getId()));
+    return aidl;
+}
+
+ConversionResult<AudioProductStrategy>
+aidl2legacy_AudioProductStrategy(const media::AudioProductStrategy& aidl) {
+    return AudioProductStrategy(
+            aidl.name,
+            VALUE_OR_RETURN(
+                    convertContainer<std::vector<AudioAttributes>>(
+                            aidl.audioAttributes,
+                            aidl2legacy_AudioAttributesEx_AudioAttributes)),
+            VALUE_OR_RETURN(aidl2legacy_int32_t_product_strategy_t(aidl.id)));
 }
 
 // Keep in sync with android/media/audiopolicy/AudioProductStrategy#attributeMatches
diff --git a/media/libaudioclient/AudioSystem.cpp b/media/libaudioclient/AudioSystem.cpp
index 2187635..5ce5974 100644
--- a/media/libaudioclient/AudioSystem.cpp
+++ b/media/libaudioclient/AudioSystem.cpp
@@ -19,6 +19,7 @@
 
 #include <utils/Log.h>
 
+#include <android/media/IAudioPolicyService.h>
 #include <android/media/BnCaptureStateListener.h>
 #include <binder/IServiceManager.h>
 #include <binder/ProcessState.h>
@@ -27,22 +28,30 @@
 #include <media/AudioResamplerPublic.h>
 #include <media/AudioSystem.h>
 #include <media/IAudioFlinger.h>
-#include <media/IAudioPolicyService.h>
+#include <media/PolicyAidlConversion.h>
 #include <media/TypeConverter.h>
 #include <math.h>
 
 #include <system/audio.h>
+#include <android/media/GetInputForAttrResponse.h>
 
 #define VALUE_OR_RETURN_BINDER_STATUS(x) \
     ({ auto _tmp = (x); \
        if (!_tmp.ok()) return aidl_utils::binderStatusFromStatusT(_tmp.error()); \
        std::move(_tmp.value()); })
 
+#define RETURN_STATUS_IF_ERROR(x)    \
+    {                                \
+        auto _tmp = (x);             \
+        if (_tmp != OK) return _tmp; \
+    }
+
 // ----------------------------------------------------------------------------
 
 namespace android {
-
+using aidl_utils::statusTFromBinderStatus;
 using binder::Status;
+using media::IAudioPolicyService;
 
 // client singleton for AudioFlinger binder interface
 Mutex AudioSystem::gLock;
@@ -57,12 +66,12 @@
 
 // Required to be held while calling into gSoundTriggerCaptureStateListener.
 class CaptureStateListenerImpl;
+
 Mutex gSoundTriggerCaptureStateListenerLock;
 sp<CaptureStateListenerImpl> gSoundTriggerCaptureStateListener = nullptr;
 
 // establish binder interface to AudioFlinger service
-const sp<IAudioFlinger> AudioSystem::get_audio_flinger()
-{
+const sp<IAudioFlinger> AudioSystem::get_audio_flinger() {
     sp<IAudioFlinger> af;
     sp<AudioFlingerClient> afc;
     bool reportNoError = false;
@@ -102,8 +111,7 @@
     return af;
 }
 
-const sp<AudioSystem::AudioFlingerClient> AudioSystem::getAudioFlingerClient()
-{
+const sp<AudioSystem::AudioFlingerClient> AudioSystem::getAudioFlingerClient() {
     // calling get_audio_flinger() will initialize gAudioFlingerClient if needed
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return 0;
@@ -111,8 +119,7 @@
     return gAudioFlingerClient;
 }
 
-sp<AudioIoDescriptor> AudioSystem::getIoDescriptor(audio_io_handle_t ioHandle)
-{
+sp<AudioIoDescriptor> AudioSystem::getIoDescriptor(audio_io_handle_t ioHandle) {
     sp<AudioIoDescriptor> desc;
     const sp<AudioFlingerClient> afc = getAudioFlingerClient();
     if (afc != 0) {
@@ -121,8 +128,7 @@
     return desc;
 }
 
-/* static */ status_t AudioSystem::checkAudioFlinger()
-{
+/* static */ status_t AudioSystem::checkAudioFlinger() {
     if (defaultServiceManager()->checkService(String16("media.audio_flinger")) != 0) {
         return NO_ERROR;
     }
@@ -131,47 +137,41 @@
 
 // FIXME Declare in binder opcode order, similarly to IAudioFlinger.h and IAudioFlinger.cpp
 
-status_t AudioSystem::muteMicrophone(bool state)
-{
+status_t AudioSystem::muteMicrophone(bool state) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     return af->setMicMute(state);
 }
 
-status_t AudioSystem::isMicrophoneMuted(bool* state)
-{
+status_t AudioSystem::isMicrophoneMuted(bool* state) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     *state = af->getMicMute();
     return NO_ERROR;
 }
 
-status_t AudioSystem::setMasterVolume(float value)
-{
+status_t AudioSystem::setMasterVolume(float value) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     af->setMasterVolume(value);
     return NO_ERROR;
 }
 
-status_t AudioSystem::setMasterMute(bool mute)
-{
+status_t AudioSystem::setMasterMute(bool mute) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     af->setMasterMute(mute);
     return NO_ERROR;
 }
 
-status_t AudioSystem::getMasterVolume(float* volume)
-{
+status_t AudioSystem::getMasterVolume(float* volume) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     *volume = af->masterVolume();
     return NO_ERROR;
 }
 
-status_t AudioSystem::getMasterMute(bool* mute)
-{
+status_t AudioSystem::getMasterMute(bool* mute) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     *mute = af->masterMute();
@@ -179,8 +179,7 @@
 }
 
 status_t AudioSystem::setStreamVolume(audio_stream_type_t stream, float value,
-        audio_io_handle_t output)
-{
+                                      audio_io_handle_t output) {
     if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
@@ -188,8 +187,7 @@
     return NO_ERROR;
 }
 
-status_t AudioSystem::setStreamMute(audio_stream_type_t stream, bool mute)
-{
+status_t AudioSystem::setStreamMute(audio_stream_type_t stream, bool mute) {
     if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
@@ -198,8 +196,7 @@
 }
 
 status_t AudioSystem::getStreamVolume(audio_stream_type_t stream, float* volume,
-        audio_io_handle_t output)
-{
+                                      audio_io_handle_t output) {
     if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
@@ -207,8 +204,7 @@
     return NO_ERROR;
 }
 
-status_t AudioSystem::getStreamMute(audio_stream_type_t stream, bool* mute)
-{
+status_t AudioSystem::getStreamMute(audio_stream_type_t stream, bool* mute) {
     if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
@@ -216,23 +212,20 @@
     return NO_ERROR;
 }
 
-status_t AudioSystem::setMode(audio_mode_t mode)
-{
+status_t AudioSystem::setMode(audio_mode_t mode) {
     if (uint32_t(mode) >= AUDIO_MODE_CNT) return BAD_VALUE;
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     return af->setMode(mode);
 }
 
-status_t AudioSystem::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs)
-{
+status_t AudioSystem::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     return af->setParameters(ioHandle, keyValuePairs);
 }
 
-String8 AudioSystem::getParameters(audio_io_handle_t ioHandle, const String8& keys)
-{
+String8 AudioSystem::getParameters(audio_io_handle_t ioHandle, const String8& keys) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     String8 result = String8("");
     if (af == 0) return result;
@@ -241,13 +234,11 @@
     return result;
 }
 
-status_t AudioSystem::setParameters(const String8& keyValuePairs)
-{
+status_t AudioSystem::setParameters(const String8& keyValuePairs) {
     return setParameters(AUDIO_IO_HANDLE_NONE, keyValuePairs);
 }
 
-String8 AudioSystem::getParameters(const String8& keys)
-{
+String8 AudioSystem::getParameters(const String8& keys) {
     return getParameters(AUDIO_IO_HANDLE_NONE, keys);
 }
 
@@ -259,16 +250,14 @@
 static const float dBConvert = -dBPerStep * 2.302585093f / 20.0f;
 static const float dBConvertInverse = 1.0f / dBConvert;
 
-float AudioSystem::linearToLog(int volume)
-{
+float AudioSystem::linearToLog(int volume) {
     // float v = volume ? exp(float(100 - volume) * dBConvert) : 0;
     // ALOGD("linearToLog(%d)=%f", volume, v);
     // return v;
     return volume ? exp(float(100 - volume) * dBConvert) : 0;
 }
 
-int AudioSystem::logToLinear(float volume)
-{
+int AudioSystem::logToLinear(float volume) {
     // int v = volume ? 100 - int(dBConvertInverse * log(volume) + 0.5) : 0;
     // ALOGD("logTolinear(%d)=%f", v, volume);
     // return v;
@@ -277,31 +266,30 @@
 
 /* static */ size_t AudioSystem::calculateMinFrameCount(
         uint32_t afLatencyMs, uint32_t afFrameCount, uint32_t afSampleRate,
-        uint32_t sampleRate, float speed /*, uint32_t notificationsPerBufferReq*/)
-{
+        uint32_t sampleRate, float speed /*, uint32_t notificationsPerBufferReq*/) {
     // Ensure that buffer depth covers at least audio hardware latency
     uint32_t minBufCount = afLatencyMs / ((1000 * afFrameCount) / afSampleRate);
     if (minBufCount < 2) {
         minBufCount = 2;
     }
 #if 0
-    // The notificationsPerBufferReq parameter is not yet used for non-fast tracks,
-    // but keeping the code here to make it easier to add later.
-    if (minBufCount < notificationsPerBufferReq) {
-        minBufCount = notificationsPerBufferReq;
-    }
+        // The notificationsPerBufferReq parameter is not yet used for non-fast tracks,
+        // but keeping the code here to make it easier to add later.
+        if (minBufCount < notificationsPerBufferReq) {
+            minBufCount = notificationsPerBufferReq;
+        }
 #endif
     ALOGV("calculateMinFrameCount afLatency %u  afFrameCount %u  afSampleRate %u  "
-            "sampleRate %u  speed %f  minBufCount: %u" /*"  notificationsPerBufferReq %u"*/,
-            afLatencyMs, afFrameCount, afSampleRate, sampleRate, speed, minBufCount
-            /*, notificationsPerBufferReq*/);
+          "sampleRate %u  speed %f  minBufCount: %u" /*"  notificationsPerBufferReq %u"*/,
+          afLatencyMs, afFrameCount, afSampleRate, sampleRate, speed, minBufCount
+    /*, notificationsPerBufferReq*/);
     return minBufCount * sourceFramesNeededWithTimestretch(
             sampleRate, afFrameCount, afSampleRate, speed);
 }
 
 
-status_t AudioSystem::getOutputSamplingRate(uint32_t* samplingRate, audio_stream_type_t streamType)
-{
+status_t
+AudioSystem::getOutputSamplingRate(uint32_t* samplingRate, audio_stream_type_t streamType) {
     audio_io_handle_t output;
 
     if (streamType == AUDIO_STREAM_DEFAULT) {
@@ -317,8 +305,7 @@
 }
 
 status_t AudioSystem::getSamplingRate(audio_io_handle_t ioHandle,
-                                      uint32_t* samplingRate)
-{
+                                      uint32_t* samplingRate) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     sp<AudioIoDescriptor> desc = getIoDescriptor(ioHandle);
@@ -337,8 +324,7 @@
     return NO_ERROR;
 }
 
-status_t AudioSystem::getOutputFrameCount(size_t* frameCount, audio_stream_type_t streamType)
-{
+status_t AudioSystem::getOutputFrameCount(size_t* frameCount, audio_stream_type_t streamType) {
     audio_io_handle_t output;
 
     if (streamType == AUDIO_STREAM_DEFAULT) {
@@ -354,8 +340,7 @@
 }
 
 status_t AudioSystem::getFrameCount(audio_io_handle_t ioHandle,
-                                    size_t* frameCount)
-{
+                                    size_t* frameCount) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     sp<AudioIoDescriptor> desc = getIoDescriptor(ioHandle);
@@ -374,8 +359,7 @@
     return NO_ERROR;
 }
 
-status_t AudioSystem::getOutputLatency(uint32_t* latency, audio_stream_type_t streamType)
-{
+status_t AudioSystem::getOutputLatency(uint32_t* latency, audio_stream_type_t streamType) {
     audio_io_handle_t output;
 
     if (streamType == AUDIO_STREAM_DEFAULT) {
@@ -391,8 +375,7 @@
 }
 
 status_t AudioSystem::getLatency(audio_io_handle_t output,
-                                 uint32_t* latency)
-{
+                                 uint32_t* latency) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     sp<AudioIoDescriptor> outputDesc = getIoDescriptor(output);
@@ -408,8 +391,7 @@
 }
 
 status_t AudioSystem::getInputBufferSize(uint32_t sampleRate, audio_format_t format,
-        audio_channel_mask_t channelMask, size_t* buffSize)
-{
+                                         audio_channel_mask_t channelMask, size_t* buffSize) {
     const sp<AudioFlingerClient> afc = getAudioFlingerClient();
     if (afc == 0) {
         return NO_INIT;
@@ -417,24 +399,21 @@
     return afc->getInputBufferSize(sampleRate, format, channelMask, buffSize);
 }
 
-status_t AudioSystem::setVoiceVolume(float value)
-{
+status_t AudioSystem::setVoiceVolume(float value) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     return af->setVoiceVolume(value);
 }
 
-status_t AudioSystem::getRenderPosition(audio_io_handle_t output, uint32_t *halFrames,
-                                        uint32_t *dspFrames)
-{
+status_t AudioSystem::getRenderPosition(audio_io_handle_t output, uint32_t* halFrames,
+                                        uint32_t* dspFrames) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
 
     return af->getRenderPosition(halFrames, dspFrames, output);
 }
 
-uint32_t AudioSystem::getInputFramesLost(audio_io_handle_t ioHandle)
-{
+uint32_t AudioSystem::getInputFramesLost(audio_io_handle_t ioHandle) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     uint32_t result = 0;
     if (af == 0) return result;
@@ -444,47 +423,41 @@
     return result;
 }
 
-audio_unique_id_t AudioSystem::newAudioUniqueId(audio_unique_id_use_t use)
-{
+audio_unique_id_t AudioSystem::newAudioUniqueId(audio_unique_id_use_t use) {
     // Must not use AF as IDs will re-roll on audioserver restart, b/130369529.
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return AUDIO_UNIQUE_ID_ALLOCATE;
     return af->newAudioUniqueId(use);
 }
 
-void AudioSystem::acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid)
-{
+void AudioSystem::acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af != 0) {
         af->acquireAudioSessionId(audioSession, pid, uid);
     }
 }
 
-void AudioSystem::releaseAudioSessionId(audio_session_t audioSession, pid_t pid)
-{
+void AudioSystem::releaseAudioSessionId(audio_session_t audioSession, pid_t pid) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af != 0) {
         af->releaseAudioSessionId(audioSession, pid);
     }
 }
 
-audio_hw_sync_t AudioSystem::getAudioHwSyncForSession(audio_session_t sessionId)
-{
+audio_hw_sync_t AudioSystem::getAudioHwSyncForSession(audio_session_t sessionId) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return AUDIO_HW_SYNC_INVALID;
     return af->getAudioHwSyncForSession(sessionId);
 }
 
-status_t AudioSystem::systemReady()
-{
+status_t AudioSystem::systemReady() {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return NO_INIT;
     return af->systemReady();
 }
 
 status_t AudioSystem::getFrameCountHAL(audio_io_handle_t ioHandle,
-                                       size_t* frameCount)
-{
+                                       size_t* frameCount) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     sp<AudioIoDescriptor> desc = getIoDescriptor(ioHandle);
@@ -506,8 +479,7 @@
 // ---------------------------------------------------------------------------
 
 
-void AudioSystem::AudioFlingerClient::clearIoCache()
-{
+void AudioSystem::AudioFlingerClient::clearIoCache() {
     Mutex::Autolock _l(mLock);
     mIoDescriptors.clear();
     mInBuffSize = 0;
@@ -516,8 +488,7 @@
     mInChannelMask = AUDIO_CHANNEL_NONE;
 }
 
-void AudioSystem::AudioFlingerClient::binderDied(const wp<IBinder>& who __unused)
-{
+void AudioSystem::AudioFlingerClient::binderDied(const wp<IBinder>& who __unused) {
     {
         Mutex::Autolock _l(AudioSystem::gLock);
         AudioSystem::gAudioFlinger.clear();
@@ -537,7 +508,8 @@
     audio_io_config_event event = VALUE_OR_RETURN_BINDER_STATUS(
             aidl2legacy_AudioIoConfigEvent_audio_io_config_event(_event));
     sp<AudioIoDescriptor> ioDesc(
-            VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_AudioIoDescriptor_AudioIoDescriptor(_ioDesc)));
+            VALUE_OR_RETURN_BINDER_STATUS(
+                    aidl2legacy_AudioIoDescriptor_AudioIoDescriptor(_ioDesc)));
 
     ALOGV("ioConfigChanged() event %d", event);
 
@@ -550,96 +522,102 @@
         auto callbacks = std::map<audio_port_handle_t, wp<AudioDeviceCallback>>();
 
         switch (event) {
-        case AUDIO_OUTPUT_OPENED:
-        case AUDIO_OUTPUT_REGISTERED:
-        case AUDIO_INPUT_OPENED:
-        case AUDIO_INPUT_REGISTERED: {
-            sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->mIoHandle);
-            if (oldDesc == 0) {
-                mIoDescriptors.add(ioDesc->mIoHandle, ioDesc);
-            } else {
+            case AUDIO_OUTPUT_OPENED:
+            case AUDIO_OUTPUT_REGISTERED:
+            case AUDIO_INPUT_OPENED:
+            case AUDIO_INPUT_REGISTERED: {
+                sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->mIoHandle);
+                if (oldDesc == 0) {
+                    mIoDescriptors.add(ioDesc->mIoHandle, ioDesc);
+                } else {
+                    deviceId = oldDesc->getDeviceId();
+                    mIoDescriptors.replaceValueFor(ioDesc->mIoHandle, ioDesc);
+                }
+
+                if (ioDesc->getDeviceId() != AUDIO_PORT_HANDLE_NONE) {
+                    deviceId = ioDesc->getDeviceId();
+                    if (event == AUDIO_OUTPUT_OPENED || event == AUDIO_INPUT_OPENED) {
+                        auto it = mAudioDeviceCallbacks.find(ioDesc->mIoHandle);
+                        if (it != mAudioDeviceCallbacks.end()) {
+                            callbacks = it->second;
+                        }
+                    }
+                }
+                ALOGV("ioConfigChanged() new %s %s %d samplingRate %u, format %#x channel mask %#x "
+                      "frameCount %zu deviceId %d",
+                      event == AUDIO_OUTPUT_OPENED || event == AUDIO_OUTPUT_REGISTERED ?
+                      "output" : "input",
+                      event == AUDIO_OUTPUT_OPENED || event == AUDIO_INPUT_OPENED ?
+                      "opened" : "registered",
+                      ioDesc->mIoHandle, ioDesc->mSamplingRate, ioDesc->mFormat,
+                      ioDesc->mChannelMask,
+                      ioDesc->mFrameCount, ioDesc->getDeviceId());
+            }
+                break;
+            case AUDIO_OUTPUT_CLOSED:
+            case AUDIO_INPUT_CLOSED: {
+                if (getIoDescriptor_l(ioDesc->mIoHandle) == 0) {
+                    ALOGW("ioConfigChanged() closing unknown %s %d",
+                          event == AUDIO_OUTPUT_CLOSED ? "output" : "input", ioDesc->mIoHandle);
+                    break;
+                }
+                ALOGV("ioConfigChanged() %s %d closed",
+                      event == AUDIO_OUTPUT_CLOSED ? "output" : "input", ioDesc->mIoHandle);
+
+                mIoDescriptors.removeItem(ioDesc->mIoHandle);
+                mAudioDeviceCallbacks.erase(ioDesc->mIoHandle);
+            }
+                break;
+
+            case AUDIO_OUTPUT_CONFIG_CHANGED:
+            case AUDIO_INPUT_CONFIG_CHANGED: {
+                sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->mIoHandle);
+                if (oldDesc == 0) {
+                    ALOGW("ioConfigChanged() modifying unknown %s! %d",
+                          event == AUDIO_OUTPUT_CONFIG_CHANGED ? "output" : "input",
+                          ioDesc->mIoHandle);
+                    break;
+                }
+
                 deviceId = oldDesc->getDeviceId();
                 mIoDescriptors.replaceValueFor(ioDesc->mIoHandle, ioDesc);
-            }
 
-            if (ioDesc->getDeviceId() != AUDIO_PORT_HANDLE_NONE) {
-                deviceId = ioDesc->getDeviceId();
-                if (event == AUDIO_OUTPUT_OPENED || event == AUDIO_INPUT_OPENED) {
+                if (deviceId != ioDesc->getDeviceId()) {
+                    deviceId = ioDesc->getDeviceId();
                     auto it = mAudioDeviceCallbacks.find(ioDesc->mIoHandle);
                     if (it != mAudioDeviceCallbacks.end()) {
                         callbacks = it->second;
                     }
                 }
+                ALOGV("ioConfigChanged() new config for %s %d samplingRate %u, format %#x "
+                      "channel mask %#x frameCount %zu frameCountHAL %zu deviceId %d",
+                      event == AUDIO_OUTPUT_CONFIG_CHANGED ? "output" : "input",
+                      ioDesc->mIoHandle, ioDesc->mSamplingRate, ioDesc->mFormat,
+                      ioDesc->mChannelMask, ioDesc->mFrameCount, ioDesc->mFrameCountHAL,
+                      ioDesc->getDeviceId());
+
             }
-            ALOGV("ioConfigChanged() new %s %s %d samplingRate %u, format %#x channel mask %#x "
-                    "frameCount %zu deviceId %d",
-                    event == AUDIO_OUTPUT_OPENED || event == AUDIO_OUTPUT_REGISTERED ?
-                            "output" : "input",
-                            event == AUDIO_OUTPUT_OPENED || event == AUDIO_INPUT_OPENED ?
-                            "opened" : "registered",
-                    ioDesc->mIoHandle, ioDesc->mSamplingRate, ioDesc->mFormat, ioDesc->mChannelMask,
-                    ioDesc->mFrameCount, ioDesc->getDeviceId());
-            } break;
-        case AUDIO_OUTPUT_CLOSED:
-        case AUDIO_INPUT_CLOSED: {
-            if (getIoDescriptor_l(ioDesc->mIoHandle) == 0) {
-                ALOGW("ioConfigChanged() closing unknown %s %d",
-                      event == AUDIO_OUTPUT_CLOSED ? "output" : "input", ioDesc->mIoHandle);
                 break;
-            }
-            ALOGV("ioConfigChanged() %s %d closed",
-                  event == AUDIO_OUTPUT_CLOSED ? "output" : "input", ioDesc->mIoHandle);
-
-            mIoDescriptors.removeItem(ioDesc->mIoHandle);
-            mAudioDeviceCallbacks.erase(ioDesc->mIoHandle);
-            } break;
-
-        case AUDIO_OUTPUT_CONFIG_CHANGED:
-        case AUDIO_INPUT_CONFIG_CHANGED: {
-            sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->mIoHandle);
-            if (oldDesc == 0) {
-                ALOGW("ioConfigChanged() modifying unknown %s! %d",
-                    event == AUDIO_OUTPUT_CONFIG_CHANGED ? "output" : "input", ioDesc->mIoHandle);
-                break;
-            }
-
-            deviceId = oldDesc->getDeviceId();
-            mIoDescriptors.replaceValueFor(ioDesc->mIoHandle, ioDesc);
-
-            if (deviceId != ioDesc->getDeviceId()) {
-                deviceId = ioDesc->getDeviceId();
+            case AUDIO_CLIENT_STARTED: {
+                sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->mIoHandle);
+                if (oldDesc == 0) {
+                    ALOGW("ioConfigChanged() start client on unknown io! %d", ioDesc->mIoHandle);
+                    break;
+                }
+                ALOGV("ioConfigChanged() AUDIO_CLIENT_STARTED  io %d port %d num callbacks %zu",
+                      ioDesc->mIoHandle, ioDesc->mPortId, mAudioDeviceCallbacks.size());
+                oldDesc->mPatch = ioDesc->mPatch;
                 auto it = mAudioDeviceCallbacks.find(ioDesc->mIoHandle);
                 if (it != mAudioDeviceCallbacks.end()) {
-                    callbacks = it->second;
+                    auto cbks = it->second;
+                    auto it2 = cbks.find(ioDesc->mPortId);
+                    if (it2 != cbks.end()) {
+                        callbacks.emplace(ioDesc->mPortId, it2->second);
+                        deviceId = oldDesc->getDeviceId();
+                    }
                 }
             }
-            ALOGV("ioConfigChanged() new config for %s %d samplingRate %u, format %#x "
-                    "channel mask %#x frameCount %zu frameCountHAL %zu deviceId %d",
-                    event == AUDIO_OUTPUT_CONFIG_CHANGED ? "output" : "input",
-                    ioDesc->mIoHandle, ioDesc->mSamplingRate, ioDesc->mFormat,
-                    ioDesc->mChannelMask, ioDesc->mFrameCount, ioDesc->mFrameCountHAL,
-                    ioDesc->getDeviceId());
-
-        } break;
-        case AUDIO_CLIENT_STARTED: {
-            sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->mIoHandle);
-            if (oldDesc == 0) {
-                ALOGW("ioConfigChanged() start client on unknown io! %d", ioDesc->mIoHandle);
                 break;
-            }
-            ALOGV("ioConfigChanged() AUDIO_CLIENT_STARTED  io %d port %d num callbacks %zu",
-                ioDesc->mIoHandle, ioDesc->mPortId, mAudioDeviceCallbacks.size());
-            oldDesc->mPatch = ioDesc->mPatch;
-            auto it = mAudioDeviceCallbacks.find(ioDesc->mIoHandle);
-            if (it != mAudioDeviceCallbacks.end()) {
-                auto cbks = it->second;
-                auto it2 = cbks.find(ioDesc->mPortId);
-                if (it2 != cbks.end()) {
-                   callbacks.emplace(ioDesc->mPortId, it2->second);
-                   deviceId = oldDesc->getDeviceId();
-                }
-            }
-        } break;
         }
 
         for (auto wpCbk : callbacks) {
@@ -661,9 +639,8 @@
 }
 
 status_t AudioSystem::AudioFlingerClient::getInputBufferSize(
-                                                uint32_t sampleRate, audio_format_t format,
-                                                audio_channel_mask_t channelMask, size_t* buffSize)
-{
+        uint32_t sampleRate, audio_format_t format,
+        audio_channel_mask_t channelMask, size_t* buffSize) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) {
         return PERMISSION_DENIED;
@@ -675,7 +652,7 @@
         size_t inBuffSize = af->getInputBufferSize(sampleRate, format, channelMask);
         if (inBuffSize == 0) {
             ALOGE("AudioSystem::getInputBufferSize failed sampleRate %d format %#x channelMask %#x",
-                    sampleRate, format, channelMask);
+                  sampleRate, format, channelMask);
             return BAD_VALUE;
         }
         // A benign race is possible here: we could overwrite a fresher cache entry
@@ -692,8 +669,8 @@
     return NO_ERROR;
 }
 
-sp<AudioIoDescriptor> AudioSystem::AudioFlingerClient::getIoDescriptor_l(audio_io_handle_t ioHandle)
-{
+sp<AudioIoDescriptor>
+AudioSystem::AudioFlingerClient::getIoDescriptor_l(audio_io_handle_t ioHandle) {
     sp<AudioIoDescriptor> desc;
     ssize_t index = mIoDescriptors.indexOfKey(ioHandle);
     if (index >= 0) {
@@ -702,19 +679,19 @@
     return desc;
 }
 
-sp<AudioIoDescriptor> AudioSystem::AudioFlingerClient::getIoDescriptor(audio_io_handle_t ioHandle)
-{
+sp<AudioIoDescriptor> AudioSystem::AudioFlingerClient::getIoDescriptor(audio_io_handle_t ioHandle) {
     Mutex::Autolock _l(mLock);
     return getIoDescriptor_l(ioHandle);
 }
 
 status_t AudioSystem::AudioFlingerClient::addAudioDeviceCallback(
         const wp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo,
-        audio_port_handle_t portId)
-{
+        audio_port_handle_t portId) {
     ALOGV("%s audioIo %d portId %d", __func__, audioIo, portId);
     Mutex::Autolock _l(mLock);
-    auto& callbacks = mAudioDeviceCallbacks.emplace(audioIo, std::map<audio_port_handle_t, wp<AudioDeviceCallback>>()).first->second;
+    auto& callbacks = mAudioDeviceCallbacks.emplace(
+            audioIo,
+            std::map<audio_port_handle_t, wp<AudioDeviceCallback>>()).first->second;
     auto result = callbacks.try_emplace(portId, callback);
     if (!result.second) {
         return INVALID_OPERATION;
@@ -724,8 +701,7 @@
 
 status_t AudioSystem::AudioFlingerClient::removeAudioDeviceCallback(
         const wp<AudioDeviceCallback>& callback __unused, audio_io_handle_t audioIo,
-        audio_port_handle_t portId)
-{
+        audio_port_handle_t portId) {
     ALOGV("%s audioIo %d portId %d", __func__, audioIo, portId);
     Mutex::Autolock _l(mLock);
     auto it = mAudioDeviceCallbacks.find(audioIo);
@@ -741,8 +717,7 @@
     return NO_ERROR;
 }
 
-/* static */ uintptr_t AudioSystem::addErrorCallback(audio_error_callback cb)
-{
+/* static */ uintptr_t AudioSystem::addErrorCallback(audio_error_callback cb) {
     Mutex::Autolock _l(gLockErrorCallbacks);
     gAudioErrorCallbacks.insert(cb);
     return reinterpret_cast<uintptr_t>(cb);
@@ -756,24 +731,21 @@
 /* static */ void AudioSystem::reportError(status_t err) {
     Mutex::Autolock _l(gLockErrorCallbacks);
     for (auto callback : gAudioErrorCallbacks) {
-      callback(err);
+        callback(err);
     }
 }
 
-/*static*/ void AudioSystem::setDynPolicyCallback(dynamic_policy_callback cb)
-{
+/*static*/ void AudioSystem::setDynPolicyCallback(dynamic_policy_callback cb) {
     Mutex::Autolock _l(gLock);
     gDynPolicyCallback = cb;
 }
 
-/*static*/ void AudioSystem::setRecordConfigCallback(record_config_callback cb)
-{
+/*static*/ void AudioSystem::setRecordConfigCallback(record_config_callback cb) {
     Mutex::Autolock _l(gLock);
     gRecordConfigCallback = cb;
 }
 
-/*static*/ void AudioSystem::setRoutingCallback(routing_callback cb)
-{
+/*static*/ void AudioSystem::setRoutingCallback(routing_callback cb) {
     Mutex::Autolock _l(gLock);
     gRoutingCallback = cb;
 }
@@ -785,8 +757,7 @@
 
 
 // establish binder interface to AudioPolicy service
-const sp<IAudioPolicyService> AudioSystem::get_audio_policy_service()
-{
+const sp<IAudioPolicyService> AudioSystem::get_audio_policy_service() {
     sp<IAudioPolicyService> ap;
     sp<AudioPolicyServiceClient> apc;
     {
@@ -826,8 +797,7 @@
 
 // ---------------------------------------------------------------------------
 
-void AudioSystem::onNewAudioModulesAvailable()
-{
+void AudioSystem::onNewAudioModulesAvailable() {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return;
     aps->onNewAudioModulesAvailable();
@@ -835,13 +805,12 @@
 
 status_t AudioSystem::setDeviceConnectionState(audio_devices_t device,
                                                audio_policy_dev_state_t state,
-                                               const char *device_address,
-                                               const char *device_name,
-                                               audio_format_t encodedFormat)
-{
+                                               const char* device_address,
+                                               const char* device_name,
+                                               audio_format_t encodedFormat) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
-    const char *address = "";
-    const char *name = "";
+    const char* address = "";
+    const char* name = "";
 
     if (aps == 0) return PERMISSION_DENIED;
 
@@ -851,26 +820,46 @@
     if (device_name != NULL) {
         name = device_name;
     }
-    return aps->setDeviceConnectionState(device, state, address, name, encodedFormat);
+
+    media::AudioDevice deviceAidl;
+    deviceAidl.type = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_devices_t_int32_t(device));
+    deviceAidl.address = address;
+
+    return statusTFromBinderStatus(
+            aps->setDeviceConnectionState(
+                    deviceAidl,
+                    VALUE_OR_RETURN_STATUS(
+                            legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(state)),
+                    name,
+                    VALUE_OR_RETURN_STATUS(legacy2aidl_audio_format_t_AudioFormat(encodedFormat))));
 }
 
 audio_policy_dev_state_t AudioSystem::getDeviceConnectionState(audio_devices_t device,
-                                                  const char *device_address)
-{
+                                                               const char* device_address) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
 
-    return aps->getDeviceConnectionState(device, device_address);
+    auto result = [&]() -> ConversionResult<audio_policy_dev_state_t> {
+        media::AudioDevice deviceAidl;
+        deviceAidl.type = VALUE_OR_RETURN(legacy2aidl_audio_devices_t_int32_t(device));
+        deviceAidl.address = device_address;
+
+        media::AudioPolicyDeviceState result;
+        RETURN_IF_ERROR(statusTFromBinderStatus(
+                aps->getDeviceConnectionState(deviceAidl, &result)));
+
+        return aidl2legacy_AudioPolicyDeviceState_audio_policy_dev_state_t(result);
+    }();
+    return result.value_or(AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE);
 }
 
 status_t AudioSystem::handleDeviceConfigChange(audio_devices_t device,
-                                               const char *device_address,
-                                               const char *device_name,
-                                               audio_format_t encodedFormat)
-{
+                                               const char* device_address,
+                                               const char* device_name,
+                                               audio_format_t encodedFormat) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
-    const char *address = "";
-    const char *name = "";
+    const char* address = "";
+    const char* name = "";
 
     if (aps == 0) return PERMISSION_DENIED;
 
@@ -880,294 +869,533 @@
     if (device_name != NULL) {
         name = device_name;
     }
-    return aps->handleDeviceConfigChange(device, address, name, encodedFormat);
+
+    media::AudioDevice deviceAidl;
+    deviceAidl.type = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_devices_t_int32_t(device));
+    deviceAidl.address = address;
+
+    return statusTFromBinderStatus(
+            aps->handleDeviceConfigChange(deviceAidl, name, VALUE_OR_RETURN_STATUS(
+                    legacy2aidl_audio_format_t_AudioFormat(encodedFormat))));
 }
 
-status_t AudioSystem::setPhoneState(audio_mode_t state, uid_t uid)
-{
+status_t AudioSystem::setPhoneState(audio_mode_t state, uid_t uid) {
     if (uint32_t(state) >= AUDIO_MODE_CNT) return BAD_VALUE;
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
 
-    return aps->setPhoneState(state, uid);
+    return statusTFromBinderStatus(aps->setPhoneState(
+            VALUE_OR_RETURN_STATUS(legacy2aidl_audio_mode_t_AudioMode(state)),
+            VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid))));
 }
 
-status_t AudioSystem::setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config)
-{
+status_t
+AudioSystem::setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->setForceUse(usage, config);
+
+    return statusTFromBinderStatus(
+            aps->setForceUse(
+                    VALUE_OR_RETURN_STATUS(
+                            legacy2aidl_audio_policy_force_use_t_AudioPolicyForceUse(usage)),
+                    VALUE_OR_RETURN_STATUS(
+                            legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(
+                                    config))));
 }
 
-audio_policy_forced_cfg_t AudioSystem::getForceUse(audio_policy_force_use_t usage)
-{
+audio_policy_forced_cfg_t AudioSystem::getForceUse(audio_policy_force_use_t usage) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return AUDIO_POLICY_FORCE_NONE;
-    return aps->getForceUse(usage);
+
+    auto result = [&]() -> ConversionResult<audio_policy_forced_cfg_t> {
+        media::AudioPolicyForceUse usageAidl = VALUE_OR_RETURN(
+                legacy2aidl_audio_policy_force_use_t_AudioPolicyForceUse(usage));
+        media::AudioPolicyForcedConfig configAidl;
+        RETURN_IF_ERROR(statusTFromBinderStatus(
+                aps->getForceUse(usageAidl, &configAidl)));
+        return aidl2legacy_AudioPolicyForcedConfig_audio_policy_forced_cfg_t(configAidl);
+    }();
+
+    return result.value_or(AUDIO_POLICY_FORCE_NONE);
 }
 
 
-audio_io_handle_t AudioSystem::getOutput(audio_stream_type_t stream)
-{
+audio_io_handle_t AudioSystem::getOutput(audio_stream_type_t stream) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
-    if (aps == 0) return 0;
-    return aps->getOutput(stream);
+    if (aps == 0) return AUDIO_IO_HANDLE_NONE;
+
+    auto result = [&]() -> ConversionResult<audio_io_handle_t> {
+        media::AudioStreamType streamAidl = VALUE_OR_RETURN(
+                legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+        int32_t outputAidl;
+        RETURN_IF_ERROR(
+                statusTFromBinderStatus(aps->getOutput(streamAidl, &outputAidl)));
+        return aidl2legacy_int32_t_audio_io_handle_t(outputAidl);
+    }();
+
+    return result.value_or(AUDIO_IO_HANDLE_NONE);
 }
 
-status_t AudioSystem::getOutputForAttr(audio_attributes_t *attr,
-                                        audio_io_handle_t *output,
-                                        audio_session_t session,
-                                        audio_stream_type_t *stream,
-                                        pid_t pid,
-                                        uid_t uid,
-                                        const audio_config_t *config,
-                                        audio_output_flags_t flags,
-                                        audio_port_handle_t *selectedDeviceId,
-                                        audio_port_handle_t *portId,
-                                        std::vector<audio_io_handle_t> *secondaryOutputs)
-{
+status_t AudioSystem::getOutputForAttr(audio_attributes_t* attr,
+                                       audio_io_handle_t* output,
+                                       audio_session_t session,
+                                       audio_stream_type_t* stream,
+                                       pid_t pid,
+                                       uid_t uid,
+                                       const audio_config_t* config,
+                                       audio_output_flags_t flags,
+                                       audio_port_handle_t* selectedDeviceId,
+                                       audio_port_handle_t* portId,
+                                       std::vector<audio_io_handle_t>* secondaryOutputs) {
+    if (attr == nullptr) {
+        ALOGE("%s NULL audio attributes", __func__);
+        return BAD_VALUE;
+    }
+    if (output == nullptr) {
+        ALOGE("%s NULL output - shouldn't happen", __func__);
+        return BAD_VALUE;
+    }
+    if (selectedDeviceId == nullptr) {
+        ALOGE("%s NULL selectedDeviceId - shouldn't happen", __func__);
+        return BAD_VALUE;
+    }
+    if (portId == nullptr) {
+        ALOGE("%s NULL portId - shouldn't happen", __func__);
+        return BAD_VALUE;
+    }
+    if (secondaryOutputs == nullptr) {
+        ALOGE("%s NULL secondaryOutputs - shouldn't happen", __func__);
+        return BAD_VALUE;
+    }
+
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return NO_INIT;
-    return aps->getOutputForAttr(attr, output, session, stream, pid, uid,
-                                 config,
-                                 flags, selectedDeviceId, portId, secondaryOutputs);
+
+    media::AudioAttributesInternal attrAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_attributes_t_AudioAttributesInternal(*attr));
+    int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
+    int32_t pidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(pid));
+    int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
+    media::AudioConfig configAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_config_t_AudioConfig(*config));
+    int32_t flagsAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_output_flags_t_int32_t_mask(flags));
+
+    media::GetOutputForAttrResponse responseAidl;
+
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->getOutputForAttr(attrAidl, sessionAidl, pidAidl, uidAidl, configAidl, flagsAidl,
+                                  &responseAidl)));
+
+    *output = VALUE_OR_RETURN_STATUS(
+            aidl2legacy_int32_t_audio_io_handle_t(responseAidl.output));
+
+    if (stream != nullptr) {
+        *stream = VALUE_OR_RETURN_STATUS(
+                aidl2legacy_AudioStreamType_audio_stream_type_t(responseAidl.stream));
+    }
+    *selectedDeviceId = VALUE_OR_RETURN_STATUS(
+            aidl2legacy_int32_t_audio_port_handle_t(responseAidl.selectedDeviceId));
+    *portId = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_port_handle_t(responseAidl.portId));
+    *secondaryOutputs = VALUE_OR_RETURN_STATUS(convertContainer<std::vector<audio_io_handle_t>>(
+            responseAidl.secondaryOutputs, aidl2legacy_int32_t_audio_io_handle_t));
+
+    return OK;
 }
 
-status_t AudioSystem::startOutput(audio_port_handle_t portId)
-{
+status_t AudioSystem::startOutput(audio_port_handle_t portId) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->startOutput(portId);
+
+    int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
+    return statusTFromBinderStatus(aps->startOutput(portIdAidl));
 }
 
-status_t AudioSystem::stopOutput(audio_port_handle_t portId)
-{
+status_t AudioSystem::stopOutput(audio_port_handle_t portId) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->stopOutput(portId);
+
+    int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
+    return statusTFromBinderStatus(aps->stopOutput(portIdAidl));
 }
 
-void AudioSystem::releaseOutput(audio_port_handle_t portId)
-{
+void AudioSystem::releaseOutput(audio_port_handle_t portId) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return;
-    aps->releaseOutput(portId);
+
+    auto status = [&]() -> status_t {
+        int32_t portIdAidl = VALUE_OR_RETURN_STATUS(
+                legacy2aidl_audio_port_handle_t_int32_t(portId));
+        RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(aps->releaseOutput(portIdAidl)));
+        return OK;
+    }();
+
+    // Ignore status.
+    (void) status;
 }
 
-status_t AudioSystem::getInputForAttr(const audio_attributes_t *attr,
-                                audio_io_handle_t *input,
-                                audio_unique_id_t riid,
-                                audio_session_t session,
-                                pid_t pid,
-                                uid_t uid,
-                                const String16& opPackageName,
-                                const audio_config_base_t *config,
-                                audio_input_flags_t flags,
-                                audio_port_handle_t *selectedDeviceId,
-                                audio_port_handle_t *portId)
-{
+status_t AudioSystem::getInputForAttr(const audio_attributes_t* attr,
+                                      audio_io_handle_t* input,
+                                      audio_unique_id_t riid,
+                                      audio_session_t session,
+                                      pid_t pid,
+                                      uid_t uid,
+                                      const String16& opPackageName,
+                                      const audio_config_base_t* config,
+                                      audio_input_flags_t flags,
+                                      audio_port_handle_t* selectedDeviceId,
+                                      audio_port_handle_t* portId) {
+    if (attr == NULL) {
+        ALOGE("getInputForAttr NULL attr - shouldn't happen");
+        return BAD_VALUE;
+    }
+    if (input == NULL) {
+        ALOGE("getInputForAttr NULL input - shouldn't happen");
+        return BAD_VALUE;
+    }
+    if (selectedDeviceId == NULL) {
+        ALOGE("getInputForAttr NULL selectedDeviceId - shouldn't happen");
+        return BAD_VALUE;
+    }
+    if (portId == NULL) {
+        ALOGE("getInputForAttr NULL portId - shouldn't happen");
+        return BAD_VALUE;
+    }
+
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return NO_INIT;
-    return aps->getInputForAttr(
-            attr, input, riid, session, pid, uid, opPackageName,
-            config, flags, selectedDeviceId, portId);
+
+    media::AudioAttributesInternal attrAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_attributes_t_AudioAttributesInternal(*attr));
+    int32_t inputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(*input));
+    int32_t riidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_unique_id_t_int32_t(riid));
+    int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
+    int32_t pidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(pid));
+    int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
+    std::string opPackageNameAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_String16_string(opPackageName));
+    media::AudioConfigBase configAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_config_base_t_AudioConfigBase(*config));
+    int32_t flagsAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_input_flags_t_int32_t_mask(flags));
+
+    media::GetInputForAttrResponse response;
+
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->getInputForAttr(attrAidl, inputAidl, riidAidl, sessionAidl, pidAidl, uidAidl,
+                                 opPackageNameAidl, configAidl, flagsAidl, &response)));
+
+    *input = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_io_handle_t(response.input));
+    *selectedDeviceId = VALUE_OR_RETURN_STATUS(
+            aidl2legacy_int32_t_audio_port_handle_t(response.selectedDeviceId));
+    *portId = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_port_handle_t(response.portId));
+
+    return OK;
 }
 
-status_t AudioSystem::startInput(audio_port_handle_t portId)
-{
+status_t AudioSystem::startInput(audio_port_handle_t portId) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->startInput(portId);
+
+    int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
+    return statusTFromBinderStatus(aps->startInput(portIdAidl));
 }
 
-status_t AudioSystem::stopInput(audio_port_handle_t portId)
-{
+status_t AudioSystem::stopInput(audio_port_handle_t portId) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->stopInput(portId);
+
+    int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
+    return statusTFromBinderStatus(aps->stopInput(portIdAidl));
 }
 
-void AudioSystem::releaseInput(audio_port_handle_t portId)
-{
+void AudioSystem::releaseInput(audio_port_handle_t portId) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return;
-    aps->releaseInput(portId);
+
+    auto status = [&]() -> status_t {
+        int32_t portIdAidl = VALUE_OR_RETURN_STATUS(
+                legacy2aidl_audio_port_handle_t_int32_t(portId));
+        RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(aps->releaseInput(portIdAidl)));
+        return OK;
+    }();
+
+    // Ignore status.
+    (void) status;
 }
 
 status_t AudioSystem::initStreamVolume(audio_stream_type_t stream,
-                                    int indexMin,
-                                    int indexMax)
-{
+                                       int indexMin,
+                                       int indexMax) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->initStreamVolume(stream, indexMin, indexMax);
+
+    media::AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+    int32_t indexMinAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(indexMin));
+    int32_t indexMaxAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(indexMax));
+    return statusTFromBinderStatus(
+            aps->initStreamVolume(streamAidl, indexMinAidl, indexMaxAidl));
 }
 
 status_t AudioSystem::setStreamVolumeIndex(audio_stream_type_t stream,
                                            int index,
-                                           audio_devices_t device)
-{
+                                           audio_devices_t device) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->setStreamVolumeIndex(stream, index, device);
+
+    media::AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+    int32_t indexAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(index));
+    int32_t deviceAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_devices_t_int32_t(device));
+    return statusTFromBinderStatus(
+            aps->setStreamVolumeIndex(streamAidl, deviceAidl, indexAidl));
 }
 
 status_t AudioSystem::getStreamVolumeIndex(audio_stream_type_t stream,
-                                           int *index,
-                                           audio_devices_t device)
-{
+                                           int* index,
+                                           audio_devices_t device) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->getStreamVolumeIndex(stream, index, device);
+
+    media::AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+    int32_t deviceAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_devices_t_int32_t(device));
+    int32_t indexAidl;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->getStreamVolumeIndex(streamAidl, deviceAidl, &indexAidl)));
+    if (index != nullptr) {
+        *index = VALUE_OR_RETURN_STATUS(convertIntegral<int>(indexAidl));
+    }
+    return OK;
 }
 
-status_t AudioSystem::setVolumeIndexForAttributes(const audio_attributes_t &attr,
+status_t AudioSystem::setVolumeIndexForAttributes(const audio_attributes_t& attr,
                                                   int index,
-                                                  audio_devices_t device)
-{
+                                                  audio_devices_t device) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->setVolumeIndexForAttributes(attr, index, device);
+
+    media::AudioAttributesInternal attrAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_attributes_t_AudioAttributesInternal(attr));
+    int32_t indexAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(index));
+    int32_t deviceAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_devices_t_int32_t(device));
+    return statusTFromBinderStatus(
+            aps->setVolumeIndexForAttributes(attrAidl, deviceAidl, indexAidl));
 }
 
-status_t AudioSystem::getVolumeIndexForAttributes(const audio_attributes_t &attr,
-                                                  int &index,
-                                                  audio_devices_t device)
-{
+status_t AudioSystem::getVolumeIndexForAttributes(const audio_attributes_t& attr,
+                                                  int& index,
+                                                  audio_devices_t device) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->getVolumeIndexForAttributes(attr, index, device);
+
+    media::AudioAttributesInternal attrAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_attributes_t_AudioAttributesInternal(attr));
+    int32_t deviceAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_devices_t_int32_t(device));
+    int32_t indexAidl;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->getVolumeIndexForAttributes(attrAidl, deviceAidl, &indexAidl)));
+    index = VALUE_OR_RETURN_STATUS(convertIntegral<int>(indexAidl));
+    return OK;
 }
 
-status_t AudioSystem::getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index)
-{
+status_t AudioSystem::getMaxVolumeIndexForAttributes(const audio_attributes_t& attr, int& index) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->getMaxVolumeIndexForAttributes(attr, index);
+
+    media::AudioAttributesInternal attrAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_attributes_t_AudioAttributesInternal(attr));
+    int32_t indexAidl;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->getMaxVolumeIndexForAttributes(attrAidl, &indexAidl)));
+    index = VALUE_OR_RETURN_STATUS(convertIntegral<int>(indexAidl));
+    return OK;
 }
 
-status_t AudioSystem::getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index)
-{
+status_t AudioSystem::getMinVolumeIndexForAttributes(const audio_attributes_t& attr, int& index) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->getMinVolumeIndexForAttributes(attr, index);
+
+    media::AudioAttributesInternal attrAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_attributes_t_AudioAttributesInternal(attr));
+    int32_t indexAidl;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->getMinVolumeIndexForAttributes(attrAidl, &indexAidl)));
+    index = VALUE_OR_RETURN_STATUS(convertIntegral<int>(indexAidl));
+    return OK;
 }
 
-uint32_t AudioSystem::getStrategyForStream(audio_stream_type_t stream)
-{
+product_strategy_t AudioSystem::getStrategyForStream(audio_stream_type_t stream) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PRODUCT_STRATEGY_NONE;
-    return aps->getStrategyForStream(stream);
+
+    auto result = [&]() -> ConversionResult<product_strategy_t> {
+        media::AudioStreamType streamAidl = VALUE_OR_RETURN(
+                legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+        int32_t resultAidl;
+        RETURN_IF_ERROR(statusTFromBinderStatus(
+                aps->getStrategyForStream(streamAidl, &resultAidl)));
+        return aidl2legacy_int32_t_product_strategy_t(resultAidl);
+    }();
+    return result.value_or(PRODUCT_STRATEGY_NONE);
 }
 
-audio_devices_t AudioSystem::getDevicesForStream(audio_stream_type_t stream)
-{
+audio_devices_t AudioSystem::getDevicesForStream(audio_stream_type_t stream) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return AUDIO_DEVICE_NONE;
-    return aps->getDevicesForStream(stream);
+
+    auto result = [&]() -> ConversionResult<audio_devices_t> {
+        media::AudioStreamType streamAidl = VALUE_OR_RETURN(
+                legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+        int32_t resultAidl;
+        RETURN_IF_ERROR(statusTFromBinderStatus(
+                aps->getDevicesForStream(streamAidl, &resultAidl)));
+        return aidl2legacy_int32_t_audio_devices_t(resultAidl);
+    }();
+    return result.value_or(AUDIO_DEVICE_NONE);
 }
 
-status_t AudioSystem::getDevicesForAttributes(const AudioAttributes &aa,
-                                              AudioDeviceTypeAddrVector *devices) {
+status_t AudioSystem::getDevicesForAttributes(const AudioAttributes& aa,
+                                              AudioDeviceTypeAddrVector* devices) {
     if (devices == nullptr) {
         return BAD_VALUE;
     }
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->getDevicesForAttributes(aa, devices);
+
+    media::AudioAttributesEx aaAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_AudioAttributes_AudioAttributesEx(aa));
+    std::vector<media::AudioDevice> retAidl;
+    RETURN_STATUS_IF_ERROR(
+            statusTFromBinderStatus(aps->getDevicesForAttributes(aaAidl, &retAidl)));
+    *devices = VALUE_OR_RETURN_STATUS(
+            convertContainer<AudioDeviceTypeAddrVector>(
+                    retAidl,
+                    aidl2legacy_AudioDeviceTypeAddress));
+    return OK;
 }
 
-audio_io_handle_t AudioSystem::getOutputForEffect(const effect_descriptor_t *desc)
-{
+audio_io_handle_t AudioSystem::getOutputForEffect(const effect_descriptor_t* desc) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     // FIXME change return type to status_t, and return PERMISSION_DENIED here
     if (aps == 0) return AUDIO_IO_HANDLE_NONE;
-    return aps->getOutputForEffect(desc);
+
+    auto result = [&]() -> ConversionResult<audio_io_handle_t> {
+        media::EffectDescriptor descAidl = VALUE_OR_RETURN(
+                legacy2aidl_effect_descriptor_t_EffectDescriptor(*desc));
+        int32_t retAidl;
+        RETURN_IF_ERROR(
+                statusTFromBinderStatus(aps->getOutputForEffect(descAidl, &retAidl)));
+        return aidl2legacy_int32_t_audio_io_handle_t(retAidl);
+    }();
+
+    return result.value_or(AUDIO_IO_HANDLE_NONE);
 }
 
-status_t AudioSystem::registerEffect(const effect_descriptor_t *desc,
-                                audio_io_handle_t io,
-                                uint32_t strategy,
-                                audio_session_t session,
-                                int id)
-{
+status_t AudioSystem::registerEffect(const effect_descriptor_t* desc,
+                                     audio_io_handle_t io,
+                                     product_strategy_t strategy,
+                                     audio_session_t session,
+                                     int id) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->registerEffect(desc, io, strategy, session, id);
+
+    media::EffectDescriptor descAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_effect_descriptor_t_EffectDescriptor(*desc));
+    int32_t ioAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(io));
+    int32_t strategyAidl = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_product_strategy_t(strategy));
+    int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
+    int32_t idAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(id));
+    return statusTFromBinderStatus(
+            aps->registerEffect(descAidl, ioAidl, strategyAidl, sessionAidl, idAidl));
 }
 
-status_t AudioSystem::unregisterEffect(int id)
-{
+status_t AudioSystem::unregisterEffect(int id) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->unregisterEffect(id);
+
+    int32_t idAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(id));
+    return statusTFromBinderStatus(
+            aps->unregisterEffect(idAidl));
 }
 
-status_t AudioSystem::setEffectEnabled(int id, bool enabled)
-{
+status_t AudioSystem::setEffectEnabled(int id, bool enabled) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->setEffectEnabled(id, enabled);
+
+    int32_t idAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(id));
+    return statusTFromBinderStatus(
+            aps->setEffectEnabled(idAidl, enabled));
 }
 
-status_t AudioSystem::moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io)
-{
+status_t AudioSystem::moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->moveEffectsToIo(ids, io);
+
+    std::vector<int32_t> idsAidl = VALUE_OR_RETURN_STATUS(
+            convertContainer<std::vector<int32_t>>(ids, convertReinterpret<int32_t, int>));
+    int32_t ioAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(io));
+    return statusTFromBinderStatus(aps->moveEffectsToIo(idsAidl, ioAidl));
 }
 
-status_t AudioSystem::isStreamActive(audio_stream_type_t stream, bool* state, uint32_t inPastMs)
-{
+status_t AudioSystem::isStreamActive(audio_stream_type_t stream, bool* state, uint32_t inPastMs) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
     if (state == NULL) return BAD_VALUE;
-    *state = aps->isStreamActive(stream, inPastMs);
-    return NO_ERROR;
+
+    media::AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+    int32_t inPastMsAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(inPastMs));
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->isStreamActive(streamAidl, inPastMsAidl, state)));
+    return OK;
 }
 
 status_t AudioSystem::isStreamActiveRemotely(audio_stream_type_t stream, bool* state,
-        uint32_t inPastMs)
-{
+                                             uint32_t inPastMs) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
     if (state == NULL) return BAD_VALUE;
-    *state = aps->isStreamActiveRemotely(stream, inPastMs);
-    return NO_ERROR;
+
+    media::AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+    int32_t inPastMsAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(inPastMs));
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->isStreamActiveRemotely(streamAidl, inPastMsAidl, state)));
+    return OK;
 }
 
-status_t AudioSystem::isSourceActive(audio_source_t stream, bool* state)
-{
+status_t AudioSystem::isSourceActive(audio_source_t stream, bool* state) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
     if (state == NULL) return BAD_VALUE;
-    *state = aps->isSourceActive(stream);
-    return NO_ERROR;
+
+    media::AudioSourceType streamAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_source_t_AudioSourceType(stream));
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->isSourceActive(streamAidl, state)));
+    return OK;
 }
 
-uint32_t AudioSystem::getPrimaryOutputSamplingRate()
-{
+uint32_t AudioSystem::getPrimaryOutputSamplingRate() {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return 0;
     return af->getPrimaryOutputSamplingRate();
 }
 
-size_t AudioSystem::getPrimaryOutputFrameCount()
-{
+size_t AudioSystem::getPrimaryOutputFrameCount() {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return 0;
     return af->getPrimaryOutputFrameCount();
 }
 
-status_t AudioSystem::setLowRamDevice(bool isLowRamDevice, int64_t totalMemory)
-{
+status_t AudioSystem::setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     return af->setLowRamDevice(isLowRamDevice, totalMemory);
 }
 
-void AudioSystem::clearAudioConfigCache()
-{
+void AudioSystem::clearAudioConfigCache() {
     // called by restoreTrack_l(), which needs new IAudioFlinger and IAudioPolicyService instances
     ALOGV("clearAudioConfigCache()");
     {
@@ -1186,74 +1414,152 @@
 status_t AudioSystem::setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == nullptr) return PERMISSION_DENIED;
-    return aps->setSupportedSystemUsages(systemUsages);
+
+    std::vector<media::AudioUsage> systemUsagesAidl = VALUE_OR_RETURN_STATUS(
+            convertContainer<std::vector<media::AudioUsage>>(systemUsages,
+                                                             legacy2aidl_audio_usage_t_AudioUsage));
+    return statusTFromBinderStatus(aps->setSupportedSystemUsages(systemUsagesAidl));
 }
 
-status_t AudioSystem::setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t flags) {
+status_t AudioSystem::setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == nullptr) return PERMISSION_DENIED;
-    return aps->setAllowedCapturePolicy(uid, flags);
+
+    int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
+    int32_t capturePolicyAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_flags_mask_t_int32_t_mask(capturePolicy));
+    return statusTFromBinderStatus(aps->setAllowedCapturePolicy(uidAidl, capturePolicyAidl));
 }
 
-audio_offload_mode_t AudioSystem::getOffloadSupport(const audio_offload_info_t& info)
-{
+audio_offload_mode_t AudioSystem::getOffloadSupport(const audio_offload_info_t& info) {
     ALOGV("%s", __func__);
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return AUDIO_OFFLOAD_NOT_SUPPORTED;
-    return aps->getOffloadSupport(info);
+
+    auto result = [&]() -> ConversionResult<audio_offload_mode_t> {
+        media::AudioOffloadInfo infoAidl = VALUE_OR_RETURN(
+                legacy2aidl_audio_offload_info_t_AudioOffloadInfo(info));
+        media::AudioOffloadMode retAidl;
+        RETURN_IF_ERROR(
+                statusTFromBinderStatus(aps->getOffloadSupport(infoAidl, &retAidl)));
+        return aidl2legacy_AudioOffloadMode_audio_offload_mode_t(retAidl);
+    }();
+
+    return result.value_or(static_cast<audio_offload_mode_t>(0));
 }
 
 status_t AudioSystem::listAudioPorts(audio_port_role_t role,
                                      audio_port_type_t type,
-                                     unsigned int *num_ports,
-                                     struct audio_port_v7 *ports,
-                                     unsigned int *generation)
-{
+                                     unsigned int* num_ports,
+                                     struct audio_port_v7* ports,
+                                     unsigned int* generation) {
+    if (num_ports == nullptr || (*num_ports != 0 && ports == nullptr) ||
+        generation == nullptr) {
+        return BAD_VALUE;
+    }
+
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->listAudioPorts(role, type, num_ports, ports, generation);
+
+    media::AudioPortRole roleAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_port_role_t_AudioPortRole(role));
+    media::AudioPortType typeAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_port_type_t_AudioPortType(type));
+    media::Int numPortsAidl;
+    numPortsAidl.value = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*num_ports));
+    std::vector<media::AudioPort> portsAidl;
+    int32_t generationAidl;
+
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->listAudioPorts(roleAidl, typeAidl, &numPortsAidl, &portsAidl, &generationAidl)));
+    *num_ports = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(numPortsAidl.value));
+    *generation = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(generationAidl));
+    RETURN_STATUS_IF_ERROR(convertRange(portsAidl.begin(), portsAidl.end(), ports,
+                                        aidl2legacy_AudioPort_audio_port_v7));
+    return OK;
 }
 
-status_t AudioSystem::getAudioPort(struct audio_port_v7 *port)
-{
+status_t AudioSystem::getAudioPort(struct audio_port_v7* port) {
+    if (port == nullptr) {
+        return BAD_VALUE;
+    }
+
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->getAudioPort(port);
+
+    media::AudioPort portAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_v7_AudioPort(*port));
+    RETURN_STATUS_IF_ERROR(
+            statusTFromBinderStatus(aps->getAudioPort(portAidl, &portAidl)));
+    *port = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioPort_audio_port_v7(portAidl));
+    return OK;
 }
 
-status_t AudioSystem::createAudioPatch(const struct audio_patch *patch,
-                                   audio_patch_handle_t *handle)
-{
+status_t AudioSystem::createAudioPatch(const struct audio_patch* patch,
+                                       audio_patch_handle_t* handle) {
+    if (patch == nullptr || handle == nullptr) {
+        return BAD_VALUE;
+    }
+
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->createAudioPatch(patch, handle);
+
+    media::AudioPatch patchAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_patch_AudioPatch(*patch));
+    int32_t handleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(*handle));
+    RETURN_STATUS_IF_ERROR(
+            statusTFromBinderStatus(aps->createAudioPatch(patchAidl, handleAidl, &handleAidl)));
+    *handle = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_patch_handle_t(handleAidl));
+    return OK;
 }
 
-status_t AudioSystem::releaseAudioPatch(audio_patch_handle_t handle)
-{
+status_t AudioSystem::releaseAudioPatch(audio_patch_handle_t handle) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->releaseAudioPatch(handle);
+
+    int32_t handleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(handle));
+    return statusTFromBinderStatus(aps->releaseAudioPatch(handleAidl));
 }
 
-status_t AudioSystem::listAudioPatches(unsigned int *num_patches,
-                                  struct audio_patch *patches,
-                                  unsigned int *generation)
-{
+status_t AudioSystem::listAudioPatches(unsigned int* num_patches,
+                                       struct audio_patch* patches,
+                                       unsigned int* generation) {
+    if (num_patches == nullptr || (*num_patches != 0 && patches == nullptr) ||
+        generation == nullptr) {
+        return BAD_VALUE;
+    }
+
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->listAudioPatches(num_patches, patches, generation);
+
+
+    media::Int numPatchesAidl;
+    numPatchesAidl.value = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*num_patches));
+    std::vector<media::AudioPatch> patchesAidl;
+    int32_t generationAidl;
+
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->listAudioPatches(&numPatchesAidl, &patchesAidl, &generationAidl)));
+    *num_patches = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(numPatchesAidl.value));
+    *generation = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(generationAidl));
+    RETURN_STATUS_IF_ERROR(convertRange(patchesAidl.begin(), patchesAidl.end(), patches,
+                                        aidl2legacy_AudioPatch_audio_patch));
+    return OK;
 }
 
-status_t AudioSystem::setAudioPortConfig(const struct audio_port_config *config)
-{
+status_t AudioSystem::setAudioPortConfig(const struct audio_port_config* config) {
+    if (config == nullptr) {
+        return BAD_VALUE;
+    }
+
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->setAudioPortConfig(config);
+
+    media::AudioPortConfig configAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_port_config_AudioPortConfig(*config));
+    return statusTFromBinderStatus(aps->setAudioPortConfig(configAidl));
 }
 
-status_t AudioSystem::addAudioPortCallback(const sp<AudioPortCallback>& callback)
-{
+status_t AudioSystem::addAudioPortCallback(const sp<AudioPortCallback>& callback) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
 
@@ -1269,8 +1575,7 @@
 }
 
 /*static*/
-status_t AudioSystem::removeAudioPortCallback(const sp<AudioPortCallback>& callback)
-{
+status_t AudioSystem::removeAudioPortCallback(const sp<AudioPortCallback>& callback) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
 
@@ -1285,8 +1590,7 @@
     return (ret < 0) ? INVALID_OPERATION : NO_ERROR;
 }
 
-status_t AudioSystem::addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback)
-{
+status_t AudioSystem::addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
 
@@ -1301,8 +1605,7 @@
     return (ret < 0) ? INVALID_OPERATION : NO_ERROR;
 }
 
-status_t AudioSystem::removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback)
-{
+status_t AudioSystem::removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
 
@@ -1319,8 +1622,7 @@
 
 status_t AudioSystem::addAudioDeviceCallback(
         const wp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo,
-        audio_port_handle_t portId)
-{
+        audio_port_handle_t portId) {
     const sp<AudioFlingerClient> afc = getAudioFlingerClient();
     if (afc == 0) {
         return NO_INIT;
@@ -1337,8 +1639,7 @@
 
 status_t AudioSystem::removeAudioDeviceCallback(
         const wp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo,
-        audio_port_handle_t portId)
-{
+        audio_port_handle_t portId) {
     const sp<AudioFlingerClient> afc = getAudioFlingerClient();
     if (afc == 0) {
         return NO_INIT;
@@ -1346,8 +1647,7 @@
     return afc->removeAudioDeviceCallback(callback, audioIo, portId);
 }
 
-audio_port_handle_t AudioSystem::getDeviceIdForIo(audio_io_handle_t audioIo)
-{
+audio_port_handle_t AudioSystem::getDeviceIdForIo(audio_io_handle_t audioIo) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     const sp<AudioIoDescriptor> desc = getIoDescriptor(audioIo);
@@ -1357,224 +1657,321 @@
     return desc->getDeviceId();
 }
 
-status_t AudioSystem::acquireSoundTriggerSession(audio_session_t *session,
-                                       audio_io_handle_t *ioHandle,
-                                       audio_devices_t *device)
-{
+status_t AudioSystem::acquireSoundTriggerSession(audio_session_t* session,
+                                                 audio_io_handle_t* ioHandle,
+                                                 audio_devices_t* device) {
+    if (session == nullptr || ioHandle == nullptr || device == nullptr) {
+        return BAD_VALUE;
+    }
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->acquireSoundTriggerSession(session, ioHandle, device);
+
+    media::SoundTriggerSession retAidl;
+    RETURN_STATUS_IF_ERROR(
+            statusTFromBinderStatus(aps->acquireSoundTriggerSession(&retAidl)));
+    *session = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_session_t(retAidl.session));
+    *ioHandle = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_io_handle_t(retAidl.ioHandle));
+    *device = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_devices_t(retAidl.device));
+    return OK;
 }
 
-status_t AudioSystem::releaseSoundTriggerSession(audio_session_t session)
-{
+status_t AudioSystem::releaseSoundTriggerSession(audio_session_t session) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->releaseSoundTriggerSession(session);
+
+    int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
+    return statusTFromBinderStatus(aps->releaseSoundTriggerSession(sessionAidl));
 }
 
-audio_mode_t AudioSystem::getPhoneState()
-{
+audio_mode_t AudioSystem::getPhoneState() {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return AUDIO_MODE_INVALID;
-    return aps->getPhoneState();
+
+    auto result = [&]() -> ConversionResult<audio_mode_t> {
+        media::AudioMode retAidl;
+        RETURN_IF_ERROR(statusTFromBinderStatus(aps->getPhoneState(&retAidl)));
+        return aidl2legacy_AudioMode_audio_mode_t(retAidl);
+    }();
+
+    return result.value_or(AUDIO_MODE_INVALID);
 }
 
-status_t AudioSystem::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
-{
+status_t AudioSystem::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->registerPolicyMixes(mixes, registration);
+
+    size_t mixesSize = std::min(mixes.size(), size_t{MAX_MIXES_PER_POLICY});
+    std::vector<media::AudioMix> mixesAidl;
+    RETURN_STATUS_IF_ERROR(
+            convertRange(mixes.begin(), mixes.begin() + mixesSize, std::back_inserter(mixesAidl),
+                         legacy2aidl_AudioMix));
+    return statusTFromBinderStatus(aps->registerPolicyMixes(mixesAidl, registration));
 }
 
-status_t AudioSystem::setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices)
-{
+status_t AudioSystem::setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->setUidDeviceAffinities(uid, devices);
+
+    int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
+    std::vector<media::AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
+            convertContainer<std::vector<media::AudioDevice>>(devices,
+                                                              legacy2aidl_AudioDeviceTypeAddress));
+    return statusTFromBinderStatus(aps->setUidDeviceAffinities(uidAidl, devicesAidl));
 }
 
 status_t AudioSystem::removeUidDeviceAffinities(uid_t uid) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->removeUidDeviceAffinities(uid);
+
+    int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
+    return statusTFromBinderStatus(aps->removeUidDeviceAffinities(uidAidl));
 }
 
 status_t AudioSystem::setUserIdDeviceAffinities(int userId,
-                                                const AudioDeviceTypeAddrVector& devices)
-{
+                                                const AudioDeviceTypeAddrVector& devices) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->setUserIdDeviceAffinities(userId, devices);
+
+    int32_t userIdAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(userId));
+    std::vector<media::AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
+            convertContainer<std::vector<media::AudioDevice>>(devices,
+                                                              legacy2aidl_AudioDeviceTypeAddress));
+    return statusTFromBinderStatus(
+            aps->setUserIdDeviceAffinities(userIdAidl, devicesAidl));
 }
 
-status_t AudioSystem::removeUserIdDeviceAffinities(int userId)
-{
+status_t AudioSystem::removeUserIdDeviceAffinities(int userId) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->removeUserIdDeviceAffinities(userId);
+    int32_t userIdAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(userId));
+    return statusTFromBinderStatus(aps->removeUserIdDeviceAffinities(userIdAidl));
 }
 
-status_t AudioSystem::startAudioSource(const struct audio_port_config *source,
-                                       const audio_attributes_t *attributes,
-                                       audio_port_handle_t *portId)
-{
+status_t AudioSystem::startAudioSource(const struct audio_port_config* source,
+                                       const audio_attributes_t* attributes,
+                                       audio_port_handle_t* portId) {
+    if (source == nullptr || attributes == nullptr || portId == nullptr) {
+        return BAD_VALUE;
+    }
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->startAudioSource(source, attributes, portId);
+
+    media::AudioPortConfig sourceAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_port_config_AudioPortConfig(*source));
+    media::AudioAttributesInternal attributesAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_attributes_t_AudioAttributesInternal(*attributes));
+    int32_t portIdAidl;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->startAudioSource(sourceAidl, attributesAidl, &portIdAidl)));
+    *portId = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
+    return OK;
 }
 
-status_t AudioSystem::stopAudioSource(audio_port_handle_t portId)
-{
+status_t AudioSystem::stopAudioSource(audio_port_handle_t portId) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->stopAudioSource(portId);
+
+    int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
+    return statusTFromBinderStatus(aps->stopAudioSource(portIdAidl));
 }
 
-status_t AudioSystem::setMasterMono(bool mono)
-{
+status_t AudioSystem::setMasterMono(bool mono) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->setMasterMono(mono);
+    return statusTFromBinderStatus(aps->setMasterMono(mono));
 }
 
-status_t AudioSystem::getMasterMono(bool *mono)
-{
+status_t AudioSystem::getMasterMono(bool* mono) {
+    if (mono == nullptr) {
+        return BAD_VALUE;
+    }
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->getMasterMono(mono);
+    return statusTFromBinderStatus(aps->getMasterMono(mono));
 }
 
-status_t AudioSystem::setMasterBalance(float balance)
-{
+status_t AudioSystem::setMasterBalance(float balance) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     return af->setMasterBalance(balance);
 }
 
-status_t AudioSystem::getMasterBalance(float *balance)
-{
+status_t AudioSystem::getMasterBalance(float* balance) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     return af->getMasterBalance(balance);
 }
 
-float AudioSystem::getStreamVolumeDB(audio_stream_type_t stream, int index, audio_devices_t device)
-{
+float
+AudioSystem::getStreamVolumeDB(audio_stream_type_t stream, int index, audio_devices_t device) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return NAN;
-    return aps->getStreamVolumeDB(stream, index, device);
+
+    auto result = [&]() -> ConversionResult<float> {
+        media::AudioStreamType streamAidl = VALUE_OR_RETURN(
+                legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+        int32_t indexAidl = VALUE_OR_RETURN(convertIntegral<int32_t>(index));
+        int32_t deviceAidl = VALUE_OR_RETURN(legacy2aidl_audio_devices_t_int32_t(device));
+        float retAidl;
+        RETURN_IF_ERROR(statusTFromBinderStatus(
+                aps->getStreamVolumeDB(streamAidl, indexAidl, deviceAidl, &retAidl)));
+        return retAidl;
+    }();
+    return result.value_or(NAN);
 }
 
-status_t AudioSystem::getMicrophones(std::vector<media::MicrophoneInfo> *microphones)
-{
+status_t AudioSystem::getMicrophones(std::vector<media::MicrophoneInfo>* microphones) {
     const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
     if (af == 0) return PERMISSION_DENIED;
     return af->getMicrophones(microphones);
 }
 
 status_t AudioSystem::setAudioHalPids(const std::vector<pid_t>& pids) {
-  const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
-  if (af == nullptr) return PERMISSION_DENIED;
-  return af->setAudioHalPids(pids);
+    const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
+    if (af == nullptr) return PERMISSION_DENIED;
+    return af->setAudioHalPids(pids);
 }
 
-status_t AudioSystem::getSurroundFormats(unsigned int *numSurroundFormats,
-                                         audio_format_t *surroundFormats,
-                                         bool *surroundFormatsEnabled,
-                                         bool reported)
-{
+status_t AudioSystem::getSurroundFormats(unsigned int* numSurroundFormats,
+                                         audio_format_t* surroundFormats,
+                                         bool* surroundFormatsEnabled,
+                                         bool reported) {
+    if (numSurroundFormats == nullptr || (*numSurroundFormats != 0 &&
+                                          (surroundFormats == nullptr ||
+                                           surroundFormatsEnabled == nullptr))) {
+        return BAD_VALUE;
+    }
+
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->getSurroundFormats(
-            numSurroundFormats, surroundFormats, surroundFormatsEnabled, reported);
+
+    media::Int numSurroundFormatsAidl;
+    numSurroundFormatsAidl.value =
+            VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*numSurroundFormats));
+    std::vector<media::audio::common::AudioFormat> surroundFormatsAidl;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->getSurroundFormats(reported, &numSurroundFormatsAidl, &surroundFormatsAidl,
+                                    surroundFormatsEnabled)));
+    *numSurroundFormats = VALUE_OR_RETURN_STATUS(
+            convertIntegral<unsigned int>(numSurroundFormatsAidl.value));
+    RETURN_STATUS_IF_ERROR(
+            convertRange(surroundFormatsAidl.begin(), surroundFormatsAidl.end(), surroundFormats,
+                         aidl2legacy_AudioFormat_audio_format_t));
+    return OK;
 }
 
-status_t AudioSystem::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
-{
+status_t AudioSystem::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->setSurroundFormatEnabled(audioFormat, enabled);
+
+    media::audio::common::AudioFormat audioFormatAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_format_t_AudioFormat(audioFormat));
+    return statusTFromBinderStatus(
+            aps->setSurroundFormatEnabled(audioFormatAidl, enabled));
 }
 
-status_t AudioSystem::setAssistantUid(uid_t uid)
-{
-    const sp <IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+status_t AudioSystem::setAssistantUid(uid_t uid) {
+    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
 
-    return aps->setAssistantUid(uid);
+    int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
+    return statusTFromBinderStatus(aps->setAssistantUid(uidAidl));
 }
 
-status_t AudioSystem::setA11yServicesUids(const std::vector<uid_t>& uids)
-{
-    const sp <IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+status_t AudioSystem::setA11yServicesUids(const std::vector<uid_t>& uids) {
+    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
 
-    return aps->setA11yServicesUids(uids);
+    std::vector<int32_t> uidsAidl = VALUE_OR_RETURN_STATUS(
+            convertContainer<std::vector<int32_t>>(uids, legacy2aidl_uid_t_int32_t));
+    return statusTFromBinderStatus(aps->setA11yServicesUids(uidsAidl));
 }
 
-status_t AudioSystem::setCurrentImeUid(uid_t uid)
-{
-    const sp <IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+status_t AudioSystem::setCurrentImeUid(uid_t uid) {
+    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
 
-    return aps->setCurrentImeUid(uid);
+    int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
+    return statusTFromBinderStatus(aps->setCurrentImeUid(uidAidl));
 }
 
-bool AudioSystem::isHapticPlaybackSupported()
-{
+bool AudioSystem::isHapticPlaybackSupported() {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return false;
-    return aps->isHapticPlaybackSupported();
+
+    auto result = [&]() -> ConversionResult<bool> {
+        bool retVal;
+        RETURN_IF_ERROR(
+                statusTFromBinderStatus(aps->isHapticPlaybackSupported(&retVal)));
+        return retVal;
+    }();
+    return result.value_or(false);
 }
 
 status_t AudioSystem::getHwOffloadEncodingFormatsSupportedForA2DP(
-                                std::vector<audio_format_t> *formats) {
-    const sp <IAudioPolicyService>
-        & aps = AudioSystem::get_audio_policy_service();
+        std::vector<audio_format_t>* formats) {
+    if (formats == nullptr) {
+        return BAD_VALUE;
+    }
+
+    const sp<IAudioPolicyService>
+            & aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->getHwOffloadEncodingFormatsSupportedForA2DP(formats);
+
+    std::vector<media::audio::common::AudioFormat> formatsAidl;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->getHwOffloadEncodingFormatsSupportedForA2DP(&formatsAidl)));
+    *formats = VALUE_OR_RETURN_STATUS(
+            convertContainer<std::vector<audio_format_t>>(formatsAidl,
+                                                          aidl2legacy_AudioFormat_audio_format_t));
+    return OK;
 }
 
-status_t AudioSystem::listAudioProductStrategies(AudioProductStrategyVector &strategies)
-{
+status_t AudioSystem::listAudioProductStrategies(AudioProductStrategyVector& strategies) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->listAudioProductStrategies(strategies);
+
+    std::vector<media::AudioProductStrategy> strategiesAidl;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->listAudioProductStrategies(&strategiesAidl)));
+    strategies = VALUE_OR_RETURN_STATUS(
+            convertContainer<AudioProductStrategyVector>(strategiesAidl,
+                                                         aidl2legacy_AudioProductStrategy));
+    return OK;
 }
 
-audio_attributes_t AudioSystem::streamTypeToAttributes(audio_stream_type_t stream)
-{
+audio_attributes_t AudioSystem::streamTypeToAttributes(audio_stream_type_t stream) {
     AudioProductStrategyVector strategies;
     listAudioProductStrategies(strategies);
-    for (const auto &strategy : strategies) {
+    for (const auto& strategy : strategies) {
         auto attrVect = strategy.getAudioAttributes();
-        auto iter = std::find_if(begin(attrVect), end(attrVect), [&stream](const auto &attributes) {
-                         return attributes.getStreamType() == stream; });
+        auto iter = std::find_if(begin(attrVect), end(attrVect), [&stream](const auto& attributes) {
+            return attributes.getStreamType() == stream;
+        });
         if (iter != end(attrVect)) {
             return iter->getAttributes();
         }
     }
-    ALOGE("invalid stream type %s when converting to attributes",  toString(stream).c_str());
+    ALOGE("invalid stream type %s when converting to attributes", toString(stream).c_str());
     return AUDIO_ATTRIBUTES_INITIALIZER;
 }
 
-audio_stream_type_t AudioSystem::attributesToStreamType(const audio_attributes_t &attr)
-{
+audio_stream_type_t AudioSystem::attributesToStreamType(const audio_attributes_t& attr) {
     product_strategy_t psId;
     status_t ret = AudioSystem::getProductStrategyFromAudioAttributes(AudioAttributes(attr), psId);
     if (ret != NO_ERROR) {
-        ALOGE("no strategy found for attributes %s",  toString(attr).c_str());
+        ALOGE("no strategy found for attributes %s", toString(attr).c_str());
         return AUDIO_STREAM_MUSIC;
     }
     AudioProductStrategyVector strategies;
     listAudioProductStrategies(strategies);
-    for (const auto &strategy : strategies) {
+    for (const auto& strategy : strategies) {
         if (strategy.getId() == psId) {
             auto attrVect = strategy.getAudioAttributes();
-            auto iter = std::find_if(begin(attrVect), end(attrVect), [&attr](const auto &refAttr) {
-                             return AudioProductStrategy::attributesMatches(
-                                 refAttr.getAttributes(), attr); });
+            auto iter = std::find_if(begin(attrVect), end(attrVect), [&attr](const auto& refAttr) {
+                return AudioProductStrategy::attributesMatches(
+                        refAttr.getAttributes(), attr);
+            });
             if (iter != end(attrVect)) {
                 return iter->getStreamType();
             }
@@ -1585,131 +1982,201 @@
             // virtual source is not expected to have an associated product strategy
             break;
         default:
-            ALOGE("invalid attributes %s when converting to stream",  toString(attr).c_str());
+            ALOGE("invalid attributes %s when converting to stream", toString(attr).c_str());
             break;
     }
     return AUDIO_STREAM_MUSIC;
 }
 
-status_t AudioSystem::getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
-                                                            product_strategy_t &productStrategy)
-{
+status_t AudioSystem::getProductStrategyFromAudioAttributes(const AudioAttributes& aa,
+                                                            product_strategy_t& productStrategy) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->getProductStrategyFromAudioAttributes(aa,productStrategy);
+
+    media::AudioAttributesEx aaAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_AudioAttributes_AudioAttributesEx(aa));
+    int32_t productStrategyAidl;
+
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->getProductStrategyFromAudioAttributes(aaAidl, &productStrategyAidl)));
+    productStrategy = VALUE_OR_RETURN_STATUS(
+            aidl2legacy_int32_t_product_strategy_t(productStrategyAidl));
+    return OK;
 }
 
-status_t AudioSystem::listAudioVolumeGroups(AudioVolumeGroupVector &groups)
-{
+status_t AudioSystem::listAudioVolumeGroups(AudioVolumeGroupVector& groups) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->listAudioVolumeGroups(groups);
+
+    std::vector<media::AudioVolumeGroup> groupsAidl;
+    RETURN_STATUS_IF_ERROR(
+            statusTFromBinderStatus(aps->listAudioVolumeGroups(&groupsAidl)));
+    groups = VALUE_OR_RETURN_STATUS(
+            convertContainer<AudioVolumeGroupVector>(groupsAidl, aidl2legacy_AudioVolumeGroup));
+    return OK;
 }
 
-status_t AudioSystem::getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
-                                                        volume_group_t &volumeGroup)
-{
+status_t AudioSystem::getVolumeGroupFromAudioAttributes(const AudioAttributes& aa,
+                                                        volume_group_t& volumeGroup) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->getVolumeGroupFromAudioAttributes(aa, volumeGroup);
+
+    media::AudioAttributesEx aaAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_AudioAttributes_AudioAttributesEx(aa));
+    int32_t volumeGroupAidl;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->getVolumeGroupFromAudioAttributes(aaAidl, &volumeGroupAidl)));
+    volumeGroup = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_volume_group_t(volumeGroupAidl));
+    return OK;
 }
 
-status_t AudioSystem::setRttEnabled(bool enabled)
-{
+status_t AudioSystem::setRttEnabled(bool enabled) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return PERMISSION_DENIED;
-    return aps->setRttEnabled(enabled);
+    return statusTFromBinderStatus(aps->setRttEnabled(enabled));
 }
 
-bool AudioSystem::isCallScreenModeSupported()
-{
+bool AudioSystem::isCallScreenModeSupported() {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return false;
-    return aps->isCallScreenModeSupported();
+
+    auto result = [&]() -> ConversionResult<bool> {
+        bool retAidl;
+        RETURN_IF_ERROR(
+                statusTFromBinderStatus(aps->isCallScreenModeSupported(&retAidl)));
+        return retAidl;
+    }();
+    return result.value_or(false);
 }
 
 status_t AudioSystem::setDevicesRoleForStrategy(product_strategy_t strategy,
                                                 device_role_t role,
-                                                const AudioDeviceTypeAddrVector &devices)
-{
+                                                const AudioDeviceTypeAddrVector& devices) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) {
         return PERMISSION_DENIED;
     }
-    return aps->setDevicesRoleForStrategy(strategy, role, devices);
+
+    int32_t strategyAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_product_strategy_t_int32_t(strategy));
+    media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+    std::vector<media::AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
+            convertContainer<std::vector<media::AudioDevice>>(devices,
+                                                              legacy2aidl_AudioDeviceTypeAddress));
+    return statusTFromBinderStatus(
+            aps->setDevicesRoleForStrategy(strategyAidl, roleAidl, devicesAidl));
 }
 
-status_t AudioSystem::removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role)
-{
+status_t
+AudioSystem::removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) {
         return PERMISSION_DENIED;
     }
-    return aps->removeDevicesRoleForStrategy(strategy, role);
+    int32_t strategyAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_product_strategy_t_int32_t(strategy));
+    media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+    return statusTFromBinderStatus(
+            aps->removeDevicesRoleForStrategy(strategyAidl, roleAidl));
 }
 
 status_t AudioSystem::getDevicesForRoleAndStrategy(product_strategy_t strategy,
                                                    device_role_t role,
-                                                   AudioDeviceTypeAddrVector &devices)
-{
+                                                   AudioDeviceTypeAddrVector& devices) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) {
         return PERMISSION_DENIED;
     }
-    return aps->getDevicesForRoleAndStrategy(strategy, role, devices);
+    int32_t strategyAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_product_strategy_t_int32_t(strategy));
+    media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+    std::vector<media::AudioDevice> devicesAidl;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->getDevicesForRoleAndStrategy(strategyAidl, roleAidl, &devicesAidl)));
+    devices = VALUE_OR_RETURN_STATUS(
+            convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+                                                        aidl2legacy_AudioDeviceTypeAddress));
+    return OK;
 }
 
 status_t AudioSystem::setDevicesRoleForCapturePreset(audio_source_t audioSource,
                                                      device_role_t role,
-                                                     const AudioDeviceTypeAddrVector &devices)
-{
+                                                     const AudioDeviceTypeAddrVector& devices) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) {
         return PERMISSION_DENIED;
     }
-    return aps->setDevicesRoleForCapturePreset(audioSource, role, devices);
+
+    media::AudioSourceType audioSourceAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_source_t_AudioSourceType(audioSource));
+    media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+    std::vector<media::AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
+            convertContainer<std::vector<media::AudioDevice>>(devices,
+                                                              legacy2aidl_AudioDeviceTypeAddress));
+    return statusTFromBinderStatus(
+            aps->setDevicesRoleForCapturePreset(audioSourceAidl, roleAidl, devicesAidl));
 }
 
 status_t AudioSystem::addDevicesRoleForCapturePreset(audio_source_t audioSource,
                                                      device_role_t role,
-                                                     const AudioDeviceTypeAddrVector &devices)
-{
+                                                     const AudioDeviceTypeAddrVector& devices) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) {
         return PERMISSION_DENIED;
     }
-    return aps->addDevicesRoleForCapturePreset(audioSource, role, devices);
+    media::AudioSourceType audioSourceAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_source_t_AudioSourceType(audioSource));
+    media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+    std::vector<media::AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
+            convertContainer<std::vector<media::AudioDevice>>(devices,
+                                                              legacy2aidl_AudioDeviceTypeAddress));
+    return statusTFromBinderStatus(
+            aps->addDevicesRoleForCapturePreset(audioSourceAidl, roleAidl, devicesAidl));
 }
 
 status_t AudioSystem::removeDevicesRoleForCapturePreset(
-        audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector& devices)
-{
+        audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector& devices) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) {
         return PERMISSION_DENIED;
     }
-    return aps->removeDevicesRoleForCapturePreset(audioSource, role, devices);
+    media::AudioSourceType audioSourceAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_source_t_AudioSourceType(audioSource));
+    media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+    std::vector<media::AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
+            convertContainer<std::vector<media::AudioDevice>>(devices,
+                                                              legacy2aidl_AudioDeviceTypeAddress));
+    return statusTFromBinderStatus(
+            aps->removeDevicesRoleForCapturePreset(audioSourceAidl, roleAidl, devicesAidl));
 }
 
 status_t AudioSystem::clearDevicesRoleForCapturePreset(audio_source_t audioSource,
-                                                       device_role_t role)
-{
+                                                       device_role_t role) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) {
         return PERMISSION_DENIED;
     }
-    return aps->clearDevicesRoleForCapturePreset(audioSource, role);
+    media::AudioSourceType audioSourceAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_source_t_AudioSourceType(audioSource));
+    media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+    return statusTFromBinderStatus(
+            aps->clearDevicesRoleForCapturePreset(audioSourceAidl, roleAidl));
 }
 
 status_t AudioSystem::getDevicesForRoleAndCapturePreset(audio_source_t audioSource,
                                                         device_role_t role,
-                                                        AudioDeviceTypeAddrVector &devices)
-{
+                                                        AudioDeviceTypeAddrVector& devices) {
     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) {
         return PERMISSION_DENIED;
     }
-    return aps->getDevicesForRoleAndCapturePreset(audioSource, role, devices);
+    media::AudioSourceType audioSourceAidl = VALUE_OR_RETURN_STATUS(
+            legacy2aidl_audio_source_t_AudioSourceType(audioSource));
+    media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+    std::vector<media::AudioDevice> devicesAidl;
+    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+            aps->getDevicesForRoleAndCapturePreset(audioSourceAidl, roleAidl, &devicesAidl)));
+    devices = VALUE_OR_RETURN_STATUS(
+            convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+                                                        aidl2legacy_AudioDeviceTypeAddress));
+    return OK;
 }
 
 class CaptureStateListenerImpl : public media::BnCaptureStateListener,
@@ -1722,7 +2189,8 @@
 
     void init() {
         bool active;
-        status_t status = mAps->registerSoundTriggerCaptureStateListener(this, &active);
+        status_t status = statusTFromBinderStatus(
+                mAps->registerSoundTriggerCaptureStateListener(this, &active));
         if (status != NO_ERROR) {
             mListener->onServiceDied();
             return;
@@ -1750,7 +2218,7 @@
 };
 
 status_t AudioSystem::registerSoundTriggerCaptureStateListener(
-    const sp<CaptureStateListener>& listener) {
+        const sp<CaptureStateListener>& listener) {
     LOG_ALWAYS_FATAL_IF(listener == nullptr);
 
     const sp<IAudioPolicyService>& aps =
@@ -1769,8 +2237,7 @@
 // ---------------------------------------------------------------------------
 
 int AudioSystem::AudioPolicyServiceClient::addAudioPortCallback(
-        const sp<AudioPortCallback>& callback)
-{
+        const sp<AudioPortCallback>& callback) {
     Mutex::Autolock _l(mLock);
     for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
         if (mAudioPortCallbacks[i] == callback) {
@@ -1782,8 +2249,7 @@
 }
 
 int AudioSystem::AudioPolicyServiceClient::removeAudioPortCallback(
-        const sp<AudioPortCallback>& callback)
-{
+        const sp<AudioPortCallback>& callback) {
     Mutex::Autolock _l(mLock);
     size_t i;
     for (i = 0; i < mAudioPortCallbacks.size(); i++) {
@@ -1799,8 +2265,7 @@
 }
 
 
-Status AudioSystem::AudioPolicyServiceClient::onAudioPortListUpdate()
-{
+Status AudioSystem::AudioPolicyServiceClient::onAudioPortListUpdate() {
     Mutex::Autolock _l(mLock);
     for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
         mAudioPortCallbacks[i]->onAudioPortListUpdate();
@@ -1808,8 +2273,7 @@
     return Status::ok();
 }
 
-Status AudioSystem::AudioPolicyServiceClient::onAudioPatchListUpdate()
-{
+Status AudioSystem::AudioPolicyServiceClient::onAudioPatchListUpdate() {
     Mutex::Autolock _l(mLock);
     for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
         mAudioPortCallbacks[i]->onAudioPatchListUpdate();
@@ -1819,8 +2283,7 @@
 
 // ----------------------------------------------------------------------------
 int AudioSystem::AudioPolicyServiceClient::addAudioVolumeGroupCallback(
-        const sp<AudioVolumeGroupCallback>& callback)
-{
+        const sp<AudioVolumeGroupCallback>& callback) {
     Mutex::Autolock _l(mLock);
     for (size_t i = 0; i < mAudioVolumeGroupCallback.size(); i++) {
         if (mAudioVolumeGroupCallback[i] == callback) {
@@ -1832,8 +2295,7 @@
 }
 
 int AudioSystem::AudioPolicyServiceClient::removeAudioVolumeGroupCallback(
-        const sp<AudioVolumeGroupCallback>& callback)
-{
+        const sp<AudioVolumeGroupCallback>& callback) {
     Mutex::Autolock _l(mLock);
     size_t i;
     for (i = 0; i < mAudioVolumeGroupCallback.size(); i++) {
@@ -1934,8 +2396,7 @@
     return Status::ok();
 }
 
-void AudioSystem::AudioPolicyServiceClient::binderDied(const wp<IBinder>& who __unused)
-{
+void AudioSystem::AudioPolicyServiceClient::binderDied(const wp<IBinder>& who __unused) {
     {
         Mutex::Autolock _l(mLock);
         for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
diff --git a/media/libaudioclient/AudioTrack.cpp b/media/libaudioclient/AudioTrack.cpp
index d4cbbc3..b1eb950 100644
--- a/media/libaudioclient/AudioTrack.cpp
+++ b/media/libaudioclient/AudioTrack.cpp
@@ -22,6 +22,7 @@
 #include <math.h>
 #include <sys/resource.h>
 
+#include <android/media/IAudioPolicyService.h>
 #include <android-base/macros.h>
 #include <audio_utils/clock.h>
 #include <audio_utils/primitives.h>
@@ -31,7 +32,6 @@
 #include <private/media/AudioTrackShared.h>
 #include <processgroup/sched_policy.h>
 #include <media/IAudioFlinger.h>
-#include <media/IAudioPolicyService.h>
 #include <media/AudioParameter.h>
 #include <media/AudioResamplerPublic.h>
 #include <media/AudioSystem.h>
@@ -172,9 +172,20 @@
 bool AudioTrack::isDirectOutputSupported(const audio_config_base_t& config,
                                          const audio_attributes_t& attributes) {
     ALOGV("%s()", __FUNCTION__);
-    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+    const sp<media::IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
     if (aps == 0) return false;
-    return aps->isDirectOutputSupported(config, attributes);
+
+    auto result = [&]() -> ConversionResult<bool> {
+        media::AudioConfigBase configAidl = VALUE_OR_RETURN(
+                legacy2aidl_audio_config_base_t_AudioConfigBase(config));
+        media::AudioAttributesInternal attributesAidl = VALUE_OR_RETURN(
+                legacy2aidl_audio_attributes_t_AudioAttributesInternal(attributes));
+        bool retAidl;
+        RETURN_IF_ERROR(aidl_utils::statusTFromBinderStatus(
+                aps->isDirectOutputSupported(configAidl, attributesAidl, &retAidl)));
+        return retAidl;
+    }();
+    return result.value_or(false);
 }
 
 // ---------------------------------------------------------------------------
diff --git a/media/libaudioclient/AudioVolumeGroup.cpp b/media/libaudioclient/AudioVolumeGroup.cpp
index e79a362..361f7b8 100644
--- a/media/libaudioclient/AudioVolumeGroup.cpp
+++ b/media/libaudioclient/AudioVolumeGroup.cpp
@@ -21,64 +21,57 @@
 #include <utils/Log.h>
 #include <binder/Parcel.h>
 
+#include <media/AidlConversion.h>
 #include <media/AudioVolumeGroup.h>
 #include <media/AudioAttributes.h>
+#include <media/PolicyAidlConversion.h>
+
+#define RETURN_STATUS_IF_ERROR(x) \
+    { auto _tmp = (x); if (_tmp != OK) return _tmp; }
 
 namespace android {
 
 status_t AudioVolumeGroup::readFromParcel(const Parcel *parcel)
 {
-    status_t ret = parcel->readUtf8FromUtf16(&mName);
-    if (ret != NO_ERROR) {
-        return ret;
-    }
-    mGroupId = static_cast<volume_group_t>(parcel->readInt32());
-    size_t size = static_cast<size_t>(parcel->readInt32());
-    for (size_t i = 0; i < size; i++) {
-        AudioAttributes attribute;
-        attribute.readFromParcel(parcel);
-        if (ret != NO_ERROR) {
-            mAudioAttributes.clear();
-            return ret;
-        }
-        mAudioAttributes.push_back(attribute.getAttributes());
-    }
-    size = static_cast<size_t>(parcel->readInt32());
-    for (size_t i = 0; i < size; i++) {
-        audio_stream_type_t stream = static_cast<audio_stream_type_t>(parcel->readInt32());
-        mStreams.push_back(stream);
-    }
-    return NO_ERROR;
+    media::AudioVolumeGroup aidl;
+    RETURN_STATUS_IF_ERROR(aidl.readFromParcel(parcel));
+    *this = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioVolumeGroup(aidl));
+    return OK;
 }
 
 status_t AudioVolumeGroup::writeToParcel(Parcel *parcel) const
 {
-    parcel->writeUtf8AsUtf16(mName);
-    parcel->writeInt32(static_cast<int32_t>(mGroupId));
-    size_t size = mAudioAttributes.size();
-    size_t sizePosition = parcel->dataPosition();
-    parcel->writeInt32(size);
-    size_t finalSize = size;
-    for (const auto &attributes : mAudioAttributes) {
-        size_t position = parcel->dataPosition();
-        AudioAttributes attribute(attributes);
-        status_t ret = attribute.writeToParcel(parcel);
-        if (ret != NO_ERROR) {
-            parcel->setDataPosition(position);
-            finalSize--;
-        }
-    }
-    if (size != finalSize) {
-        size_t position = parcel->dataPosition();
-        parcel->setDataPosition(sizePosition);
-        parcel->writeInt32(finalSize);
-        parcel->setDataPosition(position);
-    }
-    parcel->writeInt32(mStreams.size());
-    for (const auto &stream : mStreams) {
-        parcel->writeInt32(static_cast<int32_t>(stream));
-    }
-    return NO_ERROR;
+    media::AudioVolumeGroup aidl = VALUE_OR_RETURN_STATUS(legacy2aidl_AudioVolumeGroup(*this));
+    return aidl.writeToParcel(parcel);
+}
+
+ConversionResult<media::AudioVolumeGroup>
+legacy2aidl_AudioVolumeGroup(const AudioVolumeGroup& legacy) {
+    media::AudioVolumeGroup aidl;
+    aidl.groupId = VALUE_OR_RETURN(legacy2aidl_volume_group_t_int32_t(legacy.getId()));
+    aidl.name = legacy.getName();
+    aidl.audioAttributes = VALUE_OR_RETURN(
+            convertContainer<std::vector<media::AudioAttributesInternal>>(
+                    legacy.getAudioAttributes(),
+                    legacy2aidl_audio_attributes_t_AudioAttributesInternal));
+    aidl.streams = VALUE_OR_RETURN(
+            convertContainer<std::vector<media::AudioStreamType>>(legacy.getStreamTypes(),
+            legacy2aidl_audio_stream_type_t_AudioStreamType));
+    return aidl;
+}
+
+ConversionResult<AudioVolumeGroup>
+aidl2legacy_AudioVolumeGroup(const media::AudioVolumeGroup& aidl) {
+    return AudioVolumeGroup(
+            aidl.name,
+            VALUE_OR_RETURN(aidl2legacy_int32_t_volume_group_t(aidl.groupId)),
+            VALUE_OR_RETURN(convertContainer<AttributesVector>(
+                    aidl.audioAttributes,
+                    aidl2legacy_AudioAttributesInternal_audio_attributes_t)),
+            VALUE_OR_RETURN(convertContainer<StreamTypeVector>(
+                    aidl.streams,
+                    aidl2legacy_AudioStreamType_audio_stream_type_t))
+    );
 }
 
 } // namespace android
diff --git a/media/libaudioclient/IAudioPolicyService.cpp b/media/libaudioclient/IAudioPolicyService.cpp
deleted file mode 100644
index 0849e61..0000000
--- a/media/libaudioclient/IAudioPolicyService.cpp
+++ /dev/null
@@ -1,2982 +0,0 @@
-/*
-**
-** Copyright 2009, 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 "IAudioPolicyService"
-#include <utils/Log.h>
-
-#include <stdint.h>
-#include <math.h>
-#include <sys/types.h>
-
-#include <android/media/ICaptureStateListener.h>
-#include <binder/IPCThreadState.h>
-#include <binder/Parcel.h>
-#include <media/AudioEffect.h>
-#include <media/AudioValidator.h>
-#include <media/IAudioPolicyService.h>
-#include <mediautils/ServiceUtilities.h>
-#include <mediautils/TimeCheck.h>
-#include <system/audio.h>
-
-namespace android {
-
-using media::ICaptureStateListener;
-
-enum {
-    SET_DEVICE_CONNECTION_STATE = IBinder::FIRST_CALL_TRANSACTION,
-    GET_DEVICE_CONNECTION_STATE,
-    HANDLE_DEVICE_CONFIG_CHANGE,
-    SET_PHONE_STATE,
-    SET_RINGER_MODE,    // reserved, no longer used
-    SET_FORCE_USE,
-    GET_FORCE_USE,
-    GET_OUTPUT,
-    START_OUTPUT,
-    STOP_OUTPUT,
-    RELEASE_OUTPUT,
-    GET_INPUT_FOR_ATTR,
-    START_INPUT,
-    STOP_INPUT,
-    RELEASE_INPUT,
-    INIT_STREAM_VOLUME,
-    SET_STREAM_VOLUME,
-    GET_STREAM_VOLUME,
-    SET_VOLUME_ATTRIBUTES,
-    GET_VOLUME_ATTRIBUTES,
-    GET_MIN_VOLUME_FOR_ATTRIBUTES,
-    GET_MAX_VOLUME_FOR_ATTRIBUTES,
-    GET_STRATEGY_FOR_STREAM,
-    GET_OUTPUT_FOR_EFFECT,
-    REGISTER_EFFECT,
-    UNREGISTER_EFFECT,
-    IS_STREAM_ACTIVE,
-    IS_SOURCE_ACTIVE,
-    GET_DEVICES_FOR_STREAM,
-    QUERY_DEFAULT_PRE_PROCESSING,
-    SET_EFFECT_ENABLED,
-    IS_STREAM_ACTIVE_REMOTELY,
-    GET_OFFLOAD_MODE_SUPPORTED,
-    IS_DIRECT_OUTPUT_SUPPORTED,
-    LIST_AUDIO_PORTS,
-    GET_AUDIO_PORT,
-    CREATE_AUDIO_PATCH,
-    RELEASE_AUDIO_PATCH,
-    LIST_AUDIO_PATCHES,
-    SET_AUDIO_PORT_CONFIG,
-    REGISTER_CLIENT,
-    GET_OUTPUT_FOR_ATTR,
-    ACQUIRE_SOUNDTRIGGER_SESSION,
-    RELEASE_SOUNDTRIGGER_SESSION,
-    GET_PHONE_STATE,
-    REGISTER_POLICY_MIXES,
-    START_AUDIO_SOURCE,
-    STOP_AUDIO_SOURCE,
-    SET_AUDIO_PORT_CALLBACK_ENABLED,
-    SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED,
-    SET_MASTER_MONO,
-    GET_MASTER_MONO,
-    GET_STREAM_VOLUME_DB,
-    GET_SURROUND_FORMATS,
-    SET_SURROUND_FORMAT_ENABLED,
-    ADD_STREAM_DEFAULT_EFFECT,
-    REMOVE_STREAM_DEFAULT_EFFECT,
-    ADD_SOURCE_DEFAULT_EFFECT,
-    REMOVE_SOURCE_DEFAULT_EFFECT,
-    SET_ASSISTANT_UID,
-    SET_A11Y_SERVICES_UIDS,
-    IS_HAPTIC_PLAYBACK_SUPPORTED,
-    SET_UID_DEVICE_AFFINITY,
-    REMOVE_UID_DEVICE_AFFINITY,
-    SET_USERID_DEVICE_AFFINITY,
-    REMOVE_USERID_DEVICE_AFFINITY,
-    GET_OFFLOAD_FORMATS_A2DP,
-    LIST_AUDIO_PRODUCT_STRATEGIES,
-    GET_STRATEGY_FOR_ATTRIBUTES,
-    LIST_AUDIO_VOLUME_GROUPS,
-    GET_VOLUME_GROUP_FOR_ATTRIBUTES,
-    SET_SUPPORTED_SYSTEM_USAGES,
-    SET_ALLOWED_CAPTURE_POLICY,
-    MOVE_EFFECTS_TO_IO,
-    SET_RTT_ENABLED,
-    IS_CALL_SCREEN_MODE_SUPPORTED,
-    SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY,
-    REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY,
-    GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY,
-    GET_DEVICES_FOR_ATTRIBUTES,
-    AUDIO_MODULES_UPDATED,  // oneway
-    SET_CURRENT_IME_UID,
-    REGISTER_SOUNDTRIGGER_CAPTURE_STATE_LISTENER,
-    SET_DEVICES_ROLE_FOR_CAPTURE_PRESET,
-    ADD_DEVICES_ROLE_FOR_CAPTURE_PRESET,
-    REMOVE_DEVICES_ROLE_FOR_CAPTURE_PRESET,
-    CLEAR_DEVICES_ROLE_FOR_CAPTURE_PRESET,
-    GET_DEVICES_FOR_ROLE_AND_CAPTURE_PRESET,
-};
-
-#define MAX_ITEMS_PER_LIST 1024
-
-class BpAudioPolicyService : public BpInterface<IAudioPolicyService>
-{
-public:
-    explicit BpAudioPolicyService(const sp<IBinder>& impl)
-        : BpInterface<IAudioPolicyService>(impl)
-    {
-    }
-
-    virtual status_t setDeviceConnectionState(
-                                    audio_devices_t device,
-                                    audio_policy_dev_state_t state,
-                                    const char *device_address,
-                                    const char *device_name,
-                                    audio_format_t encodedFormat)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(static_cast <uint32_t>(device));
-        data.writeInt32(static_cast <uint32_t>(state));
-        data.writeCString(device_address);
-        data.writeCString(device_name);
-        data.writeInt32(static_cast <uint32_t>(encodedFormat));
-        remote()->transact(SET_DEVICE_CONNECTION_STATE, data, &reply);
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual audio_policy_dev_state_t getDeviceConnectionState(
-                                    audio_devices_t device,
-                                    const char *device_address)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(static_cast <uint32_t>(device));
-        data.writeCString(device_address);
-        remote()->transact(GET_DEVICE_CONNECTION_STATE, data, &reply);
-        return static_cast <audio_policy_dev_state_t>(reply.readInt32());
-    }
-
-    virtual status_t handleDeviceConfigChange(audio_devices_t device,
-                                              const char *device_address,
-                                              const char *device_name,
-                                              audio_format_t encodedFormat)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(static_cast <uint32_t>(device));
-        data.writeCString(device_address);
-        data.writeCString(device_name);
-        data.writeInt32(static_cast <uint32_t>(encodedFormat));
-        remote()->transact(HANDLE_DEVICE_CONFIG_CHANGE, data, &reply);
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual status_t setPhoneState(audio_mode_t state, uid_t uid)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(state);
-        data.writeInt32(uid);
-        remote()->transact(SET_PHONE_STATE, data, &reply);
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(static_cast <uint32_t>(usage));
-        data.writeInt32(static_cast <uint32_t>(config));
-        remote()->transact(SET_FORCE_USE, data, &reply);
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(static_cast <uint32_t>(usage));
-        remote()->transact(GET_FORCE_USE, data, &reply);
-        return static_cast <audio_policy_forced_cfg_t> (reply.readInt32());
-    }
-
-    virtual audio_io_handle_t getOutput(audio_stream_type_t stream)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(static_cast <uint32_t>(stream));
-        remote()->transact(GET_OUTPUT, data, &reply);
-        return static_cast <audio_io_handle_t> (reply.readInt32());
-    }
-
-    status_t getOutputForAttr(audio_attributes_t *attr,
-                              audio_io_handle_t *output,
-                              audio_session_t session,
-                              audio_stream_type_t *stream,
-                              pid_t pid,
-                              uid_t uid,
-                              const audio_config_t *config,
-                              audio_output_flags_t flags,
-                              audio_port_handle_t *selectedDeviceId,
-                              audio_port_handle_t *portId,
-                              std::vector<audio_io_handle_t> *secondaryOutputs) override
-        {
-            Parcel data, reply;
-            data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-            if (attr == nullptr) {
-                ALOGE("%s NULL audio attributes", __func__);
-                return BAD_VALUE;
-            }
-            if (output == nullptr) {
-                ALOGE("%s NULL output - shouldn't happen", __func__);
-                return BAD_VALUE;
-            }
-            if (selectedDeviceId == nullptr) {
-                ALOGE("%s NULL selectedDeviceId - shouldn't happen", __func__);
-                return BAD_VALUE;
-            }
-            if (portId == nullptr) {
-                ALOGE("%s NULL portId - shouldn't happen", __func__);
-                return BAD_VALUE;
-            }
-            if (secondaryOutputs == nullptr) {
-                ALOGE("%s NULL secondaryOutputs - shouldn't happen", __func__);
-                return BAD_VALUE;
-            }
-            data.write(attr, sizeof(audio_attributes_t));
-            data.writeInt32(session);
-            if (stream == NULL) {
-                data.writeInt32(0);
-            } else {
-                data.writeInt32(1);
-                data.writeInt32(*stream);
-            }
-            data.writeInt32(pid);
-            data.writeInt32(uid);
-            data.write(config, sizeof(audio_config_t));
-            data.writeInt32(static_cast <uint32_t>(flags));
-            data.writeInt32(*selectedDeviceId);
-            data.writeInt32(*portId);
-            status_t status = remote()->transact(GET_OUTPUT_FOR_ATTR, data, &reply);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            status = (status_t)reply.readInt32();
-            if (status != NO_ERROR) {
-                return status;
-            }
-            status = (status_t)reply.read(&attr, sizeof(audio_attributes_t));
-            if (status != NO_ERROR) {
-                return status;
-            }
-            *output = (audio_io_handle_t)reply.readInt32();
-            audio_stream_type_t lStream = (audio_stream_type_t)reply.readInt32();
-            if (stream != NULL) {
-                *stream = lStream;
-            }
-            *selectedDeviceId = (audio_port_handle_t)reply.readInt32();
-            *portId = (audio_port_handle_t)reply.readInt32();
-            secondaryOutputs->resize(reply.readInt32());
-            return reply.read(secondaryOutputs->data(),
-                              secondaryOutputs->size() * sizeof(audio_io_handle_t));
-        }
-
-    virtual status_t startOutput(audio_port_handle_t portId)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32((int32_t)portId);
-        remote()->transact(START_OUTPUT, data, &reply);
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual status_t stopOutput(audio_port_handle_t portId)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32((int32_t)portId);
-        remote()->transact(STOP_OUTPUT, data, &reply);
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual void releaseOutput(audio_port_handle_t portId)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32((int32_t)portId);
-        remote()->transact(RELEASE_OUTPUT, data, &reply);
-    }
-
-    virtual status_t getInputForAttr(const audio_attributes_t *attr,
-                                     audio_io_handle_t *input,
-                                     audio_unique_id_t riid,
-                                     audio_session_t session,
-                                     pid_t pid,
-                                     uid_t uid,
-                                     const String16& opPackageName,
-                                     const audio_config_base_t *config,
-                                     audio_input_flags_t flags,
-                                     audio_port_handle_t *selectedDeviceId,
-                                     audio_port_handle_t *portId)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        if (attr == NULL) {
-            ALOGE("getInputForAttr NULL attr - shouldn't happen");
-            return BAD_VALUE;
-        }
-        if (input == NULL) {
-            ALOGE("getInputForAttr NULL input - shouldn't happen");
-            return BAD_VALUE;
-        }
-        if (selectedDeviceId == NULL) {
-            ALOGE("getInputForAttr NULL selectedDeviceId - shouldn't happen");
-            return BAD_VALUE;
-        }
-        if (portId == NULL) {
-            ALOGE("getInputForAttr NULL portId - shouldn't happen");
-            return BAD_VALUE;
-        }
-
-        data.write(attr, sizeof(audio_attributes_t));
-        data.writeInt32(*input);
-        data.writeInt32(riid);
-        data.writeInt32(session);
-        data.writeInt32(pid);
-        data.writeInt32(uid);
-        data.writeString16(opPackageName);
-        data.write(config, sizeof(audio_config_base_t));
-        data.writeInt32(flags);
-        data.writeInt32(*selectedDeviceId);
-        data.writeInt32(*portId);
-        status_t status = remote()->transact(GET_INPUT_FOR_ATTR, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = reply.readInt32();
-        if (status != NO_ERROR) {
-            return status;
-        }
-        *input = (audio_io_handle_t)reply.readInt32();
-        *selectedDeviceId = (audio_port_handle_t)reply.readInt32();
-        *portId = (audio_port_handle_t)reply.readInt32();
-        return NO_ERROR;
-    }
-
-    virtual status_t startInput(audio_port_handle_t portId)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(portId);
-        remote()->transact(START_INPUT, data, &reply);
-        status_t status = static_cast <status_t> (reply.readInt32());
-        return status;
-    }
-
-    virtual status_t stopInput(audio_port_handle_t portId)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(portId);
-        remote()->transact(STOP_INPUT, data, &reply);
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual void releaseInput(audio_port_handle_t portId)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(portId);
-        remote()->transact(RELEASE_INPUT, data, &reply);
-    }
-
-    virtual status_t initStreamVolume(audio_stream_type_t stream,
-                                    int indexMin,
-                                    int indexMax)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(static_cast <uint32_t>(stream));
-        data.writeInt32(indexMin);
-        data.writeInt32(indexMax);
-        remote()->transact(INIT_STREAM_VOLUME, data, &reply);
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
-                                          int index,
-                                          audio_devices_t device)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(static_cast <uint32_t>(stream));
-        data.writeInt32(index);
-        data.writeInt32(static_cast <uint32_t>(device));
-        remote()->transact(SET_STREAM_VOLUME, data, &reply);
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
-                                          int *index,
-                                          audio_devices_t device)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(static_cast <uint32_t>(stream));
-        data.writeInt32(static_cast <uint32_t>(device));
-
-        remote()->transact(GET_STREAM_VOLUME, data, &reply);
-        int lIndex = reply.readInt32();
-        if (index) *index = lIndex;
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr, int index,
-                                                 audio_devices_t device)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.write(&attr, sizeof(audio_attributes_t));
-        data.writeInt32(index);
-        data.writeInt32(static_cast <uint32_t>(device));
-        status_t status = remote()->transact(SET_VOLUME_ATTRIBUTES, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        return static_cast <status_t> (reply.readInt32());
-    }
-    virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr, int &index,
-                                                 audio_devices_t device)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.write(&attr, sizeof(audio_attributes_t));
-        data.writeInt32(static_cast <uint32_t>(device));
-        status_t status = remote()->transact(GET_VOLUME_ATTRIBUTES, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = static_cast <status_t> (reply.readInt32());
-        if (status != NO_ERROR) {
-            return status;
-        }
-        index = reply.readInt32();
-        return NO_ERROR;
-    }
-    virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.write(&attr, sizeof(audio_attributes_t));
-        status_t status = remote()->transact(GET_MIN_VOLUME_FOR_ATTRIBUTES, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = static_cast <status_t> (reply.readInt32());
-        if (status != NO_ERROR) {
-            return status;
-        }
-        index = reply.readInt32();
-        return NO_ERROR;
-    }
-    virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.write(&attr, sizeof(audio_attributes_t));
-        status_t status = remote()->transact(GET_MAX_VOLUME_FOR_ATTRIBUTES, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = static_cast <status_t> (reply.readInt32());
-        if (status != NO_ERROR) {
-            return status;
-        }
-        index = reply.readInt32();
-        return NO_ERROR;
-    }
-    virtual uint32_t getStrategyForStream(audio_stream_type_t stream)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(static_cast <uint32_t>(stream));
-        remote()->transact(GET_STRATEGY_FOR_STREAM, data, &reply);
-        return reply.readUint32();
-    }
-
-    virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(static_cast <uint32_t>(stream));
-        remote()->transact(GET_DEVICES_FOR_STREAM, data, &reply);
-        return (audio_devices_t) reply.readInt32();
-    }
-
-    virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.write(desc, sizeof(effect_descriptor_t));
-        status_t status = remote()->transact(GET_OUTPUT_FOR_EFFECT, data, &reply);
-        if (status != NO_ERROR ||
-                (status = (status_t)reply.readInt32()) != NO_ERROR) {
-            return AUDIO_IO_HANDLE_NONE;
-        }
-        return static_cast <audio_io_handle_t> (reply.readInt32());
-    }
-
-    virtual status_t registerEffect(const effect_descriptor_t *desc,
-                                        audio_io_handle_t io,
-                                        uint32_t strategy,
-                                        audio_session_t session,
-                                        int id)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.write(desc, sizeof(effect_descriptor_t));
-        data.writeInt32(io);
-        data.writeInt32(strategy);
-        data.writeInt32(session);
-        data.writeInt32(id);
-        remote()->transact(REGISTER_EFFECT, data, &reply);
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual status_t unregisterEffect(int id)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(id);
-        remote()->transact(UNREGISTER_EFFECT, data, &reply);
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual status_t setEffectEnabled(int id, bool enabled)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(id);
-        data.writeInt32(enabled);
-        remote()->transact(SET_EFFECT_ENABLED, data, &reply);
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) override
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(ids.size());
-        for (auto id : ids) {
-            data.writeInt32(id);
-        }
-        data.writeInt32(io);
-        status_t status = remote()->transact(MOVE_EFFECTS_TO_IO, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32((int32_t) stream);
-        data.writeInt32(inPastMs);
-        remote()->transact(IS_STREAM_ACTIVE, data, &reply);
-        return reply.readInt32();
-    }
-
-    virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32((int32_t) stream);
-        data.writeInt32(inPastMs);
-        remote()->transact(IS_STREAM_ACTIVE_REMOTELY, data, &reply);
-        return reply.readInt32();
-    }
-
-    virtual bool isSourceActive(audio_source_t source) const
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32((int32_t) source);
-        remote()->transact(IS_SOURCE_ACTIVE, data, &reply);
-        return reply.readInt32();
-    }
-
-    virtual status_t queryDefaultPreProcessing(audio_session_t audioSession,
-                                               effect_descriptor_t *descriptors,
-                                               uint32_t *count)
-    {
-        if (descriptors == NULL || count == NULL) {
-            return BAD_VALUE;
-        }
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(audioSession);
-        data.writeInt32(*count);
-        status_t status = remote()->transact(QUERY_DEFAULT_PRE_PROCESSING, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = static_cast <status_t> (reply.readInt32());
-        uint32_t retCount = reply.readInt32();
-        if (retCount != 0) {
-            uint32_t numDesc = (retCount < *count) ? retCount : *count;
-            reply.read(descriptors, sizeof(effect_descriptor_t) * numDesc);
-        }
-        *count = retCount;
-        return status;
-    }
-
-    status_t setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages) {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(systemUsages.size());
-        for (auto systemUsage : systemUsages) {
-            data.writeInt32(systemUsage);
-        }
-        status_t status = remote()->transact(SET_SUPPORTED_SYSTEM_USAGES, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t flags) override {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(uid);
-        data.writeInt32(flags);
-        remote()->transact(SET_ALLOWED_CAPTURE_POLICY, data, &reply);
-        return reply.readInt32();
-    }
-
-    virtual audio_offload_mode_t getOffloadSupport(const audio_offload_info_t& info)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.write(&info, sizeof(audio_offload_info_t));
-        remote()->transact(GET_OFFLOAD_MODE_SUPPORTED, data, &reply);
-        return static_cast<audio_offload_mode_t>(reply.readInt32());
-    }
-
-    virtual bool isDirectOutputSupported(const audio_config_base_t& config,
-                                         const audio_attributes_t& attributes) {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.write(&config, sizeof(audio_config_base_t));
-        data.write(&attributes, sizeof(audio_attributes_t));
-        status_t status = remote()->transact(IS_DIRECT_OUTPUT_SUPPORTED, data, &reply);
-        return status == NO_ERROR ? static_cast<bool>(reply.readInt32()) : false;
-    }
-
-    virtual status_t listAudioPorts(audio_port_role_t role,
-                                    audio_port_type_t type,
-                                    unsigned int *num_ports,
-                                    struct audio_port_v7 *ports,
-                                    unsigned int *generation)
-    {
-        if (num_ports == NULL || (*num_ports != 0 && ports == NULL) ||
-                generation == NULL) {
-            return BAD_VALUE;
-        }
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        unsigned int numPortsReq = (ports == NULL) ? 0 : *num_ports;
-        data.writeInt32(role);
-        data.writeInt32(type);
-        data.writeInt32(numPortsReq);
-        status_t status = remote()->transact(LIST_AUDIO_PORTS, data, &reply);
-        if (status == NO_ERROR) {
-            status = (status_t)reply.readInt32();
-            *num_ports = (unsigned int)reply.readInt32();
-        }
-        if (status == NO_ERROR) {
-            if (numPortsReq > *num_ports) {
-                numPortsReq = *num_ports;
-            }
-            if (numPortsReq > 0) {
-                reply.read(ports, numPortsReq * sizeof(struct audio_port_v7));
-            }
-            *generation = reply.readInt32();
-        }
-        return status;
-    }
-
-    virtual status_t getAudioPort(struct audio_port_v7 *port)
-    {
-        if (port == NULL) {
-            return BAD_VALUE;
-        }
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.write(port, sizeof(struct audio_port_v7));
-        status_t status = remote()->transact(GET_AUDIO_PORT, data, &reply);
-        if (status != NO_ERROR ||
-                (status = (status_t)reply.readInt32()) != NO_ERROR) {
-            return status;
-        }
-        reply.read(port, sizeof(struct audio_port_v7));
-        return status;
-    }
-
-    virtual status_t createAudioPatch(const struct audio_patch *patch,
-                                       audio_patch_handle_t *handle)
-    {
-        if (patch == NULL || handle == NULL) {
-            return BAD_VALUE;
-        }
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.write(patch, sizeof(struct audio_patch));
-        data.write(handle, sizeof(audio_patch_handle_t));
-        status_t status = remote()->transact(CREATE_AUDIO_PATCH, data, &reply);
-        if (status != NO_ERROR ||
-                (status = (status_t)reply.readInt32()) != NO_ERROR) {
-            return status;
-        }
-        reply.read(handle, sizeof(audio_patch_handle_t));
-        return status;
-    }
-
-    virtual status_t releaseAudioPatch(audio_patch_handle_t handle)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.write(&handle, sizeof(audio_patch_handle_t));
-        status_t status = remote()->transact(RELEASE_AUDIO_PATCH, data, &reply);
-        if (status != NO_ERROR) {
-            status = (status_t)reply.readInt32();
-        }
-        return status;
-    }
-
-    virtual status_t listAudioPatches(unsigned int *num_patches,
-                                      struct audio_patch *patches,
-                                      unsigned int *generation)
-    {
-        if (num_patches == NULL || (*num_patches != 0 && patches == NULL) ||
-                generation == NULL) {
-            return BAD_VALUE;
-        }
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        unsigned int numPatchesReq = (patches == NULL) ? 0 : *num_patches;
-        data.writeInt32(numPatchesReq);
-        status_t status = remote()->transact(LIST_AUDIO_PATCHES, data, &reply);
-        if (status == NO_ERROR) {
-            status = (status_t)reply.readInt32();
-            *num_patches = (unsigned int)reply.readInt32();
-        }
-        if (status == NO_ERROR) {
-            if (numPatchesReq > *num_patches) {
-                numPatchesReq = *num_patches;
-            }
-            if (numPatchesReq > 0) {
-                reply.read(patches, numPatchesReq * sizeof(struct audio_patch));
-            }
-            *generation = reply.readInt32();
-        }
-        return status;
-    }
-
-    virtual status_t setAudioPortConfig(const struct audio_port_config *config)
-    {
-        if (config == NULL) {
-            return BAD_VALUE;
-        }
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.write(config, sizeof(struct audio_port_config));
-        status_t status = remote()->transact(SET_AUDIO_PORT_CONFIG, data, &reply);
-        if (status != NO_ERROR) {
-            status = (status_t)reply.readInt32();
-        }
-        return status;
-    }
-
-    virtual void registerClient(const sp<media::IAudioPolicyServiceClient>& client)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeStrongBinder(IInterface::asBinder(client));
-        remote()->transact(REGISTER_CLIENT, data, &reply);
-    }
-
-    virtual void setAudioPortCallbacksEnabled(bool enabled)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(enabled ? 1 : 0);
-        remote()->transact(SET_AUDIO_PORT_CALLBACK_ENABLED, data, &reply);
-    }
-
-    virtual void setAudioVolumeGroupCallbacksEnabled(bool enabled)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(enabled ? 1 : 0);
-        remote()->transact(SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED, data, &reply);
-    }
-
-    virtual status_t acquireSoundTriggerSession(audio_session_t *session,
-                                            audio_io_handle_t *ioHandle,
-                                            audio_devices_t *device)
-    {
-        if (session == NULL || ioHandle == NULL || device == NULL) {
-            return BAD_VALUE;
-        }
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        status_t status = remote()->transact(ACQUIRE_SOUNDTRIGGER_SESSION, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = (status_t)reply.readInt32();
-        if (status == NO_ERROR) {
-            *session = (audio_session_t)reply.readInt32();
-            *ioHandle = (audio_io_handle_t)reply.readInt32();
-            *device = (audio_devices_t)reply.readInt32();
-        }
-        return status;
-    }
-
-    virtual status_t releaseSoundTriggerSession(audio_session_t session)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(session);
-        status_t status = remote()->transact(RELEASE_SOUNDTRIGGER_SESSION, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        return (status_t)reply.readInt32();
-    }
-
-    virtual audio_mode_t getPhoneState()
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        status_t status = remote()->transact(GET_PHONE_STATE, data, &reply);
-        if (status != NO_ERROR) {
-            return AUDIO_MODE_INVALID;
-        }
-        return (audio_mode_t)reply.readInt32();
-    }
-
-    virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(registration ? 1 : 0);
-        size_t size = mixes.size();
-        if (size > MAX_MIXES_PER_POLICY) {
-            size = MAX_MIXES_PER_POLICY;
-        }
-        size_t sizePosition = data.dataPosition();
-        data.writeInt32(size);
-        size_t finalSize = size;
-        for (size_t i = 0; i < size; i++) {
-            size_t position = data.dataPosition();
-            if (mixes[i].writeToParcel(&data) != NO_ERROR) {
-                data.setDataPosition(position);
-                finalSize--;
-            }
-        }
-        if (size != finalSize) {
-            size_t position = data.dataPosition();
-            data.setDataPosition(sizePosition);
-            data.writeInt32(finalSize);
-            data.setDataPosition(position);
-        }
-        status_t status = remote()->transact(REGISTER_POLICY_MIXES, data, &reply);
-        if (status == NO_ERROR) {
-            status = (status_t)reply.readInt32();
-        }
-        return status;
-    }
-
-    virtual status_t startAudioSource(const struct audio_port_config *source,
-                                      const audio_attributes_t *attributes,
-                                      audio_port_handle_t *portId)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        if (source == NULL || attributes == NULL || portId == NULL) {
-            return BAD_VALUE;
-        }
-        data.write(source, sizeof(struct audio_port_config));
-        data.write(attributes, sizeof(audio_attributes_t));
-        status_t status = remote()->transact(START_AUDIO_SOURCE, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = (status_t)reply.readInt32();
-        if (status != NO_ERROR) {
-            return status;
-        }
-        *portId = (audio_port_handle_t)reply.readInt32();
-        return status;
-    }
-
-    virtual status_t stopAudioSource(audio_port_handle_t portId)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(portId);
-        status_t status = remote()->transact(STOP_AUDIO_SOURCE, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = (status_t)reply.readInt32();
-        return status;
-    }
-
-    virtual status_t setMasterMono(bool mono)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(static_cast<int32_t>(mono));
-        status_t status = remote()->transact(SET_MASTER_MONO, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        return static_cast<status_t>(reply.readInt32());
-    }
-
-    virtual status_t getMasterMono(bool *mono)
-    {
-        if (mono == nullptr) {
-            return BAD_VALUE;
-        }
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-
-        status_t status = remote()->transact(GET_MASTER_MONO, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = static_cast<status_t>(reply.readInt32());
-        if (status == NO_ERROR) {
-            *mono = static_cast<bool>(reply.readInt32());
-        }
-        return status;
-    }
-
-    virtual float getStreamVolumeDB(audio_stream_type_t stream, int index, audio_devices_t device)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(static_cast <int32_t>(stream));
-        data.writeInt32(static_cast <int32_t>(index));
-        data.writeUint32(static_cast <uint32_t>(device));
-        status_t status = remote()->transact(GET_STREAM_VOLUME_DB, data, &reply);
-        if (status != NO_ERROR) {
-            return NAN;
-        }
-        return reply.readFloat();
-    }
-
-    virtual status_t getSurroundFormats(unsigned int *numSurroundFormats,
-                                        audio_format_t *surroundFormats,
-                                        bool *surroundFormatsEnabled,
-                                        bool reported)
-    {
-        if (numSurroundFormats == NULL || (*numSurroundFormats != 0 &&
-                (surroundFormats == NULL || surroundFormatsEnabled == NULL))) {
-            return BAD_VALUE;
-        }
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        unsigned int numSurroundFormatsReq = *numSurroundFormats;
-        data.writeUint32(numSurroundFormatsReq);
-        data.writeBool(reported);
-        status_t status = remote()->transact(GET_SURROUND_FORMATS, data, &reply);
-        if (status == NO_ERROR && (status = (status_t)reply.readInt32()) == NO_ERROR) {
-            *numSurroundFormats = reply.readUint32();
-        }
-        if (status == NO_ERROR) {
-            if (numSurroundFormatsReq > *numSurroundFormats) {
-                numSurroundFormatsReq = *numSurroundFormats;
-            }
-            if (numSurroundFormatsReq > 0) {
-                status = reply.read(surroundFormats,
-                                    numSurroundFormatsReq * sizeof(audio_format_t));
-                if (status != NO_ERROR) {
-                    return status;
-                }
-                status = reply.read(surroundFormatsEnabled,
-                                    numSurroundFormatsReq * sizeof(bool));
-            }
-        }
-        return status;
-    }
-
-    virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(audioFormat);
-        data.writeBool(enabled);
-        status_t status = remote()->transact(SET_SURROUND_FORMAT_ENABLED, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        return reply.readInt32();
-    }
-
-    virtual status_t getHwOffloadEncodingFormatsSupportedForA2DP(
-                std::vector<audio_format_t> *formats)
-    {
-        if (formats == NULL) {
-            return BAD_VALUE;
-        }
-
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        status_t status = remote()->transact(GET_OFFLOAD_FORMATS_A2DP, data, &reply);
-        if (status != NO_ERROR || (status = (status_t)reply.readInt32()) != NO_ERROR) {
-            return status;
-        }
-
-        size_t list_size = reply.readUint32();
-
-        for (size_t i = 0; i < list_size; i++) {
-            formats->push_back(static_cast<audio_format_t>(reply.readInt32()));
-        }
-        return NO_ERROR;
-    }
-
-
-     virtual status_t addStreamDefaultEffect(const effect_uuid_t *type,
-                                            const String16& opPackageName,
-                                            const effect_uuid_t *uuid,
-                                            int32_t priority,
-                                            audio_usage_t usage,
-                                            audio_unique_id_t* id)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.write(type, sizeof(effect_uuid_t));
-        data.writeString16(opPackageName);
-        data.write(uuid, sizeof(effect_uuid_t));
-        data.writeInt32(priority);
-        data.writeInt32((int32_t) usage);
-        status_t status = remote()->transact(ADD_STREAM_DEFAULT_EFFECT, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = static_cast <status_t> (reply.readInt32());
-        *id = reply.readInt32();
-        return status;
-    }
-
-    virtual status_t removeStreamDefaultEffect(audio_unique_id_t id)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(id);
-        status_t status = remote()->transact(REMOVE_STREAM_DEFAULT_EFFECT, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual status_t addSourceDefaultEffect(const effect_uuid_t *type,
-                                            const String16& opPackageName,
-                                            const effect_uuid_t *uuid,
-                                            int32_t priority,
-                                            audio_source_t source,
-                                            audio_unique_id_t* id)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.write(type, sizeof(effect_uuid_t));
-        data.writeString16(opPackageName);
-        data.write(uuid, sizeof(effect_uuid_t));
-        data.writeInt32(priority);
-        data.writeInt32((int32_t) source);
-        status_t status = remote()->transact(ADD_SOURCE_DEFAULT_EFFECT, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = static_cast <status_t> (reply.readInt32());
-        *id = reply.readInt32();
-        return status;
-    }
-
-    virtual status_t removeSourceDefaultEffect(audio_unique_id_t id)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(id);
-        status_t status = remote()->transact(REMOVE_SOURCE_DEFAULT_EFFECT, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual status_t setAssistantUid(uid_t uid)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(uid);
-        status_t status = remote()->transact(SET_ASSISTANT_UID, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual status_t setA11yServicesUids(const std::vector<uid_t>& uids)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(uids.size());
-        for (auto uid : uids) {
-            data.writeInt32(uid);
-        }
-        status_t status = remote()->transact(SET_A11Y_SERVICES_UIDS, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual status_t setCurrentImeUid(uid_t uid)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(uid);
-        status_t status = remote()->transact(SET_CURRENT_IME_UID, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        return static_cast <status_t> (reply.readInt32());
-    }
-
-    virtual bool isHapticPlaybackSupported()
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        status_t status = remote()->transact(IS_HAPTIC_PLAYBACK_SUPPORTED, data, &reply);
-        if (status != NO_ERROR) {
-            return false;
-        }
-        return reply.readBool();
-    }
-
-    virtual status_t setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-
-        data.writeInt32((int32_t) uid);
-        status_t status = data.writeParcelableVector(devices);
-        if (status != NO_ERROR) {
-            return status;
-        }
-
-        status = remote()->transact(SET_UID_DEVICE_AFFINITY, data, &reply);
-        if (status == NO_ERROR) {
-            status = (status_t)reply.readInt32();
-        }
-        return status;
-    }
-
-    virtual status_t removeUidDeviceAffinities(uid_t uid) {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-
-        data.writeInt32((int32_t) uid);
-
-        status_t status =
-            remote()->transact(REMOVE_UID_DEVICE_AFFINITY, data, &reply);
-        if (status == NO_ERROR) {
-            status = (status_t) reply.readInt32();
-        }
-        return status;
-    }
-
-    virtual status_t setUserIdDeviceAffinities(int userId, const AudioDeviceTypeAddrVector& devices)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-
-        data.writeInt32((int32_t) userId);
-        status_t status = data.writeParcelableVector(devices);
-        if (status != NO_ERROR) {
-            return status;
-        }
-
-        status = remote()->transact(SET_USERID_DEVICE_AFFINITY, data, &reply);
-        if (status == NO_ERROR) {
-            status = (status_t)reply.readInt32();
-        }
-        return status;
-    }
-
-    virtual status_t removeUserIdDeviceAffinities(int userId) {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-
-        data.writeInt32((int32_t) userId);
-
-        status_t status =
-            remote()->transact(REMOVE_USERID_DEVICE_AFFINITY, data, &reply);
-        if (status == NO_ERROR) {
-            status = (status_t) reply.readInt32();
-        }
-        return status;
-    }
-
-    virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-
-        status_t status = remote()->transact(LIST_AUDIO_PRODUCT_STRATEGIES, data, &reply);
-        if (status != NO_ERROR) {
-            ALOGE("%s: permission denied", __func__);
-            return status;
-        }
-        status = static_cast<status_t>(reply.readInt32());
-        if (status != NO_ERROR) {
-            return status;
-        }
-        uint32_t numStrategies = static_cast<uint32_t>(reply.readInt32());
-        for (size_t i = 0; i < numStrategies; i++) {
-            AudioProductStrategy strategy;
-            status = strategy.readFromParcel(&reply);
-            if (status != NO_ERROR) {
-                ALOGE("%s: failed to read strategies", __FUNCTION__);
-                strategies.clear();
-                return status;
-            }
-            strategies.push_back(strategy);
-        }
-        return NO_ERROR;
-    }
-
-    virtual status_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
-                                                           product_strategy_t &productStrategy)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        status_t status = aa.writeToParcel(&data);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = remote()->transact(GET_STRATEGY_FOR_ATTRIBUTES, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = static_cast<status_t>(reply.readInt32());
-        if (status != NO_ERROR) {
-            return status;
-        }
-        productStrategy = static_cast<product_strategy_t>(reply.readInt32());
-        return NO_ERROR;
-    }
-
-    virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-
-        status_t status = remote()->transact(LIST_AUDIO_VOLUME_GROUPS, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = static_cast<status_t>(reply.readInt32());
-        if (status != NO_ERROR) {
-            return status;
-        }
-        uint32_t numGroups = static_cast<uint32_t>(reply.readInt32());
-        for (size_t i = 0; i < numGroups; i++) {
-            AudioVolumeGroup group;
-            status = group.readFromParcel(&reply);
-            if (status != NO_ERROR) {
-                ALOGE("%s: failed to read volume groups", __FUNCTION__);
-                groups.clear();
-                return status;
-            }
-            groups.push_back(group);
-        }
-        return NO_ERROR;
-    }
-
-    virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
-                                                       volume_group_t &volumeGroup)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        status_t status = aa.writeToParcel(&data);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = remote()->transact(GET_VOLUME_GROUP_FOR_ATTRIBUTES, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = static_cast<status_t>(reply.readInt32());
-        if (status != NO_ERROR) {
-            return status;
-        }
-        volumeGroup = static_cast<volume_group_t>(reply.readInt32());
-        return NO_ERROR;
-    }
-
-    virtual status_t setRttEnabled(bool enabled)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeInt32(static_cast<int32_t>(enabled));
-        status_t status = remote()->transact(SET_RTT_ENABLED, data, &reply);
-        if (status != NO_ERROR) {
-           return status;
-        }
-        return static_cast<status_t>(reply.readInt32());
-    }
-
-    virtual bool isCallScreenModeSupported()
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        status_t status = remote()->transact(IS_CALL_SCREEN_MODE_SUPPORTED, data, &reply);
-        if (status != NO_ERROR) {
-            return false;
-        }
-        return reply.readBool();
-    }
-
-    virtual status_t setDevicesRoleForStrategy(product_strategy_t strategy,
-            device_role_t role, const AudioDeviceTypeAddrVector &devices)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeUint32(static_cast<uint32_t>(strategy));
-        data.writeUint32(static_cast<uint32_t>(role));
-        status_t status = data.writeParcelableVector(devices);
-        if (status != NO_ERROR) {
-            return BAD_VALUE;
-        }
-        status = remote()->transact(SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY, data, &reply);
-        if (status != NO_ERROR) {
-           return status;
-        }
-        return static_cast<status_t>(reply.readInt32());
-    }
-
-    virtual status_t removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeUint32(static_cast<uint32_t>(strategy));
-        data.writeUint32(static_cast<uint32_t>(role));
-        status_t status = remote()->transact(REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY,
-                data, &reply);
-        if (status != NO_ERROR) {
-           return status;
-        }
-        return static_cast<status_t>(reply.readInt32());
-    }
-
-    virtual status_t getDevicesForRoleAndStrategy(product_strategy_t strategy,
-            device_role_t role, AudioDeviceTypeAddrVector &devices)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeUint32(static_cast<uint32_t>(strategy));
-        data.writeUint32(static_cast<uint32_t>(role));
-        status_t status = remote()->transact(GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY,
-                data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = reply.readParcelableVector(&devices);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        return static_cast<status_t>(reply.readInt32());
-    }
-
-    virtual status_t setDevicesRoleForCapturePreset(audio_source_t audioSource,
-            device_role_t role, const AudioDeviceTypeAddrVector &devices) {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeUint32(static_cast<uint32_t>(audioSource));
-        data.writeUint32(static_cast<uint32_t>(role));
-        status_t status = data.writeParcelableVector(devices);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = remote()->transact(SET_DEVICES_ROLE_FOR_CAPTURE_PRESET, data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        return static_cast<status_t>(reply.readInt32());
-    }
-
-    virtual status_t addDevicesRoleForCapturePreset(audio_source_t audioSource,
-            device_role_t role, const AudioDeviceTypeAddrVector &devices)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeUint32(static_cast<uint32_t>(audioSource));
-        data.writeUint32(static_cast<uint32_t>(role));
-        status_t status = data.writeParcelableVector(devices);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = remote()->transact(ADD_DEVICES_ROLE_FOR_CAPTURE_PRESET, data, &reply);
-        if (status != NO_ERROR) {
-           return status;
-        }
-        return static_cast<status_t>(reply.readInt32());
-    }
-
-    virtual status_t removeDevicesRoleForCapturePreset(
-            audio_source_t audioSource, device_role_t role,
-            const AudioDeviceTypeAddrVector& devices)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeUint32(static_cast<uint32_t>(audioSource));
-        data.writeUint32(static_cast<uint32_t>(role));
-        status_t status = data.writeParcelableVector(devices);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = remote()->transact(REMOVE_DEVICES_ROLE_FOR_CAPTURE_PRESET,
-                data, &reply);
-        if (status != NO_ERROR) {
-           return status;
-        }
-        return static_cast<status_t>(reply.readInt32());
-    }
-
-    virtual status_t clearDevicesRoleForCapturePreset(
-            audio_source_t audioSource, device_role_t role)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeUint32(static_cast<uint32_t>(audioSource));
-        data.writeUint32(static_cast<uint32_t>(role));
-        status_t status = remote()->transact(CLEAR_DEVICES_ROLE_FOR_CAPTURE_PRESET,
-                data, &reply);
-        if (status != NO_ERROR) {
-           return status;
-        }
-        return static_cast<status_t>(reply.readInt32());
-    }
-
-    virtual status_t getDevicesForRoleAndCapturePreset(audio_source_t audioSource,
-            device_role_t role, AudioDeviceTypeAddrVector &devices)
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        data.writeUint32(static_cast<uint32_t>(audioSource));
-        data.writeUint32(static_cast<uint32_t>(role));
-        status_t status = remote()->transact(GET_DEVICES_FOR_ROLE_AND_CAPTURE_PRESET,
-                data, &reply);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = reply.readParcelableVector(&devices);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        return static_cast<status_t>(reply.readInt32());
-    }
-
-    virtual status_t getDevicesForAttributes(const AudioAttributes &aa,
-            AudioDeviceTypeAddrVector *devices) const
-    {
-        if (devices == nullptr) {
-            return BAD_VALUE;
-        }
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        status_t status = aa.writeToParcel(&data);
-        if (status != NO_ERROR) {
-            return status;
-        }
-        status = remote()->transact(GET_DEVICES_FOR_ATTRIBUTES, data, &reply);
-        if (status != NO_ERROR) {
-            // transaction failed, return error
-            return status;
-        }
-        status = static_cast<status_t>(reply.readInt32());
-        if (status != NO_ERROR) {
-            // APM method call failed, return error
-            return status;
-        }
-
-        const size_t numberOfDevices = (size_t)reply.readInt32();
-        for (size_t i = 0; i < numberOfDevices; i++) {
-            AudioDeviceTypeAddr device;
-            if (device.readFromParcel((Parcel*)&reply) == NO_ERROR) {
-                devices->push_back(device);
-            } else {
-                return FAILED_TRANSACTION;
-            }
-        }
-        return NO_ERROR;
-    }
-
-    virtual void onNewAudioModulesAvailable()
-    {
-        Parcel data, reply;
-        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        remote()->transact(AUDIO_MODULES_UPDATED, data, &reply, IBinder::FLAG_ONEWAY);
-    }
-
-    status_t registerSoundTriggerCaptureStateListener(
-            const sp<media::ICaptureStateListener>& listener,
-            bool* result) override {
-        Parcel data, reply;
-        status_t status;
-        status =
-            data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-        if (status != NO_ERROR) return status;
-        status = data.writeStrongBinder(IInterface::asBinder(listener));
-        if (status != NO_ERROR) return status;
-        status =
-            remote()->transact(REGISTER_SOUNDTRIGGER_CAPTURE_STATE_LISTENER,
-                               data,
-                               &reply,
-                               0);
-        if (status != NO_ERROR) return status;
-        status = reply.readBool(result);
-        if (status != NO_ERROR) return status;
-        return NO_ERROR;
-    }
-};
-
-IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService");
-
-// ----------------------------------------------------------------------
-
-status_t BnAudioPolicyService::onTransact(
-    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
-{
-    // make sure transactions reserved to AudioFlinger do not come from other processes
-    switch (code) {
-        case START_OUTPUT:
-        case STOP_OUTPUT:
-        case RELEASE_OUTPUT:
-        case GET_INPUT_FOR_ATTR:
-        case START_INPUT:
-        case STOP_INPUT:
-        case RELEASE_INPUT:
-        case GET_OUTPUT_FOR_EFFECT:
-        case REGISTER_EFFECT:
-        case UNREGISTER_EFFECT:
-        case SET_EFFECT_ENABLED:
-        case GET_STRATEGY_FOR_STREAM:
-        case GET_OUTPUT_FOR_ATTR:
-        case MOVE_EFFECTS_TO_IO:
-            ALOGW("%s: transaction %d received from PID %d",
-                  __func__, code, IPCThreadState::self()->getCallingPid());
-            // return status only for non void methods
-            switch (code) {
-                case RELEASE_OUTPUT:
-                case RELEASE_INPUT:
-                    break;
-                default:
-                    reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION));
-                    break;
-            }
-            return OK;
-        default:
-            break;
-    }
-
-    // make sure the following transactions come from system components
-    switch (code) {
-        case SET_DEVICE_CONNECTION_STATE:
-        case HANDLE_DEVICE_CONFIG_CHANGE:
-        case SET_PHONE_STATE:
-//FIXME: Allow SET_FORCE_USE calls from system apps until a better use case routing API is available
-//      case SET_FORCE_USE:
-        case INIT_STREAM_VOLUME:
-        case SET_STREAM_VOLUME:
-        case SET_VOLUME_ATTRIBUTES:
-        case GET_STREAM_VOLUME:
-        case GET_VOLUME_ATTRIBUTES:
-        case GET_MIN_VOLUME_FOR_ATTRIBUTES:
-        case GET_MAX_VOLUME_FOR_ATTRIBUTES:
-        case IS_STREAM_ACTIVE:
-        case IS_STREAM_ACTIVE_REMOTELY:
-        case IS_SOURCE_ACTIVE:
-        case GET_DEVICES_FOR_STREAM:
-        case REGISTER_POLICY_MIXES:
-        case SET_MASTER_MONO:
-        case GET_SURROUND_FORMATS:
-        case SET_SURROUND_FORMAT_ENABLED:
-        case SET_ASSISTANT_UID:
-        case SET_A11Y_SERVICES_UIDS:
-        case SET_UID_DEVICE_AFFINITY:
-        case REMOVE_UID_DEVICE_AFFINITY:
-        case SET_USERID_DEVICE_AFFINITY:
-        case REMOVE_USERID_DEVICE_AFFINITY:
-        case GET_OFFLOAD_FORMATS_A2DP:
-        case LIST_AUDIO_VOLUME_GROUPS:
-        case GET_VOLUME_GROUP_FOR_ATTRIBUTES:
-        case ACQUIRE_SOUNDTRIGGER_SESSION:
-        case RELEASE_SOUNDTRIGGER_SESSION:
-        case SET_RTT_ENABLED:
-        case IS_CALL_SCREEN_MODE_SUPPORTED:
-        case SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY:
-        case SET_SUPPORTED_SYSTEM_USAGES:
-        case REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY:
-        case GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY:
-        case GET_DEVICES_FOR_ATTRIBUTES:
-        case SET_ALLOWED_CAPTURE_POLICY:
-        case AUDIO_MODULES_UPDATED:
-        case SET_CURRENT_IME_UID:
-        case REGISTER_SOUNDTRIGGER_CAPTURE_STATE_LISTENER:
-        case SET_DEVICES_ROLE_FOR_CAPTURE_PRESET:
-        case ADD_DEVICES_ROLE_FOR_CAPTURE_PRESET:
-        case REMOVE_DEVICES_ROLE_FOR_CAPTURE_PRESET:
-        case CLEAR_DEVICES_ROLE_FOR_CAPTURE_PRESET:
-        case GET_DEVICES_FOR_ROLE_AND_CAPTURE_PRESET: {
-            if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
-                ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
-                      __func__, code, IPCThreadState::self()->getCallingPid(),
-                      IPCThreadState::self()->getCallingUid());
-                reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION));
-                return OK;
-            }
-        } break;
-        default:
-            break;
-    }
-
-    std::string tag("IAudioPolicyService command " + std::to_string(code));
-    TimeCheck check(tag.c_str());
-
-    switch (code) {
-        case SET_DEVICE_CONNECTION_STATE: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_devices_t device =
-                    static_cast <audio_devices_t>(data.readInt32());
-            audio_policy_dev_state_t state =
-                    static_cast <audio_policy_dev_state_t>(data.readInt32());
-            const char *device_address = data.readCString();
-            const char *device_name = data.readCString();
-            audio_format_t codecFormat = static_cast <audio_format_t>(data.readInt32());
-            if (device_address == nullptr || device_name == nullptr) {
-                ALOGE("Bad Binder transaction: SET_DEVICE_CONNECTION_STATE for device %u", device);
-                reply->writeInt32(static_cast<int32_t> (BAD_VALUE));
-            } else {
-                reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device,
-                                                                                  state,
-                                                                                  device_address,
-                                                                                  device_name,
-                                                                                  codecFormat)));
-            }
-            return NO_ERROR;
-        } break;
-
-        case GET_DEVICE_CONNECTION_STATE: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_devices_t device =
-                    static_cast<audio_devices_t> (data.readInt32());
-            const char *device_address = data.readCString();
-            if (device_address == nullptr) {
-                ALOGE("Bad Binder transaction: GET_DEVICE_CONNECTION_STATE for device %u", device);
-                reply->writeInt32(static_cast<int32_t> (AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
-            } else {
-                reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device,
-                                                                                  device_address)));
-            }
-            return NO_ERROR;
-        } break;
-
-        case HANDLE_DEVICE_CONFIG_CHANGE: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_devices_t device =
-                    static_cast <audio_devices_t>(data.readInt32());
-            const char *device_address = data.readCString();
-            const char *device_name = data.readCString();
-            audio_format_t codecFormat =
-                    static_cast <audio_format_t>(data.readInt32());
-            if (device_address == nullptr || device_name == nullptr) {
-                ALOGE("Bad Binder transaction: HANDLE_DEVICE_CONFIG_CHANGE for device %u", device);
-                reply->writeInt32(static_cast<int32_t> (BAD_VALUE));
-            } else {
-                reply->writeInt32(static_cast<uint32_t> (handleDeviceConfigChange(device,
-                                                                                  device_address,
-                                                                                  device_name,
-                                                                                  codecFormat)));
-            }
-            return NO_ERROR;
-        } break;
-
-        case SET_PHONE_STATE: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            reply->writeInt32(static_cast <uint32_t>(setPhoneState(
-                    (audio_mode_t) data.readInt32(),
-                    (uid_t) data.readInt32())));
-            return NO_ERROR;
-        } break;
-
-        case SET_FORCE_USE: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
-                    data.readInt32());
-            audio_policy_forced_cfg_t config =
-                    static_cast <audio_policy_forced_cfg_t>(data.readInt32());
-            reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config)));
-            return NO_ERROR;
-        } break;
-
-        case GET_FORCE_USE: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
-                    data.readInt32());
-            reply->writeInt32(static_cast <uint32_t>(getForceUse(usage)));
-            return NO_ERROR;
-        } break;
-
-        case GET_OUTPUT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_stream_type_t stream =
-                    static_cast <audio_stream_type_t>(data.readInt32());
-            audio_io_handle_t output = getOutput(stream);
-            reply->writeInt32(static_cast <int>(output));
-            return NO_ERROR;
-        } break;
-
-        case GET_OUTPUT_FOR_ATTR: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
-            status_t status = data.read(&attr, sizeof(audio_attributes_t));
-            if (status != NO_ERROR) {
-                return status;
-            }
-            audio_session_t session = (audio_session_t)data.readInt32();
-            audio_stream_type_t stream = AUDIO_STREAM_DEFAULT;
-            bool hasStream = data.readInt32() != 0;
-            if (hasStream) {
-                stream = (audio_stream_type_t)data.readInt32();
-            }
-            pid_t pid = (pid_t)data.readInt32();
-            uid_t uid = (uid_t)data.readInt32();
-            audio_config_t config;
-            memset(&config, 0, sizeof(audio_config_t));
-            data.read(&config, sizeof(audio_config_t));
-            audio_output_flags_t flags =
-                    static_cast <audio_output_flags_t>(data.readInt32());
-            audio_port_handle_t selectedDeviceId = data.readInt32();
-            audio_port_handle_t portId = (audio_port_handle_t)data.readInt32();
-            audio_io_handle_t output = 0;
-            std::vector<audio_io_handle_t> secondaryOutputs;
-
-            status = AudioValidator::validateAudioAttributes(attr, "68953950");
-            if (status != NO_ERROR) {
-                reply->writeInt32(status);
-                return NO_ERROR;
-            }
-            status = getOutputForAttr(&attr,
-                                      &output, session, &stream, pid, uid,
-                                      &config,
-                                      flags, &selectedDeviceId, &portId, &secondaryOutputs);
-            reply->writeInt32(status);
-            status = reply->write(&attr, sizeof(audio_attributes_t));
-            if (status != NO_ERROR) {
-                return status;
-            }
-            reply->writeInt32(output);
-            reply->writeInt32(stream);
-            reply->writeInt32(selectedDeviceId);
-            reply->writeInt32(portId);
-            reply->writeInt32(secondaryOutputs.size());
-            return reply->write(secondaryOutputs.data(),
-                                secondaryOutputs.size() * sizeof(audio_io_handle_t));
-        } break;
-
-        case START_OUTPUT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            const audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
-            reply->writeInt32(static_cast <uint32_t>(startOutput(portId)));
-            return NO_ERROR;
-        } break;
-
-        case STOP_OUTPUT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            const audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
-            reply->writeInt32(static_cast <uint32_t>(stopOutput(portId)));
-            return NO_ERROR;
-        } break;
-
-        case RELEASE_OUTPUT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            const audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
-            releaseOutput(portId);
-            return NO_ERROR;
-        } break;
-
-        case GET_INPUT_FOR_ATTR: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_attributes_t attr = {};
-            status_t status = data.read(&attr, sizeof(audio_attributes_t));
-            if (status != NO_ERROR) {
-                return status;
-            }
-
-            audio_io_handle_t input = (audio_io_handle_t)data.readInt32();
-            audio_unique_id_t riid = (audio_unique_id_t)data.readInt32();
-            audio_session_t session = (audio_session_t)data.readInt32();
-            pid_t pid = (pid_t)data.readInt32();
-            uid_t uid = (uid_t)data.readInt32();
-            const String16 opPackageName = data.readString16();
-            audio_config_base_t config;
-            memset(&config, 0, sizeof(audio_config_base_t));
-            data.read(&config, sizeof(audio_config_base_t));
-            audio_input_flags_t flags = (audio_input_flags_t) data.readInt32();
-            audio_port_handle_t selectedDeviceId = (audio_port_handle_t) data.readInt32();
-            audio_port_handle_t portId = (audio_port_handle_t)data.readInt32();
-
-            status = AudioValidator::validateAudioAttributes(attr, "68953950");
-            if (status == NO_ERROR) {
-                status = getInputForAttr(&attr, &input, riid, session, pid, uid,
-                                         opPackageName, &config,
-                                         flags, &selectedDeviceId, &portId);
-            }
-            reply->writeInt32(status);
-            if (status == NO_ERROR) {
-                reply->writeInt32(input);
-                reply->writeInt32(selectedDeviceId);
-                reply->writeInt32(portId);
-            }
-            return NO_ERROR;
-        } break;
-
-        case START_INPUT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
-            status_t status = startInput(portId);
-            reply->writeInt32(static_cast <uint32_t>(status));
-            return NO_ERROR;
-        } break;
-
-        case STOP_INPUT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
-            reply->writeInt32(static_cast <uint32_t>(stopInput(portId)));
-            return NO_ERROR;
-        } break;
-
-        case RELEASE_INPUT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
-            releaseInput(portId);
-            return NO_ERROR;
-        } break;
-
-        case INIT_STREAM_VOLUME: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_stream_type_t stream =
-                    static_cast <audio_stream_type_t>(data.readInt32());
-            int indexMin = data.readInt32();
-            int indexMax = data.readInt32();
-            reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax)));
-            return NO_ERROR;
-        } break;
-
-        case SET_STREAM_VOLUME: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_stream_type_t stream =
-                    static_cast <audio_stream_type_t>(data.readInt32());
-            int index = data.readInt32();
-            audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
-            reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream,
-                                                                          index,
-                                                                          device)));
-            return NO_ERROR;
-        } break;
-
-        case GET_STREAM_VOLUME: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_stream_type_t stream =
-                    static_cast <audio_stream_type_t>(data.readInt32());
-            audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
-            int index = 0;
-            status_t status = getStreamVolumeIndex(stream, &index, device);
-            reply->writeInt32(index);
-            reply->writeInt32(static_cast <uint32_t>(status));
-            return NO_ERROR;
-        } break;
-
-        case GET_STRATEGY_FOR_STREAM: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_stream_type_t stream =
-                    static_cast <audio_stream_type_t>(data.readInt32());
-            reply->writeUint32(getStrategyForStream(stream));
-            return NO_ERROR;
-        } break;
-
-        case SET_VOLUME_ATTRIBUTES: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_attributes_t attributes = {};
-            status_t status = data.read(&attributes, sizeof(audio_attributes_t));
-            if (status != NO_ERROR) {
-                return status;
-            }
-
-            int index = data.readInt32();
-            audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
-
-            status = AudioValidator::validateAudioAttributes(attributes, "169572641");
-            if (status == NO_ERROR) {
-                status = setVolumeIndexForAttributes(attributes, index, device);
-            }
-            reply->writeInt32(static_cast <int32_t>(status));
-            return NO_ERROR;
-        } break;
-
-        case GET_VOLUME_ATTRIBUTES: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_attributes_t attributes = {};
-            status_t status = data.read(&attributes, sizeof(audio_attributes_t));
-            if (status != NO_ERROR) {
-                return status;
-            }
-            audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
-
-            int index = 0;
-            status = AudioValidator::validateAudioAttributes(attributes, "169572641");
-            if (status == NO_ERROR) {
-                status = getVolumeIndexForAttributes(attributes, index, device);
-            }
-            reply->writeInt32(static_cast <int32_t>(status));
-            if (status == NO_ERROR) {
-                reply->writeInt32(index);
-            }
-            return NO_ERROR;
-        } break;
-
-        case GET_MIN_VOLUME_FOR_ATTRIBUTES: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_attributes_t attributes = {};
-            status_t status = data.read(&attributes, sizeof(audio_attributes_t));
-            if (status != NO_ERROR) {
-                return status;
-            }
-
-            int index = 0;
-            status = AudioValidator::validateAudioAttributes(attributes, "169572641");
-            if (status == NO_ERROR) {
-                status = getMinVolumeIndexForAttributes(attributes, index);
-            }
-            reply->writeInt32(static_cast <int32_t>(status));
-            if (status == NO_ERROR) {
-                reply->writeInt32(index);
-            }
-            return NO_ERROR;
-        } break;
-
-        case GET_MAX_VOLUME_FOR_ATTRIBUTES: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_attributes_t attributes = {};
-            status_t status = data.read(&attributes, sizeof(audio_attributes_t));
-            if (status != NO_ERROR) {
-                return status;
-            }
-
-            int index = 0;
-            status = AudioValidator::validateAudioAttributes(attributes, "169572641");
-            if (status == NO_ERROR) {
-                status = getMaxVolumeIndexForAttributes(attributes, index);
-            }
-            reply->writeInt32(static_cast <int32_t>(status));
-            if (status == NO_ERROR) {
-                reply->writeInt32(index);
-            }
-            return NO_ERROR;
-        } break;
-
-        case GET_DEVICES_FOR_STREAM: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_stream_type_t stream =
-                    static_cast <audio_stream_type_t>(data.readInt32());
-            reply->writeInt32(static_cast <int>(getDevicesForStream(stream)));
-            return NO_ERROR;
-        } break;
-
-        case GET_OUTPUT_FOR_EFFECT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            effect_descriptor_t desc = {};
-            status_t status = data.read(&desc, sizeof(desc));
-            if (status != NO_ERROR) {
-                android_errorWriteLog(0x534e4554, "73126106");
-                return status;
-            }
-            status = AudioValidator::validateEffectDescriptor(desc, "73126106");
-            reply->writeInt32(status);
-            if (status == NO_ERROR) {
-                audio_io_handle_t output = getOutputForEffect(&desc);
-                reply->writeInt32(static_cast <int32_t>(output));
-            }
-            return NO_ERROR;
-        } break;
-
-        case REGISTER_EFFECT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            effect_descriptor_t desc = {};
-            status_t status = data.read(&desc, sizeof(desc));
-            if (status != NO_ERROR) {
-                android_errorWriteLog(0x534e4554, "73126106");
-                return status;
-            }
-            audio_io_handle_t io = data.readInt32();
-            uint32_t strategy = data.readInt32();
-            audio_session_t session = (audio_session_t) data.readInt32();
-            int id = data.readInt32();
-            status = AudioValidator::validateEffectDescriptor(desc, "73126106");
-            if (status == NO_ERROR) {
-                status = registerEffect(&desc, io, strategy, session, id);
-            }
-            reply->writeInt32(static_cast <int32_t>(status));
-            return NO_ERROR;
-        } break;
-
-        case UNREGISTER_EFFECT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            int id = data.readInt32();
-            reply->writeInt32(static_cast <int32_t>(unregisterEffect(id)));
-            return NO_ERROR;
-        } break;
-
-        case SET_EFFECT_ENABLED: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            int id = data.readInt32();
-            bool enabled = static_cast <bool>(data.readInt32());
-            reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled)));
-            return NO_ERROR;
-        } break;
-
-        case MOVE_EFFECTS_TO_IO: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            std::vector<int> ids;
-            int32_t size;
-            status_t status = data.readInt32(&size);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            if (size > MAX_ITEMS_PER_LIST) {
-                return BAD_VALUE;
-            }
-            for (int32_t i = 0; i < size; i++) {
-                int id;
-                status =  data.readInt32(&id);
-                if (status != NO_ERROR) {
-                    return status;
-                }
-                ids.push_back(id);
-            }
-
-            audio_io_handle_t io = data.readInt32();
-            reply->writeInt32(static_cast <int32_t>(moveEffectsToIo(ids, io)));
-            return NO_ERROR;
-        } break;
-
-        case IS_STREAM_ACTIVE: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
-            uint32_t inPastMs = (uint32_t)data.readInt32();
-            reply->writeInt32( isStreamActive(stream, inPastMs) );
-            return NO_ERROR;
-        } break;
-
-        case IS_STREAM_ACTIVE_REMOTELY: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
-            uint32_t inPastMs = (uint32_t)data.readInt32();
-            reply->writeInt32( isStreamActiveRemotely(stream, inPastMs) );
-            return NO_ERROR;
-        } break;
-
-        case IS_SOURCE_ACTIVE: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_source_t source = (audio_source_t) data.readInt32();
-            reply->writeInt32( isSourceActive(source));
-            return NO_ERROR;
-        }
-
-        case QUERY_DEFAULT_PRE_PROCESSING: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_session_t audioSession = (audio_session_t) data.readInt32();
-            uint32_t count = data.readInt32();
-            if (count > AudioEffect::kMaxPreProcessing) {
-                count = AudioEffect::kMaxPreProcessing;
-            }
-            uint32_t retCount = count;
-            effect_descriptor_t *descriptors = new effect_descriptor_t[count]{};
-            status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount);
-            reply->writeInt32(status);
-            if (status != NO_ERROR && status != NO_MEMORY) {
-                retCount = 0;
-            }
-            reply->writeInt32(retCount);
-            if (retCount != 0) {
-                if (retCount < count) {
-                    count = retCount;
-                }
-                reply->write(descriptors, sizeof(effect_descriptor_t) * count);
-            }
-            delete[] descriptors;
-            return status;
-        }
-
-        case GET_OFFLOAD_MODE_SUPPORTED: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_offload_info_t info = {};
-            data.read(&info, sizeof(audio_offload_info_t));
-            reply->writeInt32(static_cast<int32_t>(getOffloadSupport(info)));
-            return NO_ERROR;
-        }
-
-        case IS_DIRECT_OUTPUT_SUPPORTED: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_config_base_t config = {};
-            audio_attributes_t attributes = {};
-            status_t status = data.read(&config, sizeof(audio_config_base_t));
-            if (status != NO_ERROR) return status;
-            status = data.read(&attributes, sizeof(audio_attributes_t));
-            if (status != NO_ERROR) return status;
-            status = AudioValidator::validateAudioAttributes(attributes, "169572641");
-            if (status == NO_ERROR) {
-                status = isDirectOutputSupported(config, attributes);
-            }
-            reply->writeInt32(static_cast <int32_t>(status));
-            return NO_ERROR;
-        }
-
-        case LIST_AUDIO_PORTS: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_port_role_t role = (audio_port_role_t)data.readInt32();
-            audio_port_type_t type = (audio_port_type_t)data.readInt32();
-            unsigned int numPortsReq = data.readInt32();
-            if (numPortsReq > MAX_ITEMS_PER_LIST) {
-                numPortsReq = MAX_ITEMS_PER_LIST;
-            }
-            unsigned int numPorts = numPortsReq;
-            struct audio_port_v7 *ports =
-                    (struct audio_port_v7 *)calloc(numPortsReq, sizeof(struct audio_port_v7));
-            if (ports == NULL) {
-                reply->writeInt32(NO_MEMORY);
-                reply->writeInt32(0);
-                return NO_ERROR;
-            }
-            unsigned int generation;
-            status_t status = listAudioPorts(role, type, &numPorts, ports, &generation);
-            reply->writeInt32(status);
-            reply->writeInt32(numPorts);
-
-            if (status == NO_ERROR) {
-                if (numPortsReq > numPorts) {
-                    numPortsReq = numPorts;
-                }
-                reply->write(ports, numPortsReq * sizeof(struct audio_port_v7));
-                reply->writeInt32(generation);
-            }
-            free(ports);
-            return NO_ERROR;
-        }
-
-        case GET_AUDIO_PORT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            struct audio_port_v7 port = {};
-            status_t status = data.read(&port, sizeof(struct audio_port_v7));
-            if (status != NO_ERROR) {
-                ALOGE("b/23912202");
-                return status;
-            }
-            status = AudioValidator::validateAudioPort(port);
-            if (status == NO_ERROR) {
-                status = getAudioPort(&port);
-            }
-            reply->writeInt32(status);
-            if (status == NO_ERROR) {
-                reply->write(&port, sizeof(struct audio_port_v7));
-            }
-            return NO_ERROR;
-        }
-
-        case CREATE_AUDIO_PATCH: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            struct audio_patch patch = {};
-            status_t status = data.read(&patch, sizeof(struct audio_patch));
-            if (status != NO_ERROR) {
-                return status;
-            }
-            audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
-            status = data.read(&handle, sizeof(audio_patch_handle_t));
-            if (status != NO_ERROR) {
-                ALOGE("b/23912202");
-                return status;
-            }
-            status = AudioValidator::validateAudioPatch(patch);
-            if (status == NO_ERROR) {
-                status = createAudioPatch(&patch, &handle);
-            }
-            reply->writeInt32(status);
-            if (status == NO_ERROR) {
-                reply->write(&handle, sizeof(audio_patch_handle_t));
-            }
-            return NO_ERROR;
-        }
-
-        case RELEASE_AUDIO_PATCH: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
-            data.read(&handle, sizeof(audio_patch_handle_t));
-            status_t status = releaseAudioPatch(handle);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case LIST_AUDIO_PATCHES: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            unsigned int numPatchesReq = data.readInt32();
-            if (numPatchesReq > MAX_ITEMS_PER_LIST) {
-                numPatchesReq = MAX_ITEMS_PER_LIST;
-            }
-            unsigned int numPatches = numPatchesReq;
-            struct audio_patch *patches =
-                    (struct audio_patch *)calloc(numPatchesReq,
-                                                 sizeof(struct audio_patch));
-            if (patches == NULL) {
-                reply->writeInt32(NO_MEMORY);
-                reply->writeInt32(0);
-                return NO_ERROR;
-            }
-            unsigned int generation;
-            status_t status = listAudioPatches(&numPatches, patches, &generation);
-            reply->writeInt32(status);
-            reply->writeInt32(numPatches);
-            if (status == NO_ERROR) {
-                if (numPatchesReq > numPatches) {
-                    numPatchesReq = numPatches;
-                }
-                reply->write(patches, numPatchesReq * sizeof(struct audio_patch));
-                reply->writeInt32(generation);
-            }
-            free(patches);
-            return NO_ERROR;
-        }
-
-        case SET_AUDIO_PORT_CONFIG: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            struct audio_port_config config = {};
-            status_t status = data.read(&config, sizeof(struct audio_port_config));
-            if (status != NO_ERROR) {
-                return status;
-            }
-            status = AudioValidator::validateAudioPortConfig(config);
-            if (status == NO_ERROR) {
-                status = setAudioPortConfig(&config);
-            }
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case REGISTER_CLIENT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            sp<media::IAudioPolicyServiceClient> client =
-                    interface_cast<media::IAudioPolicyServiceClient>(data.readStrongBinder());
-            registerClient(client);
-            return NO_ERROR;
-        } break;
-
-        case SET_AUDIO_PORT_CALLBACK_ENABLED: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            setAudioPortCallbacksEnabled(data.readInt32() == 1);
-            return NO_ERROR;
-        } break;
-
-        case SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            setAudioVolumeGroupCallbacksEnabled(data.readInt32() == 1);
-            return NO_ERROR;
-        } break;
-
-        case ACQUIRE_SOUNDTRIGGER_SESSION: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_session_t session = AUDIO_SESSION_NONE;
-            audio_io_handle_t ioHandle = AUDIO_IO_HANDLE_NONE;
-            audio_devices_t device = AUDIO_DEVICE_NONE;
-            status_t status = acquireSoundTriggerSession(&session, &ioHandle, &device);
-            reply->writeInt32(status);
-            if (status == NO_ERROR) {
-                reply->writeInt32(session);
-                reply->writeInt32(ioHandle);
-                reply->writeInt32(device);
-            }
-            return NO_ERROR;
-        } break;
-
-        case RELEASE_SOUNDTRIGGER_SESSION: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_session_t session = (audio_session_t)data.readInt32();
-            status_t status = releaseSoundTriggerSession(session);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        } break;
-
-        case GET_PHONE_STATE: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            reply->writeInt32((int32_t)getPhoneState());
-            return NO_ERROR;
-        } break;
-
-        case REGISTER_POLICY_MIXES: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            bool registration = data.readInt32() == 1;
-            Vector<AudioMix> mixes;
-            size_t size = (size_t)data.readInt32();
-            if (size > MAX_MIXES_PER_POLICY) {
-                size = MAX_MIXES_PER_POLICY;
-            }
-            for (size_t i = 0; i < size; i++) {
-                AudioMix mix;
-                if (mix.readFromParcel((Parcel*)&data) == NO_ERROR) {
-                    mixes.add(mix);
-                }
-            }
-            status_t status = registerPolicyMixes(mixes, registration);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        } break;
-
-        case START_AUDIO_SOURCE: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            struct audio_port_config source = {};
-            status_t status = data.read(&source, sizeof(struct audio_port_config));
-            if (status != NO_ERROR) {
-                return status;
-            }
-            audio_attributes_t attributes = {};
-            status = data.read(&attributes, sizeof(audio_attributes_t));
-            if (status != NO_ERROR) {
-                return status;
-            }
-            status = AudioValidator::validateAudioPortConfig(source);
-            if (status == NO_ERROR) {
-                // OK to not always sanitize attributes as startAudioSource() is not called if
-                // the port config is invalid.
-                status = AudioValidator::validateAudioAttributes(attributes, "68953950");
-            }
-            audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
-            if (status == NO_ERROR) {
-                status = startAudioSource(&source, &attributes, &portId);
-            }
-            reply->writeInt32(status);
-            reply->writeInt32(portId);
-            return NO_ERROR;
-        } break;
-
-        case STOP_AUDIO_SOURCE: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_port_handle_t portId = (audio_port_handle_t) data.readInt32();
-            status_t status = stopAudioSource(portId);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        } break;
-
-        case SET_MASTER_MONO: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            bool mono = static_cast<bool>(data.readInt32());
-            status_t status = setMasterMono(mono);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        } break;
-
-        case GET_MASTER_MONO: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            bool mono;
-            status_t status = getMasterMono(&mono);
-            reply->writeInt32(status);
-            if (status == NO_ERROR) {
-                reply->writeInt32(static_cast<int32_t>(mono));
-            }
-            return NO_ERROR;
-        } break;
-
-        case GET_STREAM_VOLUME_DB: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_stream_type_t stream =
-                    static_cast <audio_stream_type_t>(data.readInt32());
-            int index = static_cast <int>(data.readInt32());
-            audio_devices_t device =
-                    static_cast <audio_devices_t>(data.readUint32());
-            reply->writeFloat(getStreamVolumeDB(stream, index, device));
-            return NO_ERROR;
-        }
-
-        case GET_SURROUND_FORMATS: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            unsigned int numSurroundFormatsReq = data.readUint32();
-            if (numSurroundFormatsReq > MAX_ITEMS_PER_LIST) {
-                numSurroundFormatsReq = MAX_ITEMS_PER_LIST;
-            }
-            bool reported = data.readBool();
-            unsigned int numSurroundFormats = numSurroundFormatsReq;
-            audio_format_t *surroundFormats = (audio_format_t *)calloc(
-                    numSurroundFormats, sizeof(audio_format_t));
-            bool *surroundFormatsEnabled = (bool *)calloc(numSurroundFormats, sizeof(bool));
-            if (numSurroundFormatsReq > 0 &&
-                    (surroundFormats == NULL || surroundFormatsEnabled == NULL)) {
-                free(surroundFormats);
-                free(surroundFormatsEnabled);
-                reply->writeInt32(NO_MEMORY);
-                return NO_ERROR;
-            }
-            status_t status = getSurroundFormats(
-                    &numSurroundFormats, surroundFormats, surroundFormatsEnabled, reported);
-            reply->writeInt32(status);
-
-            if (status == NO_ERROR) {
-                reply->writeUint32(numSurroundFormats);
-                if (numSurroundFormatsReq > numSurroundFormats) {
-                    numSurroundFormatsReq = numSurroundFormats;
-                }
-                reply->write(surroundFormats, numSurroundFormatsReq * sizeof(audio_format_t));
-                reply->write(surroundFormatsEnabled, numSurroundFormatsReq * sizeof(bool));
-            }
-            free(surroundFormats);
-            free(surroundFormatsEnabled);
-            return NO_ERROR;
-        }
-
-        case SET_SURROUND_FORMAT_ENABLED: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_format_t audioFormat = (audio_format_t) data.readInt32();
-            bool enabled = data.readBool();
-            status_t status = setSurroundFormatEnabled(audioFormat, enabled);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case GET_OFFLOAD_FORMATS_A2DP: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            std::vector<audio_format_t> encodingFormats;
-            status_t status = getHwOffloadEncodingFormatsSupportedForA2DP(&encodingFormats);
-            reply->writeInt32(status);
-            if (status != NO_ERROR) {
-                return NO_ERROR;
-            }
-            reply->writeUint32(static_cast<uint32_t>(encodingFormats.size()));
-            for (size_t i = 0; i < encodingFormats.size(); i++)
-                reply->writeInt32(static_cast<int32_t>(encodingFormats[i]));
-            return NO_ERROR;
-        }
-
-
-        case ADD_STREAM_DEFAULT_EFFECT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            effect_uuid_t type;
-            status_t status = data.read(&type, sizeof(effect_uuid_t));
-            if (status != NO_ERROR) {
-                return status;
-            }
-            String16 opPackageName;
-            status = data.readString16(&opPackageName);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            effect_uuid_t uuid;
-            status = data.read(&uuid, sizeof(effect_uuid_t));
-            if (status != NO_ERROR) {
-                return status;
-            }
-            int32_t priority = data.readInt32();
-            audio_usage_t usage = (audio_usage_t) data.readInt32();
-            audio_unique_id_t id = 0;
-            reply->writeInt32(static_cast <int32_t>(addStreamDefaultEffect(&type,
-                                                                           opPackageName,
-                                                                           &uuid,
-                                                                           priority,
-                                                                           usage,
-                                                                           &id)));
-            reply->writeInt32(id);
-            return NO_ERROR;
-        }
-
-        case REMOVE_STREAM_DEFAULT_EFFECT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_unique_id_t id = static_cast<audio_unique_id_t>(data.readInt32());
-            reply->writeInt32(static_cast <int32_t>(removeStreamDefaultEffect(id)));
-            return NO_ERROR;
-        }
-
-        case ADD_SOURCE_DEFAULT_EFFECT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            effect_uuid_t type;
-            status_t status = data.read(&type, sizeof(effect_uuid_t));
-            if (status != NO_ERROR) {
-                return status;
-            }
-            String16 opPackageName;
-            status = data.readString16(&opPackageName);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            effect_uuid_t uuid;
-            status = data.read(&uuid, sizeof(effect_uuid_t));
-            if (status != NO_ERROR) {
-                return status;
-            }
-            int32_t priority = data.readInt32();
-            audio_source_t source = (audio_source_t) data.readInt32();
-            audio_unique_id_t id = 0;
-            reply->writeInt32(static_cast <int32_t>(addSourceDefaultEffect(&type,
-                                                                           opPackageName,
-                                                                           &uuid,
-                                                                           priority,
-                                                                           source,
-                                                                           &id)));
-            reply->writeInt32(id);
-            return NO_ERROR;
-        }
-
-        case REMOVE_SOURCE_DEFAULT_EFFECT: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_unique_id_t id = static_cast<audio_unique_id_t>(data.readInt32());
-            reply->writeInt32(static_cast <int32_t>(removeSourceDefaultEffect(id)));
-            return NO_ERROR;
-        }
-
-        case SET_ASSISTANT_UID: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            int32_t uid;
-            status_t status = data.readInt32(&uid);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            status = setAssistantUid(uid);
-            reply->writeInt32(static_cast <int32_t>(status));
-            return NO_ERROR;
-        }
-
-        case SET_A11Y_SERVICES_UIDS: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            std::vector<uid_t> uids;
-            int32_t size;
-            status_t status = data.readInt32(&size);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            if (size > MAX_ITEMS_PER_LIST) {
-                size = MAX_ITEMS_PER_LIST;
-            }
-            for (int32_t i = 0; i < size; i++) {
-                int32_t uid;
-                status =  data.readInt32(&uid);
-                if (status != NO_ERROR) {
-                    return status;
-                }
-                uids.push_back(uid);
-            }
-            status = setA11yServicesUids(uids);
-            reply->writeInt32(static_cast <int32_t>(status));
-            return NO_ERROR;
-        }
-
-        case IS_HAPTIC_PLAYBACK_SUPPORTED: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            bool isSupported = isHapticPlaybackSupported();
-            reply->writeBool(isSupported);
-            return NO_ERROR;
-        }
-        case SET_UID_DEVICE_AFFINITY: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            const uid_t uid = (uid_t) data.readInt32();
-            AudioDeviceTypeAddrVector devices;
-            status_t status = data.readParcelableVector(&devices);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            status = setUidDeviceAffinities(uid, devices);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case REMOVE_UID_DEVICE_AFFINITY: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            const uid_t uid = (uid_t) data.readInt32();
-            status_t status = removeUidDeviceAffinities(uid);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case SET_USERID_DEVICE_AFFINITY: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            const int userId = (int) data.readInt32();
-            AudioDeviceTypeAddrVector devices;
-            status_t status = data.readParcelableVector(&devices);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            status = setUserIdDeviceAffinities(userId, devices);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case REMOVE_USERID_DEVICE_AFFINITY: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            const int userId = (int) data.readInt32();
-            status_t status = removeUserIdDeviceAffinities(userId);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case LIST_AUDIO_PRODUCT_STRATEGIES: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            AudioProductStrategyVector strategies;
-            status_t status = listAudioProductStrategies(strategies);
-            reply->writeInt32(status);
-            if (status != NO_ERROR) {
-                return NO_ERROR;
-            }
-            size_t size = strategies.size();
-            size_t sizePosition = reply->dataPosition();
-            reply->writeInt32(size);
-            size_t finalSize = size;
-            for (size_t i = 0; i < size; i++) {
-                size_t position = reply->dataPosition();
-                if (strategies[i].writeToParcel(reply) != NO_ERROR) {
-                    reply->setDataPosition(position);
-                    finalSize--;
-                }
-            }
-            if (size != finalSize) {
-                size_t position = reply->dataPosition();
-                reply->setDataPosition(sizePosition);
-                reply->writeInt32(finalSize);
-                reply->setDataPosition(position);
-            }
-            return NO_ERROR;
-        }
-
-        case GET_STRATEGY_FOR_ATTRIBUTES: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            AudioAttributes attributes;
-            status_t status = attributes.readFromParcel(&data);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            product_strategy_t strategy;
-            status = getProductStrategyFromAudioAttributes(attributes, strategy);
-            reply->writeInt32(status);
-            if (status != NO_ERROR) {
-                return NO_ERROR;
-            }
-            reply->writeUint32(static_cast<int>(strategy));
-            return NO_ERROR;
-        }
-
-        case LIST_AUDIO_VOLUME_GROUPS: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            AudioVolumeGroupVector groups;
-            status_t status = listAudioVolumeGroups(groups);
-            reply->writeInt32(status);
-            if (status != NO_ERROR) {
-                return NO_ERROR;
-            }
-            size_t size = groups.size();
-            size_t sizePosition = reply->dataPosition();
-            reply->writeInt32(size);
-            size_t finalSize = size;
-            for (size_t i = 0; i < size; i++) {
-                size_t position = reply->dataPosition();
-                if (groups[i].writeToParcel(reply) != NO_ERROR) {
-                    reply->setDataPosition(position);
-                    finalSize--;
-                }
-            }
-            if (size != finalSize) {
-                size_t position = reply->dataPosition();
-                reply->setDataPosition(sizePosition);
-                reply->writeInt32(finalSize);
-                reply->setDataPosition(position);
-            }
-            return NO_ERROR;
-        }
-
-        case GET_VOLUME_GROUP_FOR_ATTRIBUTES: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            AudioAttributes attributes;
-            status_t status = attributes.readFromParcel(&data);
-            if (status != NO_ERROR) {
-                return status;
-            }
-
-            volume_group_t group;
-            status = getVolumeGroupFromAudioAttributes(attributes, group);
-            if (status != NO_ERROR) {
-                return NO_ERROR;
-            }
-
-            reply->writeInt32(status);
-            reply->writeUint32(static_cast<int>(group));
-            return NO_ERROR;
-        }
-
-        case SET_SUPPORTED_SYSTEM_USAGES: {
-             CHECK_INTERFACE(IAudioPolicyService, data, reply);
-             std::vector<audio_usage_t> systemUsages;
-
-             int32_t size;
-             status_t status = data.readInt32(&size);
-             if (status != NO_ERROR) {
-                 return status;
-             }
-             if (size > MAX_ITEMS_PER_LIST) {
-                 size = MAX_ITEMS_PER_LIST;
-             }
-
-             for (int32_t i = 0; i < size; i++) {
-                 int32_t systemUsageInt;
-                 status = data.readInt32(&systemUsageInt);
-                 if (status != NO_ERROR) {
-                     return status;
-                 }
-
-                 audio_usage_t systemUsage = static_cast<audio_usage_t>(systemUsageInt);
-                 systemUsages.push_back(systemUsage);
-             }
-             status = setSupportedSystemUsages(systemUsages);
-             reply->writeInt32(static_cast <int32_t>(status));
-             return NO_ERROR;
-        }
-
-        case SET_ALLOWED_CAPTURE_POLICY: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            uid_t uid = data.readInt32();
-            audio_flags_mask_t flags = static_cast<audio_flags_mask_t>(data.readInt32());
-            status_t status = setAllowedCapturePolicy(uid, flags);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case SET_RTT_ENABLED: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            bool enabled = static_cast<bool>(data.readInt32());
-            status_t status = setRttEnabled(enabled);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case IS_CALL_SCREEN_MODE_SUPPORTED: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            bool isAvailable = isCallScreenModeSupported();
-            reply->writeBool(isAvailable);
-            return NO_ERROR;
-        }
-
-        case SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            product_strategy_t strategy = (product_strategy_t) data.readUint32();
-            device_role_t role = (device_role_t) data.readUint32();
-            AudioDeviceTypeAddrVector devices;
-            status_t status = data.readParcelableVector(&devices);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            status = setDevicesRoleForStrategy(strategy, role, devices);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            product_strategy_t strategy = (product_strategy_t) data.readUint32();
-            device_role_t role = (device_role_t) data.readUint32();
-            status_t status = removeDevicesRoleForStrategy(strategy, role);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            product_strategy_t strategy = (product_strategy_t) data.readUint32();
-            device_role_t role = (device_role_t) data.readUint32();
-            AudioDeviceTypeAddrVector devices;
-            status_t status = getDevicesForRoleAndStrategy(strategy, role, devices);
-            status_t marshall_status = reply->writeParcelableVector(devices);
-            if (marshall_status != NO_ERROR) {
-                return marshall_status;
-            }
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case GET_DEVICES_FOR_ATTRIBUTES: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            AudioAttributes attributes;
-            status_t status = attributes.readFromParcel(&data);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            AudioDeviceTypeAddrVector devices;
-            status = getDevicesForAttributes(attributes.getAttributes(), &devices);
-            // reply data formatted as:
-            //  - (int32) method call result from APM
-            //  - (int32) number of devices (n) if method call returned NO_ERROR
-            //  - n AudioDeviceTypeAddr         if method call returned NO_ERROR
-            reply->writeInt32(status);
-            if (status != NO_ERROR) {
-                return NO_ERROR;
-            }
-            status = reply->writeInt32(devices.size());
-            if (status != NO_ERROR) {
-                return status;
-            }
-            for (const auto& device : devices) {
-                status = device.writeToParcel(reply);
-                if (status != NO_ERROR) {
-                    return status;
-                }
-            }
-
-            return NO_ERROR;
-        }
-
-        case AUDIO_MODULES_UPDATED: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            onNewAudioModulesAvailable();
-            return NO_ERROR;
-        } break;
-
-        case SET_CURRENT_IME_UID: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            int32_t uid;
-            status_t status = data.readInt32(&uid);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            status = setCurrentImeUid(uid);
-            reply->writeInt32(static_cast <int32_t>(status));
-            return NO_ERROR;
-        }
-
-        case REGISTER_SOUNDTRIGGER_CAPTURE_STATE_LISTENER: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            sp<IBinder> binder = data.readStrongBinder();
-            if (binder == nullptr) {
-                return BAD_VALUE;
-            }
-            sp<ICaptureStateListener>
-                listener = interface_cast<ICaptureStateListener>(
-                binder);
-            if (listener == nullptr) {
-                return BAD_VALUE;
-            }
-            bool ret;
-            status_t status =
-                registerSoundTriggerCaptureStateListener(listener, &ret);
-            LOG_ALWAYS_FATAL_IF(status != NO_ERROR,
-                                "Server returned unexpected status code: %d",
-                                status);
-            status = reply->writeBool(ret);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            return NO_ERROR;
-        } break;
-
-        case SET_DEVICES_ROLE_FOR_CAPTURE_PRESET: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_source_t audioSource = (audio_source_t) data.readUint32();
-            device_role_t role = (device_role_t) data.readUint32();
-            AudioDeviceTypeAddrVector devices;
-            status_t status = data.readParcelableVector(&devices);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            status = setDevicesRoleForCapturePreset(audioSource, role, devices);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case ADD_DEVICES_ROLE_FOR_CAPTURE_PRESET: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_source_t audioSource = (audio_source_t) data.readUint32();
-            device_role_t role = (device_role_t) data.readUint32();
-            AudioDeviceTypeAddrVector devices;
-            status_t status = data.readParcelableVector(&devices);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            status = addDevicesRoleForCapturePreset(audioSource, role, devices);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case REMOVE_DEVICES_ROLE_FOR_CAPTURE_PRESET: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_source_t audioSource = (audio_source_t) data.readUint32();
-            device_role_t role = (device_role_t) data.readUint32();
-            AudioDeviceTypeAddrVector devices;
-            status_t status = data.readParcelableVector(&devices);
-            if (status != NO_ERROR) {
-                return status;
-            }
-            status = removeDevicesRoleForCapturePreset(audioSource, role, devices);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case CLEAR_DEVICES_ROLE_FOR_CAPTURE_PRESET: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_source_t audioSource = (audio_source_t) data.readUint32();
-            device_role_t role = (device_role_t) data.readUint32();
-            status_t status = clearDevicesRoleForCapturePreset(audioSource, role);
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        case GET_DEVICES_FOR_ROLE_AND_CAPTURE_PRESET: {
-            CHECK_INTERFACE(IAudioPolicyService, data, reply);
-            audio_source_t audioSource = (audio_source_t) data.readUint32();
-            device_role_t role = (device_role_t) data.readUint32();
-            AudioDeviceTypeAddrVector devices;
-            status_t status = getDevicesForRoleAndCapturePreset(audioSource, role, devices);
-            status_t marshall_status = reply->writeParcelableVector(devices);
-            if (marshall_status != NO_ERROR) {
-                return marshall_status;
-            }
-            reply->writeInt32(status);
-            return NO_ERROR;
-        }
-
-        default:
-            return BBinder::onTransact(code, data, reply, flags);
-    }
-}
-
-// ----------------------------------------------------------------------------
-
-} // namespace android
diff --git a/media/libaudioclient/PolicyAidlConversion.cpp b/media/libaudioclient/PolicyAidlConversion.cpp
new file mode 100644
index 0000000..25fdb49
--- /dev/null
+++ b/media/libaudioclient/PolicyAidlConversion.cpp
@@ -0,0 +1,469 @@
+/*
+ * Copyright (C) 2021 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 "PolicyAidlConversion"
+//#define LOG_NDEBUG 0
+#include <utils/Log.h>
+
+#include "media/PolicyAidlConversion.h"
+
+#include "media/AidlConversion.h"
+
+namespace android {
+
+using base::unexpected;
+
+ConversionResult<volume_group_t>
+aidl2legacy_int32_t_volume_group_t(int32_t aidl) {
+    return convertReinterpret<volume_group_t>(aidl);
+}
+
+ConversionResult<int32_t>
+legacy2aidl_volume_group_t_int32_t(volume_group_t legacy) {
+    return convertReinterpret<int32_t>(legacy);
+}
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixType_uint32_t(media::AudioMixType aidl) {
+    switch (aidl) {
+        case media::AudioMixType::PLAYERS:
+            return MIX_TYPE_PLAYERS;
+        case media::AudioMixType::RECORDERS:
+            return MIX_TYPE_RECORDERS;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioMixType>
+legacy2aidl_uint32_t_AudioMixType(uint32_t legacy) {
+    switch (legacy) {
+        case MIX_TYPE_PLAYERS:
+            return media::AudioMixType::PLAYERS;
+        case MIX_TYPE_RECORDERS:
+            return media::AudioMixType::RECORDERS;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixCallbackFlag_uint32_t(media::AudioMixCallbackFlag aidl) {
+    switch (aidl) {
+        case media::AudioMixCallbackFlag::NOTIFY_ACTIVITY:
+            return AudioMix::kCbFlagNotifyActivity;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioMixCallbackFlag>
+legacy2aidl_uint32_t_AudioMixCallbackFlag(uint32_t legacy) {
+    switch (legacy) {
+        case AudioMix::kCbFlagNotifyActivity:
+            return media::AudioMixCallbackFlag::NOTIFY_ACTIVITY;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixCallbackFlag_uint32_t_mask(int32_t aidl) {
+    return convertBitmask<uint32_t, int32_t, uint32_t, media::AudioMixCallbackFlag>(
+            aidl,
+            aidl2legacy_AudioMixCallbackFlag_uint32_t,
+            indexToEnum_index<media::AudioMixCallbackFlag>,
+            enumToMask_bitmask<uint32_t, uint32_t>);
+}
+
+ConversionResult<int32_t>
+legacy2aidl_uint32_t_AudioMixCallbackFlag_mask(uint32_t legacy) {
+    return convertBitmask<int32_t, uint32_t, media::AudioMixCallbackFlag, uint32_t>(
+            legacy,
+            legacy2aidl_uint32_t_AudioMixCallbackFlag,
+            indexToEnum_bitmask<uint32_t>,
+            enumToMask_index<int32_t, media::AudioMixCallbackFlag>);
+}
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixRouteFlag_uint32_t(media::AudioMixRouteFlag aidl) {
+    switch (aidl) {
+        case media::AudioMixRouteFlag::RENDER:
+            return MIX_ROUTE_FLAG_RENDER;
+        case media::AudioMixRouteFlag::LOOP_BACK:
+            return MIX_ROUTE_FLAG_LOOP_BACK;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioMixRouteFlag>
+legacy2aidl_uint32_t_AudioMixRouteFlag(uint32_t legacy) {
+    switch (legacy) {
+        case MIX_ROUTE_FLAG_RENDER:
+            return media::AudioMixRouteFlag::RENDER;
+        case MIX_ROUTE_FLAG_LOOP_BACK:
+            return media::AudioMixRouteFlag::LOOP_BACK;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixRouteFlag_uint32_t_mask(int32_t aidl) {
+    return convertBitmask<uint32_t, int32_t, uint32_t, media::AudioMixRouteFlag>(
+            aidl,
+            aidl2legacy_AudioMixRouteFlag_uint32_t,
+            indexToEnum_index<media::AudioMixRouteFlag>,
+            enumToMask_bitmask<uint32_t, uint32_t>);
+}
+
+ConversionResult<int32_t>
+legacy2aidl_uint32_t_AudioMixRouteFlag_mask(uint32_t legacy) {
+    return convertBitmask<int32_t, uint32_t, media::AudioMixRouteFlag, uint32_t>(
+            legacy,
+            legacy2aidl_uint32_t_AudioMixRouteFlag,
+            indexToEnum_bitmask<uint32_t>,
+            enumToMask_index<int32_t, media::AudioMixRouteFlag>);
+}
+
+// This type is unnamed in the original definition, thus we name it here.
+using AudioMixMatchCriterionValue = decltype(AudioMixMatchCriterion::mValue);
+
+ConversionResult<AudioMixMatchCriterionValue>
+aidl2legacy_AudioMixMatchCriterionValue(
+        const media::AudioMixMatchCriterionValue& aidl,
+        uint32_t* rule) {
+    AudioMixMatchCriterionValue legacy;
+    *rule = 0;
+    switch (aidl.getTag()) {
+        case media::AudioMixMatchCriterionValue::usage:
+            legacy.mUsage = VALUE_OR_RETURN(
+                    aidl2legacy_AudioUsage_audio_usage_t(UNION_GET(aidl, usage).value()));
+            *rule |= RULE_MATCH_ATTRIBUTE_USAGE;
+            return legacy;
+
+        case media::AudioMixMatchCriterionValue::source:
+            legacy.mSource = VALUE_OR_RETURN(
+                    aidl2legacy_AudioSourceType_audio_source_t(UNION_GET(aidl, source).value()));
+            *rule |= RULE_MATCH_ATTRIBUTE_CAPTURE_PRESET;
+            return legacy;
+
+        case media::AudioMixMatchCriterionValue::uid:
+            legacy.mUid = VALUE_OR_RETURN(
+                    aidl2legacy_int32_t_uid_t(UNION_GET(aidl, uid).value()));
+            *rule |= RULE_MATCH_UID;
+            return legacy;
+
+        case media::AudioMixMatchCriterionValue::userId:
+            legacy.mUserId = VALUE_OR_RETURN(
+                    convertIntegral<int>(UNION_GET(aidl, userId).value()));
+            *rule |= RULE_MATCH_USERID;
+            return legacy;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioMixMatchCriterionValue>
+legacy2aidl_AudioMixMatchCriterionValue(
+        const AudioMixMatchCriterionValue& legacy,
+        uint32_t rule) {
+    media::AudioMixMatchCriterionValue aidl;
+    switch (rule) {
+        case RULE_MATCH_ATTRIBUTE_USAGE:
+            UNION_SET(aidl, usage,
+                      VALUE_OR_RETURN(legacy2aidl_audio_usage_t_AudioUsage(legacy.mUsage)));
+            break;
+
+        case RULE_MATCH_ATTRIBUTE_CAPTURE_PRESET:
+            UNION_SET(aidl, source,
+                      VALUE_OR_RETURN(legacy2aidl_audio_source_t_AudioSourceType(legacy.mSource)));
+            break;
+
+        case RULE_MATCH_UID:
+            UNION_SET(aidl, uid, VALUE_OR_RETURN(legacy2aidl_uid_t_int32_t(legacy.mUid)));
+            break;
+
+        case RULE_MATCH_USERID:
+            UNION_SET(aidl, userId, VALUE_OR_RETURN(convertReinterpret<uint32_t>(legacy.mUserId)));
+            break;
+
+        default:
+            return unexpected(BAD_VALUE);
+    }
+    return aidl;
+}
+
+
+ConversionResult<AudioMixMatchCriterion>
+aidl2legacy_AudioMixMatchCriterion(const media::AudioMixMatchCriterion& aidl) {
+    AudioMixMatchCriterion legacy;
+    legacy.mValue = VALUE_OR_RETURN(
+            aidl2legacy_AudioMixMatchCriterionValue(aidl.value, &legacy.mRule));
+    if (aidl.invert) {
+        legacy.mRule |= RULE_EXCLUSION_MASK;
+    }
+    return legacy;
+}
+
+ConversionResult<media::AudioMixMatchCriterion>
+legacy2aidl_AudioMixMatchCriterion(const AudioMixMatchCriterion& legacy) {
+    media::AudioMixMatchCriterion aidl;
+    uint32_t rule = legacy.mRule;
+    if (rule & RULE_EXCLUSION_MASK) {
+        aidl.invert = true;
+        rule &= ~RULE_EXCLUSION_MASK;
+    }
+    aidl.value = VALUE_OR_RETURN(legacy2aidl_AudioMixMatchCriterionValue(legacy.mValue, rule));
+    return aidl;
+}
+
+ConversionResult<AudioMix>
+aidl2legacy_AudioMix(const media::AudioMix& aidl) {
+    AudioMix legacy;
+    RETURN_IF_ERROR(convertRange(aidl.criteria.begin(), aidl.criteria.end(),
+                                 std::back_inserter(legacy.mCriteria),
+                                 aidl2legacy_AudioMixMatchCriterion));
+    legacy.mMixType = VALUE_OR_RETURN(aidl2legacy_AudioMixType_uint32_t(aidl.mixType));
+    legacy.mFormat = VALUE_OR_RETURN(aidl2legacy_AudioConfig_audio_config_t(aidl.format));
+    legacy.mRouteFlags = VALUE_OR_RETURN(
+            aidl2legacy_AudioMixRouteFlag_uint32_t_mask(aidl.routeFlags));
+    legacy.mDeviceType = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_devices_t(aidl.device.type));
+    legacy.mDeviceAddress = VALUE_OR_RETURN(aidl2legacy_string_view_String8(aidl.device.address));
+    legacy.mCbFlags = VALUE_OR_RETURN(aidl2legacy_AudioMixCallbackFlag_uint32_t_mask(aidl.cbFlags));
+    legacy.mAllowPrivilegedMediaPlaybackCapture = aidl.allowPrivilegedMediaPlaybackCapture;
+    legacy.mVoiceCommunicationCaptureAllowed = aidl.voiceCommunicationCaptureAllowed;
+    return legacy;
+}
+
+ConversionResult<media::AudioMix>
+legacy2aidl_AudioMix(const AudioMix& legacy) {
+    media::AudioMix aidl;
+    aidl.criteria = VALUE_OR_RETURN(
+            convertContainer<std::vector<media::AudioMixMatchCriterion>>(
+                    legacy.mCriteria,
+                    legacy2aidl_AudioMixMatchCriterion));
+    aidl.mixType = VALUE_OR_RETURN(legacy2aidl_uint32_t_AudioMixType(legacy.mMixType));
+    aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_config_t_AudioConfig(legacy.mFormat));
+    aidl.routeFlags = VALUE_OR_RETURN(
+            legacy2aidl_uint32_t_AudioMixRouteFlag_mask(legacy.mRouteFlags));
+    aidl.device.type = VALUE_OR_RETURN(legacy2aidl_audio_devices_t_int32_t(legacy.mDeviceType));
+    aidl.device.address = VALUE_OR_RETURN(legacy2aidl_String8_string(legacy.mDeviceAddress));
+    aidl.cbFlags = VALUE_OR_RETURN(legacy2aidl_uint32_t_AudioMixCallbackFlag_mask(legacy.mCbFlags));
+    aidl.allowPrivilegedMediaPlaybackCapture = legacy.mAllowPrivilegedMediaPlaybackCapture;
+    aidl.voiceCommunicationCaptureAllowed = legacy.mVoiceCommunicationCaptureAllowed;
+    return aidl;
+}
+
+ConversionResult<audio_policy_dev_state_t>
+aidl2legacy_AudioPolicyDeviceState_audio_policy_dev_state_t(media::AudioPolicyDeviceState aidl) {
+    switch (aidl) {
+        case media::AudioPolicyDeviceState::UNAVAILABLE:
+            return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
+        case media::AudioPolicyDeviceState::AVAILABLE:
+            return AUDIO_POLICY_DEVICE_STATE_AVAILABLE;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioPolicyDeviceState>
+legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(audio_policy_dev_state_t legacy) {
+    switch (legacy) {
+        case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE:
+            return media::AudioPolicyDeviceState::UNAVAILABLE;
+        case AUDIO_POLICY_DEVICE_STATE_AVAILABLE:
+            return media::AudioPolicyDeviceState::AVAILABLE;
+        case AUDIO_POLICY_DEVICE_STATE_CNT:
+            break;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_policy_force_use_t>
+aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(media::AudioPolicyForceUse aidl) {
+    switch (aidl) {
+        case media::AudioPolicyForceUse::COMMUNICATION:
+            return AUDIO_POLICY_FORCE_FOR_COMMUNICATION;
+        case media::AudioPolicyForceUse::MEDIA:
+            return AUDIO_POLICY_FORCE_FOR_MEDIA;
+        case media::AudioPolicyForceUse::RECORD:
+            return AUDIO_POLICY_FORCE_FOR_RECORD;
+        case media::AudioPolicyForceUse::DOCK:
+            return AUDIO_POLICY_FORCE_FOR_DOCK;
+        case media::AudioPolicyForceUse::SYSTEM:
+            return AUDIO_POLICY_FORCE_FOR_SYSTEM;
+        case media::AudioPolicyForceUse::HDMI_SYSTEM_AUDIO:
+            return AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO;
+        case media::AudioPolicyForceUse::ENCODED_SURROUND:
+            return AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND;
+        case media::AudioPolicyForceUse::VIBRATE_RINGING:
+            return AUDIO_POLICY_FORCE_FOR_VIBRATE_RINGING;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioPolicyForceUse>
+legacy2aidl_audio_policy_force_use_t_AudioPolicyForceUse(audio_policy_force_use_t legacy) {
+    switch (legacy) {
+        case AUDIO_POLICY_FORCE_FOR_COMMUNICATION:
+            return media::AudioPolicyForceUse::COMMUNICATION;
+        case AUDIO_POLICY_FORCE_FOR_MEDIA:
+            return media::AudioPolicyForceUse::MEDIA;
+        case AUDIO_POLICY_FORCE_FOR_RECORD:
+            return media::AudioPolicyForceUse::RECORD;
+        case AUDIO_POLICY_FORCE_FOR_DOCK:
+            return media::AudioPolicyForceUse::DOCK;
+        case AUDIO_POLICY_FORCE_FOR_SYSTEM:
+            return media::AudioPolicyForceUse::SYSTEM;
+        case AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO:
+            return media::AudioPolicyForceUse::HDMI_SYSTEM_AUDIO;
+        case AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND:
+            return media::AudioPolicyForceUse::ENCODED_SURROUND;
+        case AUDIO_POLICY_FORCE_FOR_VIBRATE_RINGING:
+            return media::AudioPolicyForceUse::VIBRATE_RINGING;
+        case AUDIO_POLICY_FORCE_USE_CNT:
+            break;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_policy_forced_cfg_t>
+aidl2legacy_AudioPolicyForcedConfig_audio_policy_forced_cfg_t(media::AudioPolicyForcedConfig aidl) {
+    switch (aidl) {
+        case media::AudioPolicyForcedConfig::NONE:
+            return AUDIO_POLICY_FORCE_NONE;
+        case media::AudioPolicyForcedConfig::SPEAKER:
+            return AUDIO_POLICY_FORCE_SPEAKER;
+        case media::AudioPolicyForcedConfig::HEADPHONES:
+            return AUDIO_POLICY_FORCE_HEADPHONES;
+        case media::AudioPolicyForcedConfig::BT_SCO:
+            return AUDIO_POLICY_FORCE_BT_SCO;
+        case media::AudioPolicyForcedConfig::BT_A2DP:
+            return AUDIO_POLICY_FORCE_BT_A2DP;
+        case media::AudioPolicyForcedConfig::WIRED_ACCESSORY:
+            return AUDIO_POLICY_FORCE_WIRED_ACCESSORY;
+        case media::AudioPolicyForcedConfig::BT_CAR_DOCK:
+            return AUDIO_POLICY_FORCE_BT_CAR_DOCK;
+        case media::AudioPolicyForcedConfig::BT_DESK_DOCK:
+            return AUDIO_POLICY_FORCE_BT_DESK_DOCK;
+        case media::AudioPolicyForcedConfig::ANALOG_DOCK:
+            return AUDIO_POLICY_FORCE_ANALOG_DOCK;
+        case media::AudioPolicyForcedConfig::DIGITAL_DOCK:
+            return AUDIO_POLICY_FORCE_DIGITAL_DOCK;
+        case media::AudioPolicyForcedConfig::NO_BT_A2DP:
+            return AUDIO_POLICY_FORCE_NO_BT_A2DP;
+        case media::AudioPolicyForcedConfig::SYSTEM_ENFORCED:
+            return AUDIO_POLICY_FORCE_SYSTEM_ENFORCED;
+        case media::AudioPolicyForcedConfig::HDMI_SYSTEM_AUDIO_ENFORCED:
+            return AUDIO_POLICY_FORCE_HDMI_SYSTEM_AUDIO_ENFORCED;
+        case media::AudioPolicyForcedConfig::ENCODED_SURROUND_NEVER:
+            return AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER;
+        case media::AudioPolicyForcedConfig::ENCODED_SURROUND_ALWAYS:
+            return AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS;
+        case media::AudioPolicyForcedConfig::ENCODED_SURROUND_MANUAL:
+            return AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioPolicyForcedConfig>
+legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(audio_policy_forced_cfg_t legacy) {
+    switch (legacy) {
+        case AUDIO_POLICY_FORCE_NONE:
+            return media::AudioPolicyForcedConfig::NONE;
+        case AUDIO_POLICY_FORCE_SPEAKER:
+            return media::AudioPolicyForcedConfig::SPEAKER;
+        case AUDIO_POLICY_FORCE_HEADPHONES:
+            return media::AudioPolicyForcedConfig::HEADPHONES;
+        case AUDIO_POLICY_FORCE_BT_SCO:
+            return media::AudioPolicyForcedConfig::BT_SCO;
+        case AUDIO_POLICY_FORCE_BT_A2DP:
+            return media::AudioPolicyForcedConfig::BT_A2DP;
+        case AUDIO_POLICY_FORCE_WIRED_ACCESSORY:
+            return media::AudioPolicyForcedConfig::WIRED_ACCESSORY;
+        case AUDIO_POLICY_FORCE_BT_CAR_DOCK:
+            return media::AudioPolicyForcedConfig::BT_CAR_DOCK;
+        case AUDIO_POLICY_FORCE_BT_DESK_DOCK:
+            return media::AudioPolicyForcedConfig::BT_DESK_DOCK;
+        case AUDIO_POLICY_FORCE_ANALOG_DOCK:
+            return media::AudioPolicyForcedConfig::ANALOG_DOCK;
+        case AUDIO_POLICY_FORCE_DIGITAL_DOCK:
+            return media::AudioPolicyForcedConfig::DIGITAL_DOCK;
+        case AUDIO_POLICY_FORCE_NO_BT_A2DP:
+            return media::AudioPolicyForcedConfig::NO_BT_A2DP;
+        case AUDIO_POLICY_FORCE_SYSTEM_ENFORCED:
+            return media::AudioPolicyForcedConfig::SYSTEM_ENFORCED;
+        case AUDIO_POLICY_FORCE_HDMI_SYSTEM_AUDIO_ENFORCED:
+            return media::AudioPolicyForcedConfig::HDMI_SYSTEM_AUDIO_ENFORCED;
+        case AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER:
+            return media::AudioPolicyForcedConfig::ENCODED_SURROUND_NEVER;
+        case AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS:
+            return media::AudioPolicyForcedConfig::ENCODED_SURROUND_ALWAYS;
+        case AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL:
+            return media::AudioPolicyForcedConfig::ENCODED_SURROUND_MANUAL;
+        case AUDIO_POLICY_FORCE_CFG_CNT:
+            break;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<device_role_t>
+aidl2legacy_DeviceRole_device_role_t(media::DeviceRole aidl) {
+    switch (aidl) {
+        case media::DeviceRole::NONE:
+            return DEVICE_ROLE_NONE;
+        case media::DeviceRole::PREFERRED:
+            return DEVICE_ROLE_PREFERRED;
+        case media::DeviceRole::DISABLED:
+            return DEVICE_ROLE_DISABLED;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::DeviceRole>
+legacy2aidl_device_role_t_DeviceRole(device_role_t legacy) {
+    switch (legacy) {
+        case DEVICE_ROLE_NONE:
+            return media::DeviceRole::NONE;
+        case DEVICE_ROLE_PREFERRED:
+            return media::DeviceRole::PREFERRED;
+        case DEVICE_ROLE_DISABLED:
+            return media::DeviceRole::DISABLED;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_offload_mode_t>
+aidl2legacy_AudioOffloadMode_audio_offload_mode_t(media::AudioOffloadMode aidl) {
+    switch (aidl) {
+        case media::AudioOffloadMode::NOT_SUPPORTED:
+            return AUDIO_OFFLOAD_NOT_SUPPORTED;
+        case media::AudioOffloadMode::SUPPORTED:
+            return AUDIO_OFFLOAD_SUPPORTED;
+        case media::AudioOffloadMode::GAPLESS_SUPPORTED:
+            return AUDIO_OFFLOAD_GAPLESS_SUPPORTED;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioOffloadMode>
+legacy2aidl_audio_offload_mode_t_AudioOffloadMode(audio_offload_mode_t legacy) {
+    switch (legacy) {
+        case AUDIO_OFFLOAD_NOT_SUPPORTED:
+            return media::AudioOffloadMode::NOT_SUPPORTED;
+        case AUDIO_OFFLOAD_SUPPORTED:
+            return media::AudioOffloadMode::SUPPORTED;
+        case AUDIO_OFFLOAD_GAPLESS_SUPPORTED:
+            return media::AudioOffloadMode::GAPLESS_SUPPORTED;
+    }
+    return unexpected(BAD_VALUE);
+}
+
+}  // namespace android
diff --git a/media/libaudioclient/aidl/android/media/AudioAttributesEx.aidl b/media/libaudioclient/aidl/android/media/AudioAttributesEx.aidl
new file mode 100644
index 0000000..04a02c7
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioAttributesEx.aidl
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.AudioAttributesInternal;
+import android.media.AudioStreamType;
+
+/**
+ * This is the equivalent of the android::AudioAttributes C++ type.
+ * {@hide}
+ */
+parcelable AudioAttributesEx {
+    AudioAttributesInternal attributes;
+    AudioStreamType streamType;
+    /** Interpreted as volume_group_t. */
+    int groupId;
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioMix.aidl b/media/libaudioclient/aidl/android/media/AudioMix.aidl
new file mode 100644
index 0000000..7473372
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioMix.aidl
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.AudioConfig;
+import android.media.AudioDevice;
+import android.media.AudioMixCallbackFlag;
+import android.media.AudioMixMatchCriterion;
+import android.media.AudioMixRouteFlag;
+import android.media.AudioMixType;
+
+/**
+ * {@hide}
+ */
+parcelable AudioMix {
+    AudioMixMatchCriterion[] criteria;
+    AudioMixType mixType;
+    AudioConfig format;
+    /** Bitmask, indexed by AudioMixRouteFlag. */
+    int routeFlags;
+    AudioDevice device;
+    /** Flags indicating which callbacks to use. Bitmask, indexed by AudioMixCallbackFlag. */
+    int cbFlags;
+    /** Ignore the AUDIO_FLAG_NO_MEDIA_PROJECTION */
+    boolean allowPrivilegedMediaPlaybackCapture;
+    /** Indicates if the caller can capture voice communication output */
+    boolean voiceCommunicationCaptureAllowed;
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioMixCallbackFlag.aidl b/media/libaudioclient/aidl/android/media/AudioMixCallbackFlag.aidl
new file mode 100644
index 0000000..6cb3d38
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioMixCallbackFlag.aidl
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum AudioMixCallbackFlag {
+    NOTIFY_ACTIVITY = 0,
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioMixMatchCriterion.aidl b/media/libaudioclient/aidl/android/media/AudioMixMatchCriterion.aidl
new file mode 100644
index 0000000..2c63dc5
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioMixMatchCriterion.aidl
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.AudioMixMatchCriterionValue;
+
+/**
+ * {@hide}
+ */
+parcelable AudioMixMatchCriterion {
+    /** When true, rule becomes "exclude" instead of "include". */
+    boolean invert;
+    AudioMixMatchCriterionValue value;
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioMixMatchCriterionValue.aidl b/media/libaudioclient/aidl/android/media/AudioMixMatchCriterionValue.aidl
new file mode 100644
index 0000000..e26a9e1
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioMixMatchCriterionValue.aidl
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.AudioSourceType;
+import android.media.AudioUsage;
+
+/**
+ * {@hide}
+ */
+union AudioMixMatchCriterionValue {
+    AudioUsage usage = AudioUsage.UNKNOWN;
+    AudioSourceType source;
+    /** Interpreted as uid_t. */
+    int uid;
+    int userId;
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioMixRouteFlag.aidl b/media/libaudioclient/aidl/android/media/AudioMixRouteFlag.aidl
new file mode 100644
index 0000000..f0cce2d
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioMixRouteFlag.aidl
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum AudioMixRouteFlag {
+    RENDER = 0,
+    LOOP_BACK = 1,
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioMixType.aidl b/media/libaudioclient/aidl/android/media/AudioMixType.aidl
new file mode 100644
index 0000000..b6806dc
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioMixType.aidl
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum AudioMixType {
+    PLAYERS = 0,
+    RECORDERS = 1,
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioOffloadMode.aidl b/media/libaudioclient/aidl/android/media/AudioOffloadMode.aidl
new file mode 100644
index 0000000..45a44f2
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioOffloadMode.aidl
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum AudioOffloadMode {
+    NOT_SUPPORTED = 0,
+    SUPPORTED = 1,
+    GAPLESS_SUPPORTED = 2
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioPolicyDeviceState.aidl b/media/libaudioclient/aidl/android/media/AudioPolicyDeviceState.aidl
new file mode 100644
index 0000000..a1072d2
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioPolicyDeviceState.aidl
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum AudioPolicyDeviceState {
+    UNAVAILABLE = 0,
+    AVAILABLE = 1,
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioPolicyForceUse.aidl b/media/libaudioclient/aidl/android/media/AudioPolicyForceUse.aidl
new file mode 100644
index 0000000..9bb0605
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioPolicyForceUse.aidl
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum AudioPolicyForceUse {
+    COMMUNICATION = 0,
+    MEDIA = 1,
+    RECORD = 2,
+    DOCK = 3,
+    SYSTEM = 4,
+    HDMI_SYSTEM_AUDIO = 5,
+    ENCODED_SURROUND = 6,
+    VIBRATE_RINGING = 7,
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioPolicyForcedConfig.aidl b/media/libaudioclient/aidl/android/media/AudioPolicyForcedConfig.aidl
new file mode 100644
index 0000000..2255d4c
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioPolicyForcedConfig.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum AudioPolicyForcedConfig {
+    NONE = 0,
+    SPEAKER = 1,
+    HEADPHONES = 2,
+    BT_SCO = 3,
+    BT_A2DP = 4,
+    WIRED_ACCESSORY = 5,
+    BT_CAR_DOCK = 6,
+    BT_DESK_DOCK = 7,
+    ANALOG_DOCK = 8,
+    DIGITAL_DOCK = 9,
+    NO_BT_A2DP = 10, /* A2DP sink is not preferred to speaker or wired HS */
+    SYSTEM_ENFORCED = 11,
+    HDMI_SYSTEM_AUDIO_ENFORCED = 12,
+    ENCODED_SURROUND_NEVER = 13,
+    ENCODED_SURROUND_ALWAYS = 14,
+    ENCODED_SURROUND_MANUAL = 15,
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioProductStrategy.aidl b/media/libaudioclient/aidl/android/media/AudioProductStrategy.aidl
new file mode 100644
index 0000000..56c4a44
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioProductStrategy.aidl
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.AudioAttributesEx;
+
+/**
+ * {@hide}
+ */
+parcelable AudioProductStrategy {
+    /** Interpreted as product_strategy_t. */
+    int id;
+    @utf8InCpp String name;
+    AudioAttributesEx[] audioAttributes;
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioVolumeGroup.aidl b/media/libaudioclient/aidl/android/media/AudioVolumeGroup.aidl
new file mode 100644
index 0000000..3a29a08
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioVolumeGroup.aidl
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.AudioAttributesInternal;
+import android.media.AudioStreamType;
+
+/**
+ * {@hide}
+ */
+parcelable AudioVolumeGroup {
+    /** Interpreted as volume_group_t. */
+    int groupId;
+    @utf8InCpp String name;
+    AudioAttributesInternal[] audioAttributes;
+    AudioStreamType[] streams;
+}
diff --git a/media/libaudioclient/aidl/android/media/DeviceRole.aidl b/media/libaudioclient/aidl/android/media/DeviceRole.aidl
new file mode 100644
index 0000000..b741843
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/DeviceRole.aidl
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum DeviceRole {
+    /** Default routing rules and priority apply. */
+    NONE = 0,
+    /* Devices are specified as preferred devices. */
+    PREFERRED = 1,
+    /* Devices cannot be used. */
+    DISABLED = 2,
+}
diff --git a/media/libaudioclient/aidl/android/media/GetInputForAttrResponse.aidl b/media/libaudioclient/aidl/android/media/GetInputForAttrResponse.aidl
new file mode 100644
index 0000000..9696124
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/GetInputForAttrResponse.aidl
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+/**
+ * {@hide}
+ */
+parcelable GetInputForAttrResponse {
+    /** Interpreted as audio_io_handle_t. */
+    int input;
+    /** Interpreted as audio_port_handle_t. */
+    int selectedDeviceId;
+    /** Interpreted as audio_port_handle_t. */
+    int portId;
+}
diff --git a/media/libaudioclient/aidl/android/media/GetOutputForAttrResponse.aidl b/media/libaudioclient/aidl/android/media/GetOutputForAttrResponse.aidl
new file mode 100644
index 0000000..164fb9d
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/GetOutputForAttrResponse.aidl
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.AudioStreamType;
+
+/**
+ * {@hide}
+ */
+parcelable GetOutputForAttrResponse {
+    /** Interpreted as audio_io_handle_t. */
+    int output;
+    AudioStreamType stream;
+    /** Interpreted as audio_port_handle_t. */
+    int selectedDeviceId;
+    /** Interpreted as audio_port_handle_t. */
+    int portId;
+    /** Interpreted as audio_io_handle_t[]. */
+    int[] secondaryOutputs;
+}
diff --git a/media/libaudioclient/aidl/android/media/IAudioPolicyService.aidl b/media/libaudioclient/aidl/android/media/IAudioPolicyService.aidl
new file mode 100644
index 0000000..f3a086d
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/IAudioPolicyService.aidl
@@ -0,0 +1,334 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.audio.common.AudioFormat;
+
+import android.media.AudioAttributesEx;
+import android.media.AudioAttributesInternal;
+import android.media.AudioConfig;
+import android.media.AudioConfigBase;
+import android.media.AudioDevice;
+import android.media.AudioMix;
+import android.media.AudioMode;
+import android.media.AudioOffloadInfo;
+import android.media.AudioOffloadMode;
+import android.media.AudioPatch;
+import android.media.AudioPolicyDeviceState;
+import android.media.AudioPolicyForcedConfig;
+import android.media.AudioPolicyForceUse;
+import android.media.AudioPort;
+import android.media.AudioPortConfig;
+import android.media.AudioPortRole;
+import android.media.AudioPortType;
+import android.media.AudioProductStrategy;
+import android.media.AudioSourceType;
+import android.media.AudioStreamType;
+import android.media.AudioUsage;
+import android.media.AudioUuid;
+import android.media.AudioVolumeGroup;
+import android.media.DeviceRole;
+import android.media.EffectDescriptor;
+import android.media.GetInputForAttrResponse;
+import android.media.GetOutputForAttrResponse;
+import android.media.IAudioPolicyServiceClient;
+import android.media.ICaptureStateListener;
+import android.media.Int;
+import android.media.SoundTriggerSession;
+
+/**
+ * IAudioPolicyService interface (see AudioPolicyInterface for method descriptions).
+ *
+ * {@hide}
+ */
+interface IAudioPolicyService {
+    oneway void onNewAudioModulesAvailable();
+
+    void setDeviceConnectionState(in AudioDevice device,
+                                  in AudioPolicyDeviceState state,
+                                  @utf8InCpp String deviceName,
+                                  in AudioFormat encodedFormat);
+
+    AudioPolicyDeviceState getDeviceConnectionState(in AudioDevice device);
+
+    void handleDeviceConfigChange(in AudioDevice device,
+                                  @utf8InCpp String deviceName,
+                                  in AudioFormat encodedFormat);
+
+    void setPhoneState(AudioMode state, int /* uid_t */ uid);
+
+    void setForceUse(AudioPolicyForceUse usage,
+                     AudioPolicyForcedConfig config);
+
+    AudioPolicyForcedConfig getForceUse(AudioPolicyForceUse usage);
+
+    int /* audio_io_handle_t */ getOutput(AudioStreamType stream);
+
+    GetOutputForAttrResponse getOutputForAttr(in AudioAttributesInternal attr,
+                                              int /* audio_session_t */ session,
+                                              int /* pid_t */ pid,
+                                              int /* uid_t */ uid,
+                                              in AudioConfig config,
+                                              int /* Bitmask, indexed by AudioOutputFlags */ flags);
+
+    void startOutput(int /* audio_port_handle_t */ portId);
+
+    void stopOutput(int /* audio_port_handle_t */ portId);
+
+    void releaseOutput(int /* audio_port_handle_t */ portId);
+
+    GetInputForAttrResponse getInputForAttr(in AudioAttributesInternal attr,
+                                            int /* audio_io_handle_t */ input,
+                                            int /* audio_unique_id_t */ riid,
+                                            int /* audio_session_t */ session,
+                                            int /* pid_t */ pid,
+                                            int /* uid_t */ uid,
+                                            @utf8InCpp String opPackageName,
+                                            in AudioConfigBase config,
+                                            int /* Bitmask, indexed by AudioInputFlags */ flags);
+
+    void startInput(int /* audio_port_handle_t */ portId);
+
+    void stopInput(int /* audio_port_handle_t */ portId);
+
+    void releaseInput(int /* audio_port_handle_t */ portId);
+
+    void initStreamVolume(AudioStreamType stream,
+                          int indexMin,
+                          int indexMax);
+
+    void setStreamVolumeIndex(AudioStreamType stream,
+                              int /* audio_devices_t */ device,
+                              int index);
+
+    int getStreamVolumeIndex(AudioStreamType stream,
+                             int /* audio_devices_t */ device);
+
+    void setVolumeIndexForAttributes(in AudioAttributesInternal attr,
+                                     int /* audio_devices_t */ device,
+                                     int index);
+
+    int getVolumeIndexForAttributes(in AudioAttributesInternal attr,
+                                    int /* audio_devices_t */ device);
+
+    int getMaxVolumeIndexForAttributes(in AudioAttributesInternal attr);
+
+    int getMinVolumeIndexForAttributes(in AudioAttributesInternal attr);
+
+    int /* product_strategy_t */ getStrategyForStream(AudioStreamType stream);
+
+    int /* bitmask of audio_devices_t */ getDevicesForStream(AudioStreamType stream);
+
+    AudioDevice[] getDevicesForAttributes(in AudioAttributesEx attr);
+
+    int /* audio_io_handle_t */ getOutputForEffect(in EffectDescriptor desc);
+
+    void registerEffect(in EffectDescriptor desc,
+                        int /* audio_io_handle_t */ io,
+                        int /* product_strategy_t */ strategy,
+                        int /* audio_session_t */ session,
+                        int id);
+
+    void unregisterEffect(int id);
+
+    void setEffectEnabled(int id, boolean enabled);
+
+    void moveEffectsToIo(in int[] ids, int /* audio_io_handle_t */ io);
+
+    boolean isStreamActive(AudioStreamType stream, int inPastMs);
+
+    boolean isStreamActiveRemotely(AudioStreamType stream, int inPastMs);
+
+    boolean isSourceActive(AudioSourceType source);
+
+    /**
+     * On input, count represents the maximum length of the returned array.
+     * On output, count is the total number of elements, which may be larger than the array size.
+     * Passing '0' on input and inspecting the value on output is a common way of determining the
+     * number of elements without actually retrieving them.
+     */
+    EffectDescriptor[] queryDefaultPreProcessing(int /* audio_session_t */ audioSession,
+                                                 inout Int count);
+
+    int /* audio_unique_id_t */ addSourceDefaultEffect(in AudioUuid type,
+                                                       @utf8InCpp String opPackageName,
+                                                       in AudioUuid uuid,
+                                                       int priority,
+                                                       AudioSourceType source);
+
+    int /* audio_unique_id_t */ addStreamDefaultEffect(in AudioUuid type,
+                                                       @utf8InCpp String opPackageName,
+                                                       in AudioUuid uuid,
+                                                       int priority,
+                                                       AudioUsage usage);
+
+    void removeSourceDefaultEffect(int /* audio_unique_id_t */ id);
+
+    void removeStreamDefaultEffect(int /* audio_unique_id_t */ id);
+
+    void setSupportedSystemUsages(in AudioUsage[] systemUsages);
+
+    void setAllowedCapturePolicy(int /* uid_t */ uid,
+                                 int /* Bitmask of AudioFlags */ capturePolicy);
+
+    /**
+     * Check if offload is possible for given format, stream type, sample rate,
+     * bit rate, duration, video and streaming or offload property is enabled.
+     */
+    AudioOffloadMode getOffloadSupport(in AudioOffloadInfo info);
+
+    /**
+     * Check if direct playback is possible for given format, sample rate, channel mask and flags.
+     */
+    boolean isDirectOutputSupported(in AudioConfigBase config,
+                                    in AudioAttributesInternal attributes);
+
+    /**
+     * List available audio ports and their attributes. Returns the generation.
+     *
+     * On input, count represents the maximum length of the returned array.
+     * On output, count is the total number of elements, which may be larger than the array size.
+     * Passing '0' on input and inspecting the value on output is a common way of determining the
+     * number of elements without actually retrieving them.
+     */
+    int listAudioPorts(AudioPortRole role,
+                       AudioPortType type,
+                       inout Int count,
+                       out AudioPort[] ports);
+
+    /** Get attributes for a given audio port. */
+    AudioPort getAudioPort(in AudioPort port);
+
+    /**
+     * Create an audio patch between several source and sink ports.
+     * The handle argument is used when updating an existing patch.
+     */
+    int /* audio_patch_handle_t */ createAudioPatch(in AudioPatch patch, int handle);
+
+    /** Release an audio patch. */
+    void releaseAudioPatch(int /* audio_patch_handle_t */ handle);
+
+    /**
+     * List existing audio patches. Returns the generation.
+     *
+     * On input, count represents the maximum length of the returned array.
+     * On output, count is the total number of elements, which may be larger than the array size.
+     * Passing '0' on input and inspecting the value on output is a common way of determining the
+     * number of elements without actually retrieving them.
+     */
+    int listAudioPatches(inout Int count, out AudioPatch[] patches);
+
+    /** Set audio port configuration. */
+    void setAudioPortConfig(in AudioPortConfig config);
+
+    void registerClient(IAudioPolicyServiceClient client);
+
+    void setAudioPortCallbacksEnabled(boolean enabled);
+
+    void setAudioVolumeGroupCallbacksEnabled(boolean enabled);
+
+    SoundTriggerSession acquireSoundTriggerSession();
+
+    void releaseSoundTriggerSession(int /* audio_session_t */ session);
+
+    AudioMode getPhoneState();
+
+    void registerPolicyMixes(in AudioMix[] mixes, boolean registration);
+
+    void setUidDeviceAffinities(int /* uid_t */ uid, in AudioDevice[] devices);
+
+    void removeUidDeviceAffinities(int /* uid_t */ uid);
+
+    void setUserIdDeviceAffinities(int userId, in AudioDevice[] devices);
+
+    void removeUserIdDeviceAffinities(int userId);
+
+    int /* audio_port_handle_t */ startAudioSource(in AudioPortConfig source,
+                                                   in AudioAttributesInternal attributes);
+
+    void stopAudioSource(int /* audio_port_handle_t */ portId);
+
+    void setMasterMono(boolean mono);
+
+    boolean getMasterMono();
+
+    float getStreamVolumeDB(AudioStreamType stream, int index, int /* audio_devices_t */ device);
+
+    /**
+     * Returns whether surround formats are enabled.
+     *
+     * On input, count represents the maximum length of the returned array.
+     * On output, count is the total number of elements, which may be larger than the array size.
+     * Passing '0' on input and inspecting the value on output is a common way of determining the
+     * number of elements without actually retrieving them.
+     */
+    boolean getSurroundFormats(boolean reported,
+                               inout Int count,
+                               out AudioFormat[] formats);
+
+    AudioFormat[] getHwOffloadEncodingFormatsSupportedForA2DP();
+
+    void setSurroundFormatEnabled(AudioFormat audioFormat, boolean enabled);
+
+    void setAssistantUid(int /* uid_t */ uid);
+
+    void setA11yServicesUids(in int[] /* uid_t[] */ uids);
+
+    void setCurrentImeUid(int /* uid_t */ uid);
+
+    boolean isHapticPlaybackSupported();
+
+    AudioProductStrategy[] listAudioProductStrategies();
+    int /* product_strategy_t */ getProductStrategyFromAudioAttributes(in AudioAttributesEx aa);
+
+    AudioVolumeGroup[] listAudioVolumeGroups();
+    int /* volume_group_t */ getVolumeGroupFromAudioAttributes(in AudioAttributesEx aa);
+
+    void setRttEnabled(boolean enabled);
+
+    boolean isCallScreenModeSupported();
+
+    void setDevicesRoleForStrategy(int /* product_strategy_t */ strategy,
+                                   DeviceRole role,
+                                   in AudioDevice[] devices);
+
+    void removeDevicesRoleForStrategy(int /* product_strategy_t */ strategy,
+                                       DeviceRole role);
+
+    AudioDevice[] getDevicesForRoleAndStrategy(int /* product_strategy_t */ strategy,
+                                               DeviceRole role);
+
+    void setDevicesRoleForCapturePreset(AudioSourceType audioSource,
+                                        DeviceRole role,
+                                        in AudioDevice[] devices);
+
+    void addDevicesRoleForCapturePreset(AudioSourceType audioSource,
+                                        DeviceRole role,
+                                        in AudioDevice[] devices);
+
+    void removeDevicesRoleForCapturePreset(AudioSourceType audioSource,
+                                           DeviceRole role,
+                                           in AudioDevice[] devices);
+
+    void clearDevicesRoleForCapturePreset(AudioSourceType audioSource,
+                                          DeviceRole role);
+
+    AudioDevice[] getDevicesForRoleAndCapturePreset(AudioSourceType audioSource,
+                                                    DeviceRole role);
+
+    boolean registerSoundTriggerCaptureStateListener(ICaptureStateListener listener);
+}
diff --git a/media/libaudioclient/aidl/android/media/Int.aidl b/media/libaudioclient/aidl/android/media/Int.aidl
new file mode 100644
index 0000000..24f4d62
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/Int.aidl
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+/**
+ * This is a simple wrapper around an 'int', putting it in a parcelable, so it can be used as an
+ * inout parameter, be made @nullable, etc.
+ *
+ * {@hide}
+ */
+parcelable Int {
+    int value;
+}
diff --git a/media/libaudioclient/aidl/android/media/SoundTriggerSession.aidl b/media/libaudioclient/aidl/android/media/SoundTriggerSession.aidl
new file mode 100644
index 0000000..a829e59
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/SoundTriggerSession.aidl
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+/**
+ * {@hide}
+ */
+parcelable SoundTriggerSession {
+    /** Interpreted as audio_session_t. */
+    int session;
+    /** Interpreted as audio_io_handle_t. */
+    int ioHandle;
+    /** Interpreted as audio_devices_t. */
+    int device;
+}
diff --git a/media/libaudioclient/include/media/AidlConversionUtil.h b/media/libaudioclient/include/media/AidlConversionUtil.h
index 9453673..bf2d800 100644
--- a/media/libaudioclient/include/media/AidlConversionUtil.h
+++ b/media/libaudioclient/include/media/AidlConversionUtil.h
@@ -111,6 +111,84 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
+// The code below establishes:
+// IntegralTypeOf<T>, which works for either integral types (in which case it evaluates to T), or
+// enum types (in which case it evaluates to std::underlying_type_T<T>).
+
+template<typename T, typename = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>>
+struct IntegralTypeOfStruct {
+    using Type = T;
+};
+
+template<typename T>
+struct IntegralTypeOfStruct<T, std::enable_if_t<std::is_enum_v<T>>> {
+    using Type = std::underlying_type_t<T>;
+};
+
+template<typename T>
+using IntegralTypeOf = typename IntegralTypeOfStruct<T>::Type;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Utilities for handling bitmasks.
+
+template<typename Enum>
+Enum indexToEnum_index(int index) {
+    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
+    return static_cast<Enum>(index);
+}
+
+template<typename Enum>
+Enum indexToEnum_bitmask(int index) {
+    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
+    return static_cast<Enum>(1 << index);
+}
+
+template<typename Mask, typename Enum>
+Mask enumToMask_bitmask(Enum e) {
+    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
+    static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);
+    return static_cast<Mask>(e);
+}
+
+template<typename Mask, typename Enum>
+Mask enumToMask_index(Enum e) {
+    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);
+    static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);
+    return static_cast<Mask>(static_cast<std::make_unsigned_t<IntegralTypeOf<Mask>>>(1)
+            << static_cast<int>(e));
+}
+
+template<typename DestMask, typename SrcMask, typename DestEnum, typename SrcEnum>
+ConversionResult<DestMask> convertBitmask(
+        SrcMask src, const std::function<ConversionResult<DestEnum>(SrcEnum)>& enumConversion,
+        const std::function<SrcEnum(int)>& srcIndexToEnum,
+        const std::function<DestMask(DestEnum)>& destEnumToMask) {
+    using UnsignedDestMask = std::make_unsigned_t<IntegralTypeOf<DestMask>>;
+    using UnsignedSrcMask = std::make_unsigned_t<IntegralTypeOf<SrcMask>>;
+
+    UnsignedDestMask dest = static_cast<UnsignedDestMask>(0);
+    UnsignedSrcMask usrc = static_cast<UnsignedSrcMask>(src);
+
+    int srcBitIndex = 0;
+    while (usrc != 0) {
+        if (usrc & 1) {
+            SrcEnum srcEnum = srcIndexToEnum(srcBitIndex);
+            DestEnum destEnum = VALUE_OR_RETURN(enumConversion(srcEnum));
+            DestMask destMask = destEnumToMask(destEnum);
+            dest |= destMask;
+        }
+        ++srcBitIndex;
+        usrc >>= 1;
+    }
+    return static_cast<DestMask>(dest);
+}
+
+template<typename Mask, typename Enum>
+bool bitmaskIsSet(Mask mask, Enum index) {
+    return (mask & enumToMask_index<Mask, Enum>(index)) != 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
 // Utilities for working with AIDL unions.
 // UNION_GET(obj, fieldname) returns a ConversionResult<T> containing either the strongly-typed
 //   value of the respective field, or BAD_VALUE if the union is not set to the requested field.
@@ -225,6 +303,7 @@
     return Status::fromServiceSpecificError(status, emptyIfNull);
 }
 
+
 } // namespace aidl_utils
 
 }  // namespace android
diff --git a/media/libaudioclient/include/media/AudioAttributes.h b/media/libaudioclient/include/media/AudioAttributes.h
index 001c629..24bd179 100644
--- a/media/libaudioclient/include/media/AudioAttributes.h
+++ b/media/libaudioclient/include/media/AudioAttributes.h
@@ -17,7 +17,9 @@
 
 #pragma once
 
+#include <android/media/AudioAttributesEx.h>
 #include <media/AudioCommonTypes.h>
+#include <media/AidlConversionUtil.h>
 #include <system/audio.h>
 #include <system/audio_policy.h>
 #include <binder/Parcelable.h>
@@ -57,4 +59,10 @@
     volume_group_t mGroupId = VOLUME_GROUP_NONE;
 };
 
+// AIDL conversion routines.
+ConversionResult<media::AudioAttributesEx>
+legacy2aidl_AudioAttributes_AudioAttributesEx(const AudioAttributes& legacy);
+ConversionResult<AudioAttributes>
+aidl2legacy_AudioAttributesEx_AudioAttributes(const media::AudioAttributesEx& aidl);
+
 } // namespace android
diff --git a/media/libaudioclient/include/media/AudioEffect.h b/media/libaudioclient/include/media/AudioEffect.h
index 8371711..0d18fb1 100644
--- a/media/libaudioclient/include/media/AudioEffect.h
+++ b/media/libaudioclient/include/media/AudioEffect.h
@@ -21,7 +21,6 @@
 #include <sys/types.h>
 
 #include <media/IAudioFlinger.h>
-#include <media/IAudioPolicyService.h>
 #include <media/AudioSystem.h>
 #include <system/audio_effect.h>
 
diff --git a/media/libaudioclient/include/media/AudioProductStrategy.h b/media/libaudioclient/include/media/AudioProductStrategy.h
index 7441095..b55b506 100644
--- a/media/libaudioclient/include/media/AudioProductStrategy.h
+++ b/media/libaudioclient/include/media/AudioProductStrategy.h
@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <android/media/AudioProductStrategy.h>
+#include <media/AidlConversionUtil.h>
 #include <media/AudioCommonTypes.h>
 #include <media/AudioAttributes.h>
 #include <system/audio.h>
@@ -62,5 +64,11 @@
 
 using AudioProductStrategyVector = std::vector<AudioProductStrategy>;
 
+// AIDL conversion routines.
+ConversionResult<media::AudioProductStrategy>
+legacy2aidl_AudioProductStrategy(const AudioProductStrategy& legacy);
+ConversionResult<AudioProductStrategy>
+aidl2legacy_AudioProductStrategy(const media::AudioProductStrategy& aidl);
+
 } // namespace android
 
diff --git a/media/libaudioclient/include/media/AudioSystem.h b/media/libaudioclient/include/media/AudioSystem.h
index 71b1e33..db4c28f 100644
--- a/media/libaudioclient/include/media/AudioSystem.h
+++ b/media/libaudioclient/include/media/AudioSystem.h
@@ -68,9 +68,12 @@
 typedef void (*routing_callback)();
 
 class IAudioFlinger;
-class IAudioPolicyService;
 class String8;
 
+namespace media {
+class IAudioPolicyService;
+}
+
 class AudioSystem
 {
 public:
@@ -308,7 +311,7 @@
 
     static status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index);
 
-    static uint32_t getStrategyForStream(audio_stream_type_t stream);
+    static product_strategy_t getStrategyForStream(audio_stream_type_t stream);
     static audio_devices_t getDevicesForStream(audio_stream_type_t stream);
     static status_t getDevicesForAttributes(const AudioAttributes &aa,
                                             AudioDeviceTypeAddrVector *devices);
@@ -316,7 +319,7 @@
     static audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc);
     static status_t registerEffect(const effect_descriptor_t *desc,
                                     audio_io_handle_t io,
-                                    uint32_t strategy,
+                                    product_strategy_t strategy,
                                     audio_session_t session,
                                     int id);
     static status_t unregisterEffect(int id);
@@ -327,7 +330,7 @@
     // and output configuration cache (gOutputs)
     static void clearAudioConfigCache();
 
-    static const sp<IAudioPolicyService> get_audio_policy_service();
+    static const sp<media::IAudioPolicyService> get_audio_policy_service();
 
     // helpers for android.media.AudioManager.getProperty(), see description there for meaning
     static uint32_t getPrimaryOutputSamplingRate();
@@ -337,7 +340,7 @@
 
     static status_t setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages);
 
-    static status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t flags);
+    static status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy);
 
     // Indicate if hw offload is possible for given format, stream type, sample rate,
     // bit rate, duration, video and streaming or offload property is enabled and when possible
@@ -667,7 +670,7 @@
     static audio_format_t gPrevInFormat;
     static audio_channel_mask_t gPrevInChannelMask;
 
-    static sp<IAudioPolicyService> gAudioPolicyService;
+    static sp<media::IAudioPolicyService> gAudioPolicyService;
 };
 
 };  // namespace android
diff --git a/media/libaudioclient/include/media/AudioVolumeGroup.h b/media/libaudioclient/include/media/AudioVolumeGroup.h
index 9a6ea07..946d58a 100644
--- a/media/libaudioclient/include/media/AudioVolumeGroup.h
+++ b/media/libaudioclient/include/media/AudioVolumeGroup.h
@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <android/media/AudioVolumeGroup.h>
+#include <media/AidlConversionUtil.h>
 #include <media/AudioProductStrategy.h>
 #include <system/audio.h>
 #include <system/audio_policy.h>
@@ -51,4 +53,10 @@
 
 using AudioVolumeGroupVector = std::vector<AudioVolumeGroup>;
 
+// AIDL conversion routines.
+ConversionResult<media::AudioVolumeGroup>
+legacy2aidl_AudioVolumeGroup(const AudioVolumeGroup& legacy);
+ConversionResult<AudioVolumeGroup>
+aidl2legacy_AudioVolumeGroup(const media::AudioVolumeGroup& aidl);
+
 } // namespace android
diff --git a/media/libaudioclient/include/media/IAudioPolicyService.h b/media/libaudioclient/include/media/IAudioPolicyService.h
deleted file mode 100644
index 3018364..0000000
--- a/media/libaudioclient/include/media/IAudioPolicyService.h
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
- * Copyright (C) 2009 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.
- */
-
-#ifndef ANDROID_IAUDIOPOLICYSERVICE_H
-#define ANDROID_IAUDIOPOLICYSERVICE_H
-
-#include <stdint.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <android/media/IAudioPolicyServiceClient.h>
-#include <binder/IInterface.h>
-#include <media/AudioDeviceTypeAddr.h>
-#include <media/AudioSystem.h>
-#include <media/AudioPolicy.h>
-#include <system/audio_policy.h>
-#include <utils/Errors.h>
-#include <utils/RefBase.h>
-#include <vector>
-
-namespace android {
-namespace media {
-// Must be pre-declared, or else there isn't a good way to generate a header
-// library.
-class ICaptureStateListener;
-}
-
-// ----------------------------------------------------------------------------
-
-class IAudioPolicyService : public IInterface
-{
-public:
-    DECLARE_META_INTERFACE(AudioPolicyService);
-
-    //
-    // IAudioPolicyService interface (see AudioPolicyInterface for method descriptions)
-    //
-    virtual void onNewAudioModulesAvailable() = 0;
-    virtual status_t setDeviceConnectionState(audio_devices_t device,
-                                              audio_policy_dev_state_t state,
-                                              const char *device_address,
-                                              const char *device_name,
-                                              audio_format_t encodedFormat) = 0;
-    virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device,
-                                                                  const char *device_address) = 0;
-    virtual status_t handleDeviceConfigChange(audio_devices_t device,
-                                              const char *device_address,
-                                              const char *device_name,
-                                              audio_format_t encodedFormat) = 0;
-    virtual status_t setPhoneState(audio_mode_t state, uid_t uid) = 0;
-    virtual status_t setForceUse(audio_policy_force_use_t usage,
-                                    audio_policy_forced_cfg_t config) = 0;
-    virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) = 0;
-    virtual audio_io_handle_t getOutput(audio_stream_type_t stream) = 0;
-    virtual status_t getOutputForAttr(audio_attributes_t *attr,
-                                      audio_io_handle_t *output,
-                                      audio_session_t session,
-                                      audio_stream_type_t *stream,
-                                      pid_t pid,
-                                      uid_t uid,
-                                      const audio_config_t *config,
-                                      audio_output_flags_t flags,
-                                      audio_port_handle_t *selectedDeviceId,
-                                      audio_port_handle_t *portId,
-                                      std::vector<audio_io_handle_t> *secondaryOutputs) = 0;
-    virtual status_t startOutput(audio_port_handle_t portId) = 0;
-    virtual status_t stopOutput(audio_port_handle_t portId) = 0;
-    virtual void releaseOutput(audio_port_handle_t portId) = 0;
-    virtual status_t  getInputForAttr(const audio_attributes_t *attr,
-                              audio_io_handle_t *input,
-                              audio_unique_id_t riid,
-                              audio_session_t session,
-                              pid_t pid,
-                              uid_t uid,
-                              const String16& opPackageName,
-                              const audio_config_base_t *config,
-                              audio_input_flags_t flags,
-                              audio_port_handle_t *selectedDeviceId,
-                              audio_port_handle_t *portId) = 0;
-    virtual status_t startInput(audio_port_handle_t portId) = 0;
-    virtual status_t stopInput(audio_port_handle_t portId) = 0;
-    virtual void releaseInput(audio_port_handle_t portId) = 0;
-    virtual status_t initStreamVolume(audio_stream_type_t stream,
-                                      int indexMin,
-                                      int indexMax) = 0;
-    virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
-                                          int index,
-                                          audio_devices_t device) = 0;
-    virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
-                                          int *index,
-                                          audio_devices_t device) = 0;
-
-    virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr,
-                                                 int index,
-                                                 audio_devices_t device) = 0;
-    virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr,
-                                                 int &index,
-                                                 audio_devices_t device) = 0;
-    virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index) = 0;
-
-    virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index) = 0;
-
-    virtual uint32_t getStrategyForStream(audio_stream_type_t stream) = 0;
-    virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) = 0;
-    virtual status_t getDevicesForAttributes(const AudioAttributes &aa,
-            AudioDeviceTypeAddrVector *devices) const = 0;
-    virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) = 0;
-    virtual status_t registerEffect(const effect_descriptor_t *desc,
-                                    audio_io_handle_t io,
-                                    uint32_t strategy,
-                                    audio_session_t session,
-                                    int id) = 0;
-    virtual status_t unregisterEffect(int id) = 0;
-    virtual status_t setEffectEnabled(int id, bool enabled) = 0;
-    virtual status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) = 0;
-    virtual bool     isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const = 0;
-    virtual bool     isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs = 0)
-                             const = 0;
-    virtual bool     isSourceActive(audio_source_t source) const = 0;
-    virtual status_t queryDefaultPreProcessing(audio_session_t audioSession,
-                                              effect_descriptor_t *descriptors,
-                                              uint32_t *count) = 0;
-    virtual status_t addSourceDefaultEffect(const effect_uuid_t *type,
-                                            const String16& opPackageName,
-                                            const effect_uuid_t *uuid,
-                                            int32_t priority,
-                                            audio_source_t source,
-                                            audio_unique_id_t* id) = 0;
-    virtual status_t addStreamDefaultEffect(const effect_uuid_t *type,
-                                            const String16& opPackageName,
-                                            const effect_uuid_t *uuid,
-                                            int32_t priority,
-                                            audio_usage_t usage,
-                                            audio_unique_id_t* id) = 0;
-    virtual status_t removeSourceDefaultEffect(audio_unique_id_t id) = 0;
-    virtual status_t removeStreamDefaultEffect(audio_unique_id_t id) = 0;
-    virtual status_t setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages) = 0;
-    virtual status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t flags) = 0;
-   // Check if offload is possible for given format, stream type, sample rate,
-    // bit rate, duration, video and streaming or offload property is enabled
-    virtual audio_offload_mode_t getOffloadSupport(const audio_offload_info_t& info) = 0;
-
-    // Check if direct playback is possible for given format, sample rate, channel mask and flags.
-    virtual bool isDirectOutputSupported(const audio_config_base_t& config,
-                                         const audio_attributes_t& attributes) = 0;
-
-    /* List available audio ports and their attributes */
-    virtual status_t listAudioPorts(audio_port_role_t role,
-                                    audio_port_type_t type,
-                                    unsigned int *num_ports,
-                                    struct audio_port_v7 *ports,
-                                    unsigned int *generation) = 0;
-
-    /* Get attributes for a given audio port */
-    virtual status_t getAudioPort(struct audio_port_v7 *port) = 0;
-
-    /* Create an audio patch between several source and sink ports */
-    virtual status_t createAudioPatch(const struct audio_patch *patch,
-                                       audio_patch_handle_t *handle) = 0;
-
-    /* Release an audio patch */
-    virtual status_t releaseAudioPatch(audio_patch_handle_t handle) = 0;
-
-    /* List existing audio patches */
-    virtual status_t listAudioPatches(unsigned int *num_patches,
-                                      struct audio_patch *patches,
-                                      unsigned int *generation) = 0;
-    /* Set audio port configuration */
-    virtual status_t setAudioPortConfig(const struct audio_port_config *config) = 0;
-
-    virtual void registerClient(const sp<media::IAudioPolicyServiceClient>& client) = 0;
-
-    virtual void setAudioPortCallbacksEnabled(bool enabled) = 0;
-
-    virtual void setAudioVolumeGroupCallbacksEnabled(bool enabled) = 0;
-
-    virtual status_t acquireSoundTriggerSession(audio_session_t *session,
-                                           audio_io_handle_t *ioHandle,
-                                           audio_devices_t *device) = 0;
-
-    virtual status_t releaseSoundTriggerSession(audio_session_t session) = 0;
-
-    virtual audio_mode_t getPhoneState() = 0;
-
-    virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration) = 0;
-
-    virtual status_t setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices)
-            = 0;
-
-    virtual status_t removeUidDeviceAffinities(uid_t uid) = 0;
-
-    virtual status_t setUserIdDeviceAffinities(int userId,
-            const AudioDeviceTypeAddrVector& devices) = 0;
-
-    virtual status_t removeUserIdDeviceAffinities(int userId) = 0;
-
-    virtual status_t startAudioSource(const struct audio_port_config *source,
-                                      const audio_attributes_t *attributes,
-                                      audio_port_handle_t *portId) = 0;
-    virtual status_t stopAudioSource(audio_port_handle_t portId) = 0;
-
-    virtual status_t setMasterMono(bool mono) = 0;
-    virtual status_t getMasterMono(bool *mono) = 0;
-    virtual float    getStreamVolumeDB(
-            audio_stream_type_t stream, int index, audio_devices_t device) = 0;
-
-    virtual status_t getSurroundFormats(unsigned int *numSurroundFormats,
-                                        audio_format_t *surroundFormats,
-                                        bool *surroundFormatsEnabled,
-                                        bool reported) = 0;
-    virtual status_t getHwOffloadEncodingFormatsSupportedForA2DP(
-                                        std::vector<audio_format_t> *formats) = 0;
-    virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled) = 0;
-
-    virtual status_t setAssistantUid(uid_t uid) = 0;
-    virtual status_t setA11yServicesUids(const std::vector<uid_t>& uids) = 0;
-    virtual status_t setCurrentImeUid(uid_t uid) = 0;
-
-    virtual bool     isHapticPlaybackSupported() = 0;
-    virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies) = 0;
-    virtual status_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
-                                                           product_strategy_t &productStrategy) = 0;
-
-    virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups) = 0;
-    virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
-                                                       volume_group_t &volumeGroup) = 0;
-
-    virtual status_t setRttEnabled(bool enabled) = 0;
-
-    virtual bool     isCallScreenModeSupported() = 0;
-
-    virtual status_t setDevicesRoleForStrategy(product_strategy_t strategy,
-                                               device_role_t role,
-                                               const AudioDeviceTypeAddrVector &devices) = 0;
-
-    virtual status_t removeDevicesRoleForStrategy(product_strategy_t strategy,
-                                                  device_role_t role) = 0;
-
-    virtual status_t getDevicesForRoleAndStrategy(product_strategy_t strategy,
-                                                  device_role_t role,
-                                                  AudioDeviceTypeAddrVector &devices) = 0;
-
-    virtual status_t setDevicesRoleForCapturePreset(audio_source_t audioSource,
-                                                    device_role_t role,
-                                                    const AudioDeviceTypeAddrVector &devices) = 0;
-
-    virtual status_t addDevicesRoleForCapturePreset(audio_source_t audioSource,
-                                                    device_role_t role,
-                                                    const AudioDeviceTypeAddrVector &devices) = 0;
-
-    virtual status_t removeDevicesRoleForCapturePreset(
-            audio_source_t audioSource, device_role_t role,
-            const AudioDeviceTypeAddrVector& devices) = 0;
-
-    virtual status_t clearDevicesRoleForCapturePreset(audio_source_t audioSource,
-                                                      device_role_t role) = 0;
-
-    virtual status_t getDevicesForRoleAndCapturePreset(audio_source_t audioSource,
-                                                       device_role_t role,
-                                                       AudioDeviceTypeAddrVector &devices) = 0;
-
-    // The return code here is only intended to represent transport errors. The
-    // actual server implementation should always return NO_ERROR.
-    virtual status_t registerSoundTriggerCaptureStateListener(
-        const sp<media::ICaptureStateListener>& listener,
-        bool* result) = 0;
-};
-
-
-// ----------------------------------------------------------------------------
-
-class BnAudioPolicyService : public BnInterface<IAudioPolicyService>
-{
-public:
-    virtual status_t    onTransact( uint32_t code,
-                                    const Parcel& data,
-                                    Parcel* reply,
-                                    uint32_t flags = 0);
-};
-
-// ----------------------------------------------------------------------------
-
-}; // namespace android
-
-#endif // ANDROID_IAUDIOPOLICYSERVICE_H
diff --git a/media/libaudioclient/include/media/PolicyAidlConversion.h b/media/libaudioclient/include/media/PolicyAidlConversion.h
new file mode 100644
index 0000000..873f27a
--- /dev/null
+++ b/media/libaudioclient/include/media/PolicyAidlConversion.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2021 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 <limits>
+#include <type_traits>
+
+#include <system/audio.h>
+
+#include <android/media/AudioMix.h>
+#include <android/media/AudioMixCallbackFlag.h>
+#include <android/media/AudioMixLatencyClass.h>
+#include <android/media/AudioMixRouteFlag.h>
+#include <android/media/AudioMixType.h>
+#include <android/media/AudioMode.h>
+#include <android/media/AudioOffloadMode.h>
+#include <android/media/AudioPolicyForceUse.h>
+#include <android/media/AudioPolicyForcedConfig.h>
+#include <android/media/DeviceRole.h>
+
+#include <media/AidlConversionUtil.h>
+#include <media/AudioCommonTypes.h>
+#include <media/AudioPolicy.h>
+#include <android/media/AudioPolicyDeviceState.h>
+
+namespace android {
+
+ConversionResult<volume_group_t>
+aidl2legacy_int32_t_volume_group_t(int32_t aidl);
+ConversionResult<int32_t>
+legacy2aidl_volume_group_t_int32_t(volume_group_t legacy);
+
+ConversionResult<product_strategy_t>
+aidl2legacy_int32_t_product_strategy_t(int32_t aidl);
+ConversionResult<int32_t>
+legacy2aidl_product_strategy_t_int32_t(product_strategy_t legacy);
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixType_uint32_t(media::AudioMixType aidl);
+ConversionResult<media::AudioMixType>
+legacy2aidl_uint32_t_AudioMixType(uint32_t legacy);
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixCallbackFlag_uint32_t(media::AudioMixCallbackFlag aidl);
+ConversionResult<media::AudioMixCallbackFlag>
+legacy2aidl_uint32_t_AudioMixCallbackFlag(uint32_t legacy);
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixCallbackFlag_uint32_t_mask(int32_t aidl);
+ConversionResult<int32_t>
+legacy2aidl_uint32_t_AudioMixCallbackFlag_mask(uint32_t legacy);
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixRouteFlag_uint32_t(media::AudioMixRouteFlag aidl);
+ConversionResult<media::AudioMixRouteFlag>
+legacy2aidl_uint32_t_AudioMixRouteFlag(uint32_t legacy);
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixRouteFlag_uint32_t_mask(int32_t aidl);
+ConversionResult<int32_t>
+legacy2aidl_uint32_t_AudioMixRouteFlag_mask(uint32_t legacy);
+
+ConversionResult<AudioMixMatchCriterion>
+aidl2legacy_AudioMixMatchCriterion(const media::AudioMixMatchCriterion& aidl);
+ConversionResult<media::AudioMixMatchCriterion>
+legacy2aidl_AudioMixMatchCriterion(const AudioMixMatchCriterion& legacy);
+
+ConversionResult<AudioMix>
+aidl2legacy_AudioMix(const media::AudioMix& aidl);
+ConversionResult<media::AudioMix>
+legacy2aidl_AudioMix(const AudioMix& legacy);
+
+ConversionResult<audio_policy_dev_state_t>
+aidl2legacy_AudioPolicyDeviceState_audio_policy_dev_state_t(media::AudioPolicyDeviceState aidl);
+ConversionResult<media::AudioPolicyDeviceState>
+legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(audio_policy_dev_state_t legacy);
+
+ConversionResult<audio_policy_force_use_t>
+aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(media::AudioPolicyForceUse aidl);
+ConversionResult<media::AudioPolicyForceUse>
+legacy2aidl_audio_policy_force_use_t_AudioPolicyForceUse(audio_policy_force_use_t legacy);
+
+ConversionResult<audio_policy_forced_cfg_t>
+aidl2legacy_AudioPolicyForcedConfig_audio_policy_forced_cfg_t(media::AudioPolicyForcedConfig aidl);
+ConversionResult<media::AudioPolicyForcedConfig>
+legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(audio_policy_forced_cfg_t legacy);
+
+ConversionResult<device_role_t>
+aidl2legacy_DeviceRole_device_role_t(media::DeviceRole aidl);
+ConversionResult<media::DeviceRole>
+legacy2aidl_device_role_t_DeviceRole(device_role_t legacy);
+
+ConversionResult<audio_offload_mode_t>
+aidl2legacy_AudioOffloadMode_audio_offload_mode_t(media::AudioOffloadMode aidl);
+ConversionResult<media::AudioOffloadMode>
+legacy2aidl_audio_offload_mode_t_AudioOffloadMode(audio_offload_mode_t legacy);
+
+}  // namespace android
diff --git a/media/libaudiofoundation/AudioDeviceTypeAddr.cpp b/media/libaudiofoundation/AudioDeviceTypeAddr.cpp
index 8f1e113..c5d7da8 100644
--- a/media/libaudiofoundation/AudioDeviceTypeAddr.cpp
+++ b/media/libaudiofoundation/AudioDeviceTypeAddr.cpp
@@ -15,13 +15,14 @@
  */
 
 #include <media/AudioDeviceTypeAddr.h>
-
 #include <arpa/inet.h>
 #include <iostream>
 #include <regex>
 #include <set>
 #include <sstream>
 
+#include <media/AidlConversion.h>
+
 namespace android {
 
 namespace {
diff --git a/media/libaudiofoundation/include/media/AudioDeviceTypeAddr.h b/media/libaudiofoundation/include/media/AudioDeviceTypeAddr.h
index 34da233..8edcc58 100644
--- a/media/libaudiofoundation/include/media/AudioDeviceTypeAddr.h
+++ b/media/libaudiofoundation/include/media/AudioDeviceTypeAddr.h
@@ -23,7 +23,7 @@
 #include <binder/Parcelable.h>
 #include <binder/Parcel.h>
 #include <media/AudioContainers.h>
-#include <media/AidlConversion.h>
+#include <media/AidlConversionUtil.h>
 #include <system/audio.h>
 #include <utils/Errors.h>
 
diff --git a/media/libmedia/CharacterEncodingDetector.cpp b/media/libmedia/CharacterEncodingDetector.cpp
index 5c6b981..64ba977 100644
--- a/media/libmedia/CharacterEncodingDetector.cpp
+++ b/media/libmedia/CharacterEncodingDetector.cpp
@@ -268,7 +268,7 @@
 
                 ucnv_convertEx(mUtf8Conv, conv, &target, target + targetLength,
                         &source, source + strlen(source),
-                        NULL, NULL, NULL, NULL, TRUE, TRUE, &status);
+                        NULL, NULL, NULL, NULL, true, true, &status);
 
                 if (U_FAILURE(status)) {
                     ALOGE("ucnv_convertEx failed: %d", status);
diff --git a/media/libmediatranscoding/TranscodingClientManager.cpp b/media/libmediatranscoding/TranscodingClientManager.cpp
index 87c984e..46d1da2 100644
--- a/media/libmediatranscoding/TranscodingClientManager.cpp
+++ b/media/libmediatranscoding/TranscodingClientManager.cpp
@@ -135,12 +135,12 @@
     } else if (in_clientUid < 0) {
         return Status::ok();
     } else if (in_clientUid != callingUid && !owner->isTrustedCaller(callingPid, callingUid)) {
-        ALOGE("MediaTranscodingService::registerClient rejected (clientPid %d, clientUid %d) "
+        ALOGE("submitRequest rejected (clientPid %d, clientUid %d) "
               "(don't trust callingUid %d)",
               in_clientPid, in_clientUid, callingUid);
         return STATUS_ERROR_FMT(
                 IMediaTranscodingService::ERROR_PERMISSION_DENIED,
-                "MediaTranscodingService::registerClient rejected (clientPid %d, clientUid %d) "
+                "submitRequest rejected (clientPid %d, clientUid %d) "
                 "(don't trust callingUid %d)",
                 in_clientPid, in_clientUid, callingUid);
     }
@@ -152,12 +152,12 @@
     } else if (in_clientPid < 0) {
         return Status::ok();
     } else if (in_clientPid != callingPid && !owner->isTrustedCaller(callingPid, callingUid)) {
-        ALOGE("MediaTranscodingService::registerClient rejected (clientPid %d, clientUid %d) "
+        ALOGE("submitRequest rejected (clientPid %d, clientUid %d) "
               "(don't trust callingUid %d)",
               in_clientPid, in_clientUid, callingUid);
         return STATUS_ERROR_FMT(
                 IMediaTranscodingService::ERROR_PERMISSION_DENIED,
-                "MediaTranscodingService::registerClient rejected (clientPid %d, clientUid %d) "
+                "submitRequest rejected (clientPid %d, clientUid %d) "
                 "(don't trust callingUid %d)",
                 in_clientPid, in_clientUid, callingUid);
     }
diff --git a/media/libmediatranscoding/aidl/android/media/TranscodingRequestParcel.aidl b/media/libmediatranscoding/aidl/android/media/TranscodingRequestParcel.aidl
index 4b19f6a..7047073 100644
--- a/media/libmediatranscoding/aidl/android/media/TranscodingRequestParcel.aidl
+++ b/media/libmediatranscoding/aidl/android/media/TranscodingRequestParcel.aidl
@@ -33,11 +33,25 @@
      */
     @utf8InCpp String sourceFilePath;
 
+    /*
+     * The filedescrptor of the sourceFilePath. If the source Fd is provided, transcoding service
+     * will use this fd instead of calling back to client side to open the sourceFilePath.
+     * -1 means not available.
+     */
+     int sourceFd = -1;
+
     /**
      * The absolute file path of the destination file.
      */
     @utf8InCpp String destinationFilePath;
 
+    /*
+     * The filedescrptor of the destinationFilePath. If the destination Fd is provided, transcoding
+     * service will use this fd instead of calling back to client side to open the sourceFilePath.
+     * -1 means not available.
+     */
+     int destinationFd = -1;
+
     /**
      * The UID of the client that this transcoding request is for. Only privileged caller could
      * set this Uid as only they could do the transcoding on behalf of the client.
diff --git a/media/libmediatranscoding/include/media/TranscodingRequest.h b/media/libmediatranscoding/include/media/TranscodingRequest.h
index 485403f..e782386 100644
--- a/media/libmediatranscoding/include/media/TranscodingRequest.h
+++ b/media/libmediatranscoding/include/media/TranscodingRequest.h
@@ -36,7 +36,9 @@
 private:
     void setTo(const TranscodingRequestParcel& parcel) {
         sourceFilePath = parcel.sourceFilePath;
+        sourceFd = parcel.sourceFd;
         destinationFilePath = parcel.destinationFilePath;
+        destinationFd = parcel.destinationFd;
         clientUid = parcel.clientUid;
         clientPid = parcel.clientPid;
         clientPackageName = parcel.clientPackageName;
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index b8257d3..dc2c171 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -31,7 +31,7 @@
 #include <sys/resource.h>
 #include <thread>
 
-
+#include <android/media/IAudioPolicyService.h>
 #include <android/os/IExternalVibratorService.h>
 #include <binder/IPCThreadState.h>
 #include <binder/IServiceManager.h>
@@ -42,7 +42,6 @@
 #include <media/audiohal/DevicesFactoryHalInterface.h>
 #include <media/audiohal/EffectsFactoryHalInterface.h>
 #include <media/AudioParameter.h>
-#include <media/IAudioPolicyService.h>
 #include <media/MediaMetricsItem.h>
 #include <media/TypeConverter.h>
 #include <mediautils/TimeCheck.h>
diff --git a/services/audioflinger/DeviceEffectManager.h b/services/audioflinger/DeviceEffectManager.h
index d187df2..a05f5fe 100644
--- a/services/audioflinger/DeviceEffectManager.h
+++ b/services/audioflinger/DeviceEffectManager.h
@@ -183,7 +183,7 @@
     void checkSuspendOnEffectEnabled(const sp<EffectBase>& effect __unused,
                           bool enabled __unused, bool threadLocked __unused) override {}
     void resetVolume() override {}
-    uint32_t strategy() const override  { return 0; }
+    product_strategy_t strategy() const override  { return static_cast<product_strategy_t>(0); }
     int32_t activeTrackCnt() const override { return 0; }
     void onEffectEnable(const sp<EffectBase>& effect __unused) override {}
     void onEffectDisable(const sp<EffectBase>& effect __unused) override {}
diff --git a/services/audioflinger/Effects.cpp b/services/audioflinger/Effects.cpp
index 56d32a6..392d339 100644
--- a/services/audioflinger/Effects.cpp
+++ b/services/audioflinger/Effects.cpp
@@ -238,7 +238,7 @@
     bool doEnable = false;
     bool enabled = false;
     audio_io_handle_t io = AUDIO_IO_HANDLE_NONE;
-    uint32_t strategy = PRODUCT_STRATEGY_NONE;
+    product_strategy_t strategy = PRODUCT_STRATEGY_NONE;
 
     {
         Mutex::Autolock _l(mLock);
@@ -2985,7 +2985,7 @@
 
 }
 
-uint32_t AudioFlinger::EffectChain::EffectCallback::strategy() const {
+product_strategy_t AudioFlinger::EffectChain::EffectCallback::strategy() const {
     sp<EffectChain> c = chain().promote();
     if (c == nullptr) {
         return PRODUCT_STRATEGY_NONE;
diff --git a/services/audioflinger/Effects.h b/services/audioflinger/Effects.h
index 139c049..8e82d53 100644
--- a/services/audioflinger/Effects.h
+++ b/services/audioflinger/Effects.h
@@ -59,7 +59,7 @@
     virtual bool updateOrphanEffectChains(const sp<EffectBase>& effect) = 0;
 
     // Methods usually implemented with help from EffectChain: pay attention to mutex locking order
-    virtual uint32_t strategy() const = 0;
+    virtual product_strategy_t strategy() const = 0;
     virtual int32_t activeTrackCnt() const = 0;
     virtual void resetVolume() = 0;
 
@@ -465,8 +465,8 @@
     void decActiveTrackCnt() { android_atomic_dec(&mActiveTrackCnt); }
     int32_t activeTrackCnt() const { return android_atomic_acquire_load(&mActiveTrackCnt); }
 
-    uint32_t strategy() const { return mStrategy; }
-    void setStrategy(uint32_t strategy)
+    product_strategy_t strategy() const { return mStrategy; }
+    void setStrategy(product_strategy_t strategy)
             { mStrategy = strategy; }
 
     // suspend or restore effects of the specified type. The number of suspend requests is counted
@@ -556,7 +556,7 @@
         void checkSuspendOnEffectEnabled(const sp<EffectBase>& effect,
                               bool enabled, bool threadLocked) override;
         void resetVolume() override;
-        uint32_t strategy() const override;
+        product_strategy_t strategy() const override;
         int32_t activeTrackCnt() const override;
         void onEffectEnable(const sp<EffectBase>& effect) override;
         void onEffectDisable(const sp<EffectBase>& effect) override;
@@ -626,7 +626,7 @@
              uint32_t mRightVolume;      // previous volume on right channel
              uint32_t mNewLeftVolume;       // new volume on left channel
              uint32_t mNewRightVolume;      // new volume on right channel
-             uint32_t mStrategy; // strategy for this effect chain
+             product_strategy_t mStrategy; // strategy for this effect chain
              // mSuspendedEffects lists all effects currently suspended in the chain.
              // Use effect type UUID timelow field as key. There is no real risk of identical
              // timeLow fields among effect type UUIDs.
@@ -706,7 +706,7 @@
         void checkSuspendOnEffectEnabled(const sp<EffectBase>& effect __unused,
                               bool enabled __unused, bool threadLocked __unused) override {}
         void resetVolume() override {}
-        uint32_t strategy() const override  { return 0; }
+        product_strategy_t strategy() const override  { return static_cast<product_strategy_t>(0); }
         int32_t activeTrackCnt() const override { return 0; }
         void onEffectEnable(const sp<EffectBase>& effect __unused) override {}
         void onEffectDisable(const sp<EffectBase>& effect __unused) override {}
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 7e1c67e..1f5b8d2 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -2345,11 +2345,11 @@
         // all tracks in same audio session must share the same routing strategy otherwise
         // conflicts will happen when tracks are moved from one output to another by audio policy
         // manager
-        uint32_t strategy = AudioSystem::getStrategyForStream(streamType);
+        product_strategy_t strategy = AudioSystem::getStrategyForStream(streamType);
         for (size_t i = 0; i < mTracks.size(); ++i) {
             sp<Track> t = mTracks[i];
             if (t != 0 && t->isExternalTrack()) {
-                uint32_t actual = AudioSystem::getStrategyForStream(t->streamType());
+                product_strategy_t actual = AudioSystem::getStrategyForStream(t->streamType());
                 if (sessionId == t->sessionId() && strategy != actual) {
                     ALOGE("createTrack_l() mismatched strategy; expected %u but found %u",
                             strategy, actual);
@@ -2999,7 +2999,7 @@
     }
 }
 
-uint32_t AudioFlinger::PlaybackThread::getStrategyForSession_l(audio_session_t sessionId)
+product_strategy_t AudioFlinger::PlaybackThread::getStrategyForSession_l(audio_session_t sessionId)
 {
     // session AUDIO_SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that
     // it is moved to correct output by audio policy manager when A2DP is connected or disconnected
diff --git a/services/audioflinger/Threads.h b/services/audioflinger/Threads.h
index cf4bb8a..c974252 100644
--- a/services/audioflinger/Threads.h
+++ b/services/audioflinger/Threads.h
@@ -435,8 +435,10 @@
 
                 // the value returned by default implementation is not important as the
                 // strategy is only meaningful for PlaybackThread which implements this method
-                virtual uint32_t getStrategyForSession_l(audio_session_t sessionId __unused)
-                        { return 0; }
+                virtual product_strategy_t getStrategyForSession_l(
+                        audio_session_t sessionId __unused) {
+                    return static_cast<product_strategy_t>(0);
+                }
 
                 // check if some effects must be suspended/restored when an effect is enabled
                 // or disabled
@@ -924,7 +926,7 @@
                         uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
                             return ThreadBase::hasAudioSession_l(sessionId, mTracks);
                         }
-                virtual uint32_t getStrategyForSession_l(audio_session_t sessionId);
+                virtual product_strategy_t getStrategyForSession_l(audio_session_t sessionId);
 
 
                 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
diff --git a/services/audiopolicy/AudioPolicyInterface.h b/services/audiopolicy/AudioPolicyInterface.h
index e52ad5e..630c423 100644
--- a/services/audiopolicy/AudioPolicyInterface.h
+++ b/services/audiopolicy/AudioPolicyInterface.h
@@ -191,7 +191,7 @@
                                                     int &index) = 0;
 
     // return the strategy corresponding to a given stream type
-    virtual uint32_t getStrategyForStream(audio_stream_type_t stream) = 0;
+    virtual product_strategy_t getStrategyForStream(audio_stream_type_t stream) = 0;
 
     // return the enabled output devices for the given stream type
     virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) = 0;
@@ -204,7 +204,7 @@
     virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) = 0;
     virtual status_t registerEffect(const effect_descriptor_t *desc,
                                     audio_io_handle_t io,
-                                    uint32_t strategy,
+                                    product_strategy_t strategy,
                                     int session,
                                     int id) = 0;
     virtual status_t unregisterEffect(int id) = 0;
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
index 65bae77..c0a8f9d 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
@@ -2852,7 +2852,7 @@
 
 status_t AudioPolicyManager::registerEffect(const effect_descriptor_t *desc,
                                 audio_io_handle_t io,
-                                uint32_t strategy,
+                                product_strategy_t strategy,
                                 int session,
                                 int id)
 {
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.h b/services/audiopolicy/managerdefault/AudioPolicyManager.h
index eba0c44..3c55b63 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.h
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.h
@@ -180,7 +180,7 @@
                                 const DeviceTypeSet& deviceTypes) const;
 
         // return the strategy corresponding to a given stream type
-        virtual uint32_t getStrategyForStream(audio_stream_type_t stream)
+        virtual product_strategy_t getStrategyForStream(audio_stream_type_t stream)
         {
             return streamToStrategy(stream);
         }
@@ -200,7 +200,7 @@
         virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc = NULL);
         virtual status_t registerEffect(const effect_descriptor_t *desc,
                                         audio_io_handle_t io,
-                                        uint32_t strategy,
+                                        product_strategy_t strategy,
                                         int session,
                                         int id);
         virtual status_t unregisterEffect(int id);
diff --git a/services/audiopolicy/service/Android.bp b/services/audiopolicy/service/Android.bp
index ceddb7e..8cb1b59 100644
--- a/services/audiopolicy/service/Android.bp
+++ b/services/audiopolicy/service/Android.bp
@@ -17,6 +17,7 @@
         "libaudioclient",
         "libaudioclient_aidl_conversion",
         "libaudiofoundation",
+        "libaudiopolicy",
         "libaudiopolicymanager",
         "libaudioutils",
         "libbinder",
@@ -32,7 +33,8 @@
         "audioclient-types-aidl-unstable-cpp",
         "audioflinger-aidl-unstable-cpp",
         "audiopolicy-aidl-unstable-cpp",
-        "capture_state_listener-aidl-cpp",
+        "audiopolicy-types-aidl-unstable-cpp",
+        "capture_state_listener-aidl-unstable-cpp",
     ],
 
     static_libs: [
diff --git a/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp b/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
index 66f9fbd..fed88a4 100644
--- a/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
+++ b/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
@@ -19,11 +19,29 @@
 
 #include "AudioPolicyService.h"
 #include "TypeConverter.h"
-#include <media/MediaMetricsItem.h>
+#include <media/AidlConversion.h>
 #include <media/AudioPolicy.h>
+#include <media/AudioValidator.h>
+#include <media/MediaMetricsItem.h>
+#include <media/PolicyAidlConversion.h>
 #include <utils/Log.h>
 
+#define VALUE_OR_RETURN_BINDER_STATUS(x) \
+    ({ auto _tmp = (x); \
+       if (!_tmp.ok()) return aidl_utils::binderStatusFromStatusT(_tmp.error()); \
+       std::move(_tmp.value()); })
+
+#define RETURN_IF_BINDER_ERROR(x)      \
+    {                                  \
+        binder::Status _tmp = (x);     \
+        if (!_tmp.isOk()) return _tmp; \
+    }
+
+#define MAX_ITEMS_PER_LIST 1024
+
 namespace android {
+using binder::Status;
+using aidl_utils::binderStatusFromStatusT;
 
 const std::vector<audio_usage_t>& SYSTEM_USAGES = {
     AUDIO_USAGE_CALL_ASSISTANT,
@@ -74,71 +92,94 @@
     mAudioPolicyManager->onNewAudioModulesAvailable();
 }
 
-status_t AudioPolicyService::setDeviceConnectionState(audio_devices_t device,
-                                                  audio_policy_dev_state_t state,
-                                                  const char *device_address,
-                                                  const char *device_name,
-                                                  audio_format_t encodedFormat)
-{
+Status AudioPolicyService::setDeviceConnectionState(
+        const media::AudioDevice& deviceAidl,
+        media::AudioPolicyDeviceState stateAidl,
+        const std::string& deviceNameAidl,
+        media::audio::common::AudioFormat encodedFormatAidl) {
+    audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_devices_t(deviceAidl.type));
+    audio_policy_dev_state_t state = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioPolicyDeviceState_audio_policy_dev_state_t(stateAidl));
+    audio_format_t encodedFormat = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioFormat_audio_format_t(encodedFormatAidl));
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     if (!settingsAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
     if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE &&
             state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
-        return BAD_VALUE;
+        return binderStatusFromStatusT(BAD_VALUE);
     }
 
     ALOGV("setDeviceConnectionState()");
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->setDeviceConnectionState(device, state,
-                                                         device_address, device_name, encodedFormat);
+    return binderStatusFromStatusT(
+            mAudioPolicyManager->setDeviceConnectionState(device, state,
+                                                          deviceAidl.address.c_str(),
+                                                          deviceNameAidl.c_str(),
+                                                          encodedFormat));
 }
 
-audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState(
-                                                              audio_devices_t device,
-                                                              const char *device_address)
-{
+Status AudioPolicyService::getDeviceConnectionState(const media::AudioDevice& deviceAidl,
+                                                    media::AudioPolicyDeviceState* _aidl_return) {
+    audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_devices_t(deviceAidl.type));
     if (mAudioPolicyManager == NULL) {
-        return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
+        *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+                legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(
+                        AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
+        return Status::ok();
     }
     AutoCallerClear acc;
-    return mAudioPolicyManager->getDeviceConnectionState(device,
-                                                      device_address);
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(
+                    mAudioPolicyManager->getDeviceConnectionState(device,
+                                                                  deviceAidl.address.c_str())));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::handleDeviceConfigChange(audio_devices_t device,
-                                                  const char *device_address,
-                                                  const char *device_name,
-                                                  audio_format_t encodedFormat)
-{
+Status AudioPolicyService::handleDeviceConfigChange(
+        const media::AudioDevice& deviceAidl,
+        const std::string& deviceNameAidl,
+        media::audio::common::AudioFormat encodedFormatAidl) {
+    audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_devices_t(deviceAidl.type));
+    audio_format_t encodedFormat = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioFormat_audio_format_t(encodedFormatAidl));
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     if (!settingsAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
 
     ALOGV("handleDeviceConfigChange()");
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->handleDeviceConfigChange(device, device_address,
-                                                         device_name, encodedFormat);
+    return binderStatusFromStatusT(
+            mAudioPolicyManager->handleDeviceConfigChange(device, deviceAidl.address.c_str(),
+                                                          deviceNameAidl.c_str(), encodedFormat));
 }
 
-status_t AudioPolicyService::setPhoneState(audio_mode_t state, uid_t uid)
+Status AudioPolicyService::setPhoneState(media::AudioMode stateAidl, int32_t uidAidl)
 {
+    audio_mode_t state = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioMode_audio_mode_t(stateAidl));
+    uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     if (!settingsAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
     if (uint32_t(state) >= AUDIO_MODE_CNT) {
-        return BAD_VALUE;
+        return binderStatusFromStatusT(BAD_VALUE);
     }
 
     ALOGV("setPhoneState()");
@@ -154,85 +195,116 @@
     mAudioPolicyManager->setPhoneState(state);
     mPhoneState = state;
     mPhoneStateOwnerUid = uid;
-    return NO_ERROR;
+    return Status::ok();
 }
 
-audio_mode_t AudioPolicyService::getPhoneState()
-{
+Status AudioPolicyService::getPhoneState(media::AudioMode* _aidl_return) {
     Mutex::Autolock _l(mLock);
-    return mPhoneState;
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_mode_t_AudioMode(mPhoneState));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage,
-                                         audio_policy_forced_cfg_t config)
+Status AudioPolicyService::setForceUse(media::AudioPolicyForceUse usageAidl,
+                                       media::AudioPolicyForcedConfig configAidl)
 {
+    audio_policy_force_use_t usage = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(usageAidl));
+    audio_policy_forced_cfg_t config = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioPolicyForcedConfig_audio_policy_forced_cfg_t(configAidl));
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
 
     if (!modifyAudioRoutingAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
 
     if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
-        return BAD_VALUE;
+        return binderStatusFromStatusT(BAD_VALUE);
     }
     if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) {
-        return BAD_VALUE;
+        return binderStatusFromStatusT(BAD_VALUE);
     }
     ALOGV("setForceUse()");
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
     mAudioPolicyManager->setForceUse(usage, config);
-    return NO_ERROR;
+    return Status::ok();
 }
 
-audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage)
-{
+Status AudioPolicyService::getForceUse(media::AudioPolicyForceUse usageAidl,
+                                       media::AudioPolicyForcedConfig* _aidl_return) {
+    audio_policy_force_use_t usage = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(usageAidl));
+
     if (mAudioPolicyManager == NULL) {
-        return AUDIO_POLICY_FORCE_NONE;
+        return binderStatusFromStatusT(NO_INIT);
     }
     if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
-        return AUDIO_POLICY_FORCE_NONE;
+        *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(AUDIO_POLICY_FORCE_NONE));
+        return Status::ok();
     }
     AutoCallerClear acc;
-    return mAudioPolicyManager->getForceUse(usage);
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(
+                    mAudioPolicyManager->getForceUse(usage)));
+    return Status::ok();
 }
 
-audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream)
+Status AudioPolicyService::getOutput(media::AudioStreamType streamAidl, int32_t* _aidl_return)
 {
+    audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+
     if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
-        return AUDIO_IO_HANDLE_NONE;
+        *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_audio_io_handle_t_int32_t(AUDIO_IO_HANDLE_NONE));
+        return Status::ok();
     }
     if (mAudioPolicyManager == NULL) {
-        return AUDIO_IO_HANDLE_NONE;
+        return binderStatusFromStatusT(NO_INIT);
     }
     ALOGV("getOutput()");
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->getOutput(stream);
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_audio_io_handle_t_int32_t(mAudioPolicyManager->getOutput(stream)));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::getOutputForAttr(audio_attributes_t *attr,
-                                              audio_io_handle_t *output,
-                                              audio_session_t session,
-                                              audio_stream_type_t *stream,
-                                              pid_t pid,
-                                              uid_t uid,
-                                              const audio_config_t *config,
-                                              audio_output_flags_t flags,
-                                              audio_port_handle_t *selectedDeviceId,
-                                              audio_port_handle_t *portId,
-                                              std::vector<audio_io_handle_t> *secondaryOutputs)
+Status AudioPolicyService::getOutputForAttr(const media::AudioAttributesInternal& attrAidl,
+                                            int32_t sessionAidl,
+                                            int32_t pidAidl,
+                                            int32_t uidAidl,
+                                            const media::AudioConfig& configAidl,
+                                            int32_t flagsAidl,
+                                            media::GetOutputForAttrResponse* _aidl_return)
 {
+    audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
+    audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_session_t(sessionAidl));
+    audio_stream_type_t stream = AUDIO_STREAM_DEFAULT;
+    pid_t pid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_pid_t(pidAidl));
+    uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
+    audio_config_t config = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioConfig_audio_config_t(configAidl));
+    audio_output_flags_t flags = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_output_flags_t_mask(flagsAidl));
+    audio_io_handle_t output;
+    audio_port_handle_t selectedDeviceId;
+    audio_port_handle_t portId;
+    std::vector<audio_io_handle_t> secondaryOutputs;
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
 
-    status_t result = validateUsage(attr->usage, pid, uid);
-    if (result != NO_ERROR) {
-        return result;
-    }
+    RETURN_IF_BINDER_ERROR(
+            binderStatusFromStatusT(AudioValidator::validateAudioAttributes(attr, "68953950")));
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attr.usage, pid, uid)));
 
     ALOGV("%s()", __func__);
     Mutex::Autolock _l(mLock);
@@ -244,20 +316,22 @@
         uid = callingUid;
     }
     if (!mPackageManager.allowPlaybackCapture(uid)) {
-        attr->flags = static_cast<audio_flags_mask_t>(attr->flags | AUDIO_FLAG_NO_MEDIA_PROJECTION);
+        attr.flags = static_cast<audio_flags_mask_t>(attr.flags | AUDIO_FLAG_NO_MEDIA_PROJECTION);
     }
-    if (((attr->flags & (AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE)) != 0)
+    if (((attr.flags & (AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE)) != 0)
             && !bypassInterruptionPolicyAllowed(pid, uid)) {
-        attr->flags = static_cast<audio_flags_mask_t>(
-                attr->flags & ~(AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE));
+        attr.flags = static_cast<audio_flags_mask_t>(
+                attr.flags & ~(AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE));
     }
     AutoCallerClear acc;
     AudioPolicyInterface::output_type_t outputType;
-    result = mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid,
-                                                 config,
-                                                 &flags, selectedDeviceId, portId,
-                                                 secondaryOutputs,
-                                                 &outputType);
+    status_t result = mAudioPolicyManager->getOutputForAttr(&attr, &output, session,
+                                                            &stream,
+                                                            uid,
+                                                            &config,
+                                                            &flags, &selectedDeviceId, &portId,
+                                                            &secondaryOutputs,
+                                                            &outputType);
 
     // FIXME: Introduce a way to check for the the telephony device before opening the output
     if (result == NO_ERROR) {
@@ -287,11 +361,24 @@
     }
 
     if (result == NO_ERROR) {
-        sp <AudioPlaybackClient> client =
-            new AudioPlaybackClient(*attr, *output, uid, pid, session, *portId, *selectedDeviceId, *stream);
-        mAudioPlaybackClients.add(*portId, client);
+        sp<AudioPlaybackClient> client =
+                new AudioPlaybackClient(attr, output, uid, pid, session, portId, selectedDeviceId,
+                                        stream);
+        mAudioPlaybackClients.add(portId, client);
+
+        _aidl_return->output = VALUE_OR_RETURN_BINDER_STATUS(
+                legacy2aidl_audio_io_handle_t_int32_t(output));
+        _aidl_return->stream = VALUE_OR_RETURN_BINDER_STATUS(
+                legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+        _aidl_return->selectedDeviceId = VALUE_OR_RETURN_BINDER_STATUS(
+                legacy2aidl_audio_port_handle_t_int32_t(selectedDeviceId));
+        _aidl_return->portId = VALUE_OR_RETURN_BINDER_STATUS(
+                legacy2aidl_audio_port_handle_t_int32_t(portId));
+        _aidl_return->secondaryOutputs = VALUE_OR_RETURN_BINDER_STATUS(
+                convertContainer<std::vector<int32_t>>(secondaryOutputs,
+                                                       legacy2aidl_audio_io_handle_t_int32_t));
     }
-    return result;
+    return binderStatusFromStatusT(result);
 }
 
 void AudioPolicyService::getPlaybackClientAndEffects(audio_port_handle_t portId,
@@ -309,10 +396,12 @@
     effects = mAudioPolicyEffects;
 }
 
-status_t AudioPolicyService::startOutput(audio_port_handle_t portId)
+Status AudioPolicyService::startOutput(int32_t portIdAidl)
 {
+    audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     ALOGV("startOutput()");
     sp<AudioPlaybackClient> client;
@@ -334,17 +423,19 @@
     if (status == NO_ERROR) {
         client->active = true;
     }
-    return status;
+    return binderStatusFromStatusT(status);
 }
 
-status_t AudioPolicyService::stopOutput(audio_port_handle_t portId)
+Status AudioPolicyService::stopOutput(int32_t portIdAidl)
 {
+    audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     ALOGV("stopOutput()");
     mOutputCommandThread->stopOutputCommand(portId);
-    return NO_ERROR;
+    return Status::ok();
 }
 
 status_t  AudioPolicyService::doStopOutput(audio_port_handle_t portId)
@@ -372,13 +463,16 @@
     return status;
 }
 
-void AudioPolicyService::releaseOutput(audio_port_handle_t portId)
+Status AudioPolicyService::releaseOutput(int32_t portIdAidl)
 {
+    audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
     if (mAudioPolicyManager == NULL) {
-        return;
+        return binderStatusFromStatusT(NO_INIT);
     }
     ALOGV("releaseOutput()");
     mOutputCommandThread->releaseOutputCommand(portId);
+    return Status::ok();
 }
 
 void AudioPolicyService::doReleaseOutput(audio_port_handle_t portId)
@@ -401,28 +495,44 @@
     mAudioPolicyManager->releaseOutput(portId);
 }
 
-status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr,
-                                             audio_io_handle_t *input,
-                                             audio_unique_id_t riid,
-                                             audio_session_t session,
-                                             pid_t pid,
-                                             uid_t uid,
-                                             const String16& opPackageName,
-                                             const audio_config_base_t *config,
-                                             audio_input_flags_t flags,
-                                             audio_port_handle_t *selectedDeviceId,
-                                             audio_port_handle_t *portId)
-{
+Status AudioPolicyService::getInputForAttr(const media::AudioAttributesInternal& attrAidl,
+                                           int32_t inputAidl,
+                                           int32_t riidAidl,
+                                           int32_t sessionAidl,
+                                           int32_t pidAidl,
+                                           int32_t uidAidl,
+                                           const std::string& opPackageNameAidl,
+                                           const media::AudioConfigBase& configAidl,
+                                           int32_t flagsAidl,
+                                           media::GetInputForAttrResponse* _aidl_return) {
+    audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
+    audio_io_handle_t input = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_io_handle_t(inputAidl));
+    audio_unique_id_t riid = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_unique_id_t(riidAidl));
+    audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_session_t(sessionAidl));
+    pid_t pid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_pid_t(pidAidl));
+    uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
+    String16 opPackageName = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_string_view_String16(opPackageNameAidl));
+    audio_config_base_t config = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioConfigBase_audio_config_base_t(configAidl));
+    audio_input_flags_t flags = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_input_flags_t_mask(flagsAidl));
+    audio_port_handle_t selectedDeviceId;
+    audio_port_handle_t portId;
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
 
-    status_t result = validateUsage(attr->usage, pid, uid);
-    if (result != NO_ERROR) {
-        return result;
-    }
+    RETURN_IF_BINDER_ERROR(
+            binderStatusFromStatusT(AudioValidator::validateAudioAttributes(attr, "68953950")));
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attr.usage, pid, uid)));
 
-    audio_source_t inputSource = attr->source;
+    audio_source_t inputSource = attr.source;
     if (inputSource == AUDIO_SOURCE_DEFAULT) {
         inputSource = AUDIO_SOURCE_MIC;
     }
@@ -433,7 +543,7 @@
                 && inputSource != AUDIO_SOURCE_HOTWORD
                 && inputSource != AUDIO_SOURCE_FM_TUNER
                 && inputSource != AUDIO_SOURCE_ECHO_REFERENCE)) {
-        return BAD_VALUE;
+        return binderStatusFromStatusT(BAD_VALUE);
     }
 
     bool updatePid = (pid == -1);
@@ -457,10 +567,10 @@
     // Capturing from FM_TUNER source is controlled by captureTunerAudioInputAllowed() and
     // captureAudioOutputAllowed() (deprecated) as this does not affect users privacy
     // as does capturing from an actual microphone.
-    if (!(recordingAllowed(opPackageName, pid, uid) || attr->source == AUDIO_SOURCE_FM_TUNER)) {
+    if (!(recordingAllowed(opPackageName, pid, uid) || attr.source == AUDIO_SOURCE_FM_TUNER)) {
         ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
                 __func__, uid, pid);
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
 
     bool canCaptureOutput = captureAudioOutputAllowed(pid, uid);
@@ -469,18 +579,18 @@
         inputSource == AUDIO_SOURCE_VOICE_CALL ||
         inputSource == AUDIO_SOURCE_ECHO_REFERENCE)
         && !canCaptureOutput) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
 
     if (inputSource == AUDIO_SOURCE_FM_TUNER
         && !captureTunerAudioInputAllowed(pid, uid)
         && !canCaptureOutput) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
 
     bool canCaptureHotword = captureHotwordAllowed(opPackageName, pid, uid);
     if ((inputSource == AUDIO_SOURCE_HOTWORD) && !canCaptureHotword) {
-        return BAD_VALUE;
+        return binderStatusFromStatusT(BAD_VALUE);
     }
 
     sp<AudioPolicyEffects>audioPolicyEffects;
@@ -492,10 +602,10 @@
         {
             AutoCallerClear acc;
             // the audio_in_acoustics_t parameter is ignored by get_input()
-            status = mAudioPolicyManager->getInputForAttr(attr, input, riid, session, uid,
-                                                         config,
-                                                         flags, selectedDeviceId,
-                                                         &inputType, portId);
+            status = mAudioPolicyManager->getInputForAttr(&attr, &input, riid, session, uid,
+                                                          &config,
+                                                          flags, &selectedDeviceId,
+                                                          &inputType, &portId);
         }
         audioPolicyEffects = mAudioPolicyEffects;
 
@@ -531,25 +641,32 @@
         if (status != NO_ERROR) {
             if (status == PERMISSION_DENIED) {
                 AutoCallerClear acc;
-                mAudioPolicyManager->releaseInput(*portId);
+                mAudioPolicyManager->releaseInput(portId);
             }
-            return status;
+            return binderStatusFromStatusT(status);
         }
 
-        sp<AudioRecordClient> client = new AudioRecordClient(*attr, *input, uid, pid, session, *portId,
-                                                             *selectedDeviceId, opPackageName,
+        sp<AudioRecordClient> client = new AudioRecordClient(attr, input, uid, pid, session, portId,
+                                                             selectedDeviceId, opPackageName,
                                                              canCaptureOutput, canCaptureHotword);
-        mAudioRecordClients.add(*portId, client);
+        mAudioRecordClients.add(portId, client);
     }
 
     if (audioPolicyEffects != 0) {
         // create audio pre processors according to input source
-        status_t status = audioPolicyEffects->addInputEffects(*input, inputSource, session);
+        status_t status = audioPolicyEffects->addInputEffects(input, inputSource, session);
         if (status != NO_ERROR && status != ALREADY_EXISTS) {
-            ALOGW("Failed to add effects on input %d", *input);
+            ALOGW("Failed to add effects on input %d", input);
         }
     }
-    return NO_ERROR;
+
+    _aidl_return->input = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_audio_io_handle_t_int32_t(input));
+    _aidl_return->selectedDeviceId = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_audio_port_handle_t_int32_t(selectedDeviceId));
+    _aidl_return->portId = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_audio_port_handle_t_int32_t(portId));
+    return Status::ok();
 }
 
 std::string AudioPolicyService::getDeviceTypeStrForPortId(audio_port_handle_t portId) {
@@ -562,10 +679,13 @@
     return {};
 }
 
-status_t AudioPolicyService::startInput(audio_port_handle_t portId)
+Status AudioPolicyService::startInput(int32_t portIdAidl)
 {
+    audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     sp<AudioRecordClient> client;
     {
@@ -573,7 +693,7 @@
 
         ssize_t index = mAudioRecordClients.indexOfKey(portId);
         if (index < 0) {
-            return INVALID_OPERATION;
+            return binderStatusFromStatusT(INVALID_OPERATION);
         }
         client = mAudioRecordClients.valueAt(index);
     }
@@ -584,7 +704,7 @@
             || client->attributes.source == AUDIO_SOURCE_FM_TUNER)) {
         ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
                 __func__, client->uid, client->pid);
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
 
     Mutex::Autolock _l(mLock);
@@ -672,20 +792,23 @@
                         client->attributes.source);
     }
 
-    return status;
+    return binderStatusFromStatusT(status);
 }
 
-status_t AudioPolicyService::stopInput(audio_port_handle_t portId)
+Status AudioPolicyService::stopInput(int32_t portIdAidl)
 {
+    audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
 
     Mutex::Autolock _l(mLock);
 
     ssize_t index = mAudioRecordClients.indexOfKey(portId);
     if (index < 0) {
-        return INVALID_OPERATION;
+        return binderStatusFromStatusT(INVALID_OPERATION);
     }
     sp<AudioRecordClient> client = mAudioRecordClients.valueAt(index);
 
@@ -698,13 +821,16 @@
     finishRecording(client->opPackageName, client->uid,
                     client->attributes.source);
     AutoCallerClear acc;
-    return mAudioPolicyManager->stopInput(portId);
+    return binderStatusFromStatusT(mAudioPolicyManager->stopInput(portId));
 }
 
-void AudioPolicyService::releaseInput(audio_port_handle_t portId)
+Status AudioPolicyService::releaseInput(int32_t portIdAidl)
 {
+    audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
+
     if (mAudioPolicyManager == NULL) {
-        return;
+        return binderStatusFromStatusT(NO_INIT);
     }
     sp<AudioPolicyEffects>audioPolicyEffects;
     sp<AudioRecordClient> client;
@@ -713,7 +839,7 @@
         audioPolicyEffects = mAudioPolicyEffects;
         ssize_t index = mAudioRecordClients.indexOfKey(portId);
         if (index < 0) {
-            return;
+            return Status::ok();
         }
         client = mAudioRecordClients.valueAt(index);
 
@@ -727,7 +853,7 @@
         mAudioRecordClients.removeItem(portId);
     }
     if (client == 0) {
-        return;
+        return Status::ok();
     }
     if (audioPolicyEffects != 0) {
         // release audio processors from the input
@@ -741,239 +867,354 @@
         AutoCallerClear acc;
         mAudioPolicyManager->releaseInput(portId);
     }
+    return Status::ok();
 }
 
-status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream,
-                                            int indexMin,
-                                            int indexMax)
-{
+Status AudioPolicyService::initStreamVolume(media::AudioStreamType streamAidl,
+                                            int32_t indexMinAidl,
+                                            int32_t indexMaxAidl) {
+    audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+    int indexMin = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexMinAidl));
+    int indexMax = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexMaxAidl));
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     if (!settingsAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
     if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
-        return BAD_VALUE;
+        return binderStatusFromStatusT(BAD_VALUE);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
     mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax);
-    return NO_ERROR;
+    return binderStatusFromStatusT(NO_ERROR);
 }
 
-status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,
-                                                  int index,
-                                                  audio_devices_t device)
-{
+Status AudioPolicyService::setStreamVolumeIndex(media::AudioStreamType streamAidl,
+                                                int32_t deviceAidl, int32_t indexAidl) {
+    audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+    int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
+    audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_devices_t(deviceAidl));
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     if (!settingsAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
     if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
-        return BAD_VALUE;
+        return binderStatusFromStatusT(BAD_VALUE);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->setStreamVolumeIndex(stream,
-                                                    index,
-                                                    device);
+    return binderStatusFromStatusT(mAudioPolicyManager->setStreamVolumeIndex(stream,
+                                                                             index,
+                                                                             device));
 }
 
-status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream,
-                                                  int *index,
-                                                  audio_devices_t device)
-{
+Status AudioPolicyService::getStreamVolumeIndex(media::AudioStreamType streamAidl,
+                                                int32_t deviceAidl, int32_t* _aidl_return) {
+    audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+    audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_devices_t(deviceAidl));
+    int index;
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
-        return BAD_VALUE;
+        return binderStatusFromStatusT(BAD_VALUE);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->getStreamVolumeIndex(stream,
-                                                    index,
-                                                    device);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            mAudioPolicyManager->getStreamVolumeIndex(stream, &index, device)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::setVolumeIndexForAttributes(const audio_attributes_t &attributes,
-                                                         int index, audio_devices_t device)
-{
+Status AudioPolicyService::setVolumeIndexForAttributes(
+        const media::AudioAttributesInternal& attrAidl, int32_t deviceAidl, int32_t indexAidl) {
+    audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
+    int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
+    audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_devices_t(deviceAidl));
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            AudioValidator::validateAudioAttributes(attributes, "169572641")));
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     if (!settingsAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->setVolumeIndexForAttributes(attributes, index, device);
+    return binderStatusFromStatusT(
+            mAudioPolicyManager->setVolumeIndexForAttributes(attributes, index, device));
 }
 
-status_t AudioPolicyService::getVolumeIndexForAttributes(const audio_attributes_t &attributes,
-                                                         int &index, audio_devices_t device)
-{
+Status AudioPolicyService::getVolumeIndexForAttributes(
+        const media::AudioAttributesInternal& attrAidl, int32_t deviceAidl, int32_t* _aidl_return) {
+    audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
+    audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_devices_t(deviceAidl));
+    int index;
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            AudioValidator::validateAudioAttributes(attributes, "169572641")));
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->getVolumeIndexForAttributes(attributes, index, device);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            mAudioPolicyManager->getVolumeIndexForAttributes(attributes, index, device)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::getMinVolumeIndexForAttributes(const audio_attributes_t &attributes,
-                                                            int &index)
-{
+Status AudioPolicyService::getMinVolumeIndexForAttributes(
+        const media::AudioAttributesInternal& attrAidl, int32_t* _aidl_return) {
+    audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
+    int index;
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            AudioValidator::validateAudioAttributes(attributes, "169572641")));
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->getMinVolumeIndexForAttributes(attributes, index);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            mAudioPolicyManager->getMinVolumeIndexForAttributes(attributes, index)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::getMaxVolumeIndexForAttributes(const audio_attributes_t &attributes,
-                                                            int &index)
-{
+Status AudioPolicyService::getMaxVolumeIndexForAttributes(
+        const media::AudioAttributesInternal& attrAidl, int32_t* _aidl_return) {
+    audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
+    int index;
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            AudioValidator::validateAudioAttributes(attributes, "169572641")));
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->getMaxVolumeIndexForAttributes(attributes, index);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            mAudioPolicyManager->getMaxVolumeIndexForAttributes(attributes, index)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
+    return Status::ok();
 }
 
-uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream)
-{
+Status AudioPolicyService::getStrategyForStream(media::AudioStreamType streamAidl,
+                                                int32_t* _aidl_return) {
+    audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+
     if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
-        return PRODUCT_STRATEGY_NONE;
+        *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+                convertReinterpret<int32_t>(PRODUCT_STRATEGY_NONE));
+        return Status::ok();
     }
     if (mAudioPolicyManager == NULL) {
-        return PRODUCT_STRATEGY_NONE;
+        return binderStatusFromStatusT(NO_INIT);
     }
+
     // DO NOT LOCK, may be called from AudioFlinger with lock held, reaching deadlock
     AutoCallerClear acc;
-    return mAudioPolicyManager->getStrategyForStream(stream);
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_product_strategy_t_int32_t(
+                    mAudioPolicyManager->getStrategyForStream(stream)));
+    return Status::ok();
 }
 
 //audio policy: use audio_device_t appropriately
 
-audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream)
-{
+Status AudioPolicyService::getDevicesForStream(media::AudioStreamType streamAidl,
+                                               int32_t* _aidl_return) {
+    audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+
     if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
-        return AUDIO_DEVICE_NONE;
+        *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+                legacy2aidl_audio_devices_t_int32_t(AUDIO_DEVICE_NONE));
+        return Status::ok();
     }
     if (mAudioPolicyManager == NULL) {
-        return AUDIO_DEVICE_NONE;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->getDevicesForStream(stream);
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_audio_devices_t_int32_t(mAudioPolicyManager->getDevicesForStream(stream)));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::getDevicesForAttributes(const AudioAttributes &aa,
-                                                     AudioDeviceTypeAddrVector *devices) const
+Status AudioPolicyService::getDevicesForAttributes(const media::AudioAttributesEx& attrAidl,
+                                                   std::vector<media::AudioDevice>* _aidl_return)
 {
+    AudioAttributes aa = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioAttributesEx_AudioAttributes(attrAidl));
+    AudioDeviceTypeAddrVector devices;
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->getDevicesForAttributes(aa.getAttributes(), devices);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            mAudioPolicyManager->getDevicesForAttributes(aa.getAttributes(), &devices)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            convertContainer<std::vector<media::AudioDevice>>(devices,
+                                                              legacy2aidl_AudioDeviceTypeAddress));
+    return Status::ok();
 }
 
-audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc)
-{
-    // FIXME change return type to status_t, and return NO_INIT here
+Status AudioPolicyService::getOutputForEffect(const media::EffectDescriptor& descAidl,
+                                              int32_t* _aidl_return) {
+    effect_descriptor_t desc = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_EffectDescriptor_effect_descriptor_t(descAidl));
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            AudioValidator::validateEffectDescriptor(desc, "73126106")));
+
     if (mAudioPolicyManager == NULL) {
-        return 0;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->getOutputForEffect(desc);
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_audio_io_handle_t_int32_t(mAudioPolicyManager->getOutputForEffect(&desc)));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc,
-                                audio_io_handle_t io,
-                                uint32_t strategy,
-                                audio_session_t session,
-                                int id)
-{
+Status AudioPolicyService::registerEffect(const media::EffectDescriptor& descAidl, int32_t ioAidl,
+                                          int32_t strategyAidl, int32_t sessionAidl,
+                                          int32_t idAidl) {
+    effect_descriptor_t desc = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_EffectDescriptor_effect_descriptor_t(descAidl));
+    audio_io_handle_t io = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_io_handle_t(ioAidl));
+    product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_product_strategy_t(strategyAidl));
+    audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_session_t(sessionAidl));
+    int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            AudioValidator::validateEffectDescriptor(desc, "73126106")));
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id);
+    return binderStatusFromStatusT(
+            mAudioPolicyManager->registerEffect(&desc, io, strategy, session, id));
 }
 
-status_t AudioPolicyService::unregisterEffect(int id)
+Status AudioPolicyService::unregisterEffect(int32_t idAidl)
 {
+    int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->unregisterEffect(id);
+    return binderStatusFromStatusT(mAudioPolicyManager->unregisterEffect(id));
 }
 
-status_t AudioPolicyService::setEffectEnabled(int id, bool enabled)
+Status AudioPolicyService::setEffectEnabled(int32_t idAidl, bool enabled)
 {
+    int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->setEffectEnabled(id, enabled);
+    return binderStatusFromStatusT(mAudioPolicyManager->setEffectEnabled(id, enabled));
 }
 
-status_t AudioPolicyService::moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io)
+Status AudioPolicyService::moveEffectsToIo(const std::vector<int32_t>& idsAidl, int32_t ioAidl)
+
 {
+    const std::vector<int>& ids = VALUE_OR_RETURN_BINDER_STATUS(
+            convertContainer<std::vector<int>>(idsAidl, convertReinterpret<int, int32_t>));
+    audio_io_handle_t io = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_io_handle_t(ioAidl));
+    if (ids.size() > MAX_ITEMS_PER_LIST) {
+        return binderStatusFromStatusT(BAD_VALUE);
+    }
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->moveEffectsToIo(ids, io);
+    return binderStatusFromStatusT(mAudioPolicyManager->moveEffectsToIo(ids, io));
 }
 
-bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
-{
+Status AudioPolicyService::isStreamActive(media::AudioStreamType streamAidl, int32_t inPastMsAidl,
+                                          bool* _aidl_return) {
+    audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+    uint32_t inPastMs = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(inPastMsAidl));
+
     if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
-        return false;
+        *_aidl_return = false;
+        return Status::ok();
     }
     if (mAudioPolicyManager == NULL) {
-        return false;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->isStreamActive(stream, inPastMs);
+    *_aidl_return = mAudioPolicyManager->isStreamActive(stream, inPastMs);
+    return Status::ok();
 }
 
-bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
-{
+Status AudioPolicyService::isStreamActiveRemotely(media::AudioStreamType streamAidl,
+                                                  int32_t inPastMsAidl,
+                                                  bool* _aidl_return) {
+    audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+    uint32_t inPastMs = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(inPastMsAidl));
+
     if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
-        return false;
+        *_aidl_return = false;
+        return Status::ok();
     }
     if (mAudioPolicyManager == NULL) {
-        return false;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
+    *_aidl_return = mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
+    return Status::ok();
 }
 
-bool AudioPolicyService::isSourceActive(audio_source_t source) const
-{
+Status AudioPolicyService::isSourceActive(media::AudioSourceType sourceAidl, bool* _aidl_return) {
+    audio_source_t source = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioSourceType_audio_source_t(sourceAidl));
     if (mAudioPolicyManager == NULL) {
-        return false;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->isSourceActive(source);
+    *_aidl_return = mAudioPolicyManager->isSourceActive(source);
+    return Status::ok();
 }
 
 status_t AudioPolicyService::getAudioPolicyEffects(sp<AudioPolicyEffects>& audioPolicyEffects)
@@ -992,246 +1233,378 @@
     return OK;
 }
 
-status_t AudioPolicyService::queryDefaultPreProcessing(audio_session_t audioSession,
-                                                       effect_descriptor_t *descriptors,
-                                                       uint32_t *count)
-{
-    sp<AudioPolicyEffects>audioPolicyEffects;
-    status_t status = getAudioPolicyEffects(audioPolicyEffects);
-    if (status != OK) {
-        *count = 0;
-        return status;
+Status AudioPolicyService::queryDefaultPreProcessing(
+        int32_t audioSessionAidl,
+        media::Int* countAidl,
+        std::vector<media::EffectDescriptor>* _aidl_return) {
+    audio_session_t audioSession = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_session_t(audioSessionAidl));
+    uint32_t count = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(countAidl->value));
+    if (count > AudioEffect::kMaxPreProcessing) {
+        count = AudioEffect::kMaxPreProcessing;
     }
-    return audioPolicyEffects->queryDefaultInputEffects(
-            (audio_session_t)audioSession, descriptors, count);
+    uint32_t countReq = count;
+    std::unique_ptr<effect_descriptor_t[]> descriptors(new effect_descriptor_t[count]);
+
+    sp<AudioPolicyEffects> audioPolicyEffects;
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->queryDefaultInputEffects(
+            (audio_session_t) audioSession, descriptors.get(), &count)));
+    countReq = std::min(count, countReq);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            convertRange(descriptors.get(), descriptors.get() + countReq,
+                         std::back_inserter(*_aidl_return),
+                         legacy2aidl_effect_descriptor_t_EffectDescriptor)));
+    countAidl->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(count));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::addSourceDefaultEffect(const effect_uuid_t *type,
-                                                    const String16& opPackageName,
-                                                    const effect_uuid_t *uuid,
-                                                    int32_t priority,
-                                                    audio_source_t source,
-                                                    audio_unique_id_t* id)
-{
+Status AudioPolicyService::addSourceDefaultEffect(const media::AudioUuid& typeAidl,
+                                                  const std::string& opPackageNameAidl,
+                                                  const media::AudioUuid& uuidAidl,
+                                                  int32_t priority,
+                                                  media::AudioSourceType sourceAidl,
+                                                  int32_t* _aidl_return) {
+    effect_uuid_t type = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioUuid_audio_uuid_t(typeAidl));
+    String16 opPackageName = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_string_view_String16(opPackageNameAidl));
+    effect_uuid_t uuid = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioUuid_audio_uuid_t(uuidAidl));
+    audio_source_t source = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioSourceType_audio_source_t(sourceAidl));
+    audio_unique_id_t id;
+
     sp<AudioPolicyEffects>audioPolicyEffects;
-    status_t status = getAudioPolicyEffects(audioPolicyEffects);
-    if (status != OK) {
-        return status;
-    }
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
     if (!modifyDefaultAudioEffectsAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
-    return audioPolicyEffects->addSourceDefaultEffect(
-            type, opPackageName, uuid, priority, source, id);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->addSourceDefaultEffect(
+            &type, opPackageName, &uuid, priority, source, &id)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::addStreamDefaultEffect(const effect_uuid_t *type,
-                                                    const String16& opPackageName,
-                                                    const effect_uuid_t *uuid,
-                                                    int32_t priority,
-                                                    audio_usage_t usage,
-                                                    audio_unique_id_t* id)
-{
-    sp<AudioPolicyEffects>audioPolicyEffects;
-    status_t status = getAudioPolicyEffects(audioPolicyEffects);
-    if (status != OK) {
-        return status;
-    }
+Status AudioPolicyService::addStreamDefaultEffect(const media::AudioUuid& typeAidl,
+                                                  const std::string& opPackageNameAidl,
+                                                  const media::AudioUuid& uuidAidl,
+                                                  int32_t priority, media::AudioUsage usageAidl,
+                                                  int32_t* _aidl_return) {
+    effect_uuid_t type = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioUuid_audio_uuid_t(typeAidl));
+    String16 opPackageName = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_string_view_String16(opPackageNameAidl));
+    effect_uuid_t uuid = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioUuid_audio_uuid_t(uuidAidl));
+    audio_usage_t usage = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioUsage_audio_usage_t(usageAidl));
+    audio_unique_id_t id;
+
+    sp<AudioPolicyEffects> audioPolicyEffects;
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
     if (!modifyDefaultAudioEffectsAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
-    return audioPolicyEffects->addStreamDefaultEffect(
-            type, opPackageName, uuid, priority, usage, id);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->addStreamDefaultEffect(
+            &type, opPackageName, &uuid, priority, usage, &id)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::removeSourceDefaultEffect(audio_unique_id_t id)
+Status AudioPolicyService::removeSourceDefaultEffect(int32_t idAidl)
 {
+    audio_unique_id_t id = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_unique_id_t(idAidl));
     sp<AudioPolicyEffects>audioPolicyEffects;
-    status_t status = getAudioPolicyEffects(audioPolicyEffects);
-    if (status != OK) {
-        return status;
-    }
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
     if (!modifyDefaultAudioEffectsAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
-    return audioPolicyEffects->removeSourceDefaultEffect(id);
+    return binderStatusFromStatusT(audioPolicyEffects->removeSourceDefaultEffect(id));
 }
 
-status_t AudioPolicyService::removeStreamDefaultEffect(audio_unique_id_t id)
+Status AudioPolicyService::removeStreamDefaultEffect(int32_t idAidl)
 {
+    audio_unique_id_t id = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_unique_id_t(idAidl));
     sp<AudioPolicyEffects>audioPolicyEffects;
-    status_t status = getAudioPolicyEffects(audioPolicyEffects);
-    if (status != OK) {
-        return status;
-    }
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
     if (!modifyDefaultAudioEffectsAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
-    return audioPolicyEffects->removeStreamDefaultEffect(id);
+    return binderStatusFromStatusT(audioPolicyEffects->removeStreamDefaultEffect(id));
 }
 
-status_t AudioPolicyService::setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages) {
+Status AudioPolicyService::setSupportedSystemUsages(
+        const std::vector<media::AudioUsage>& systemUsagesAidl) {
+    size_t size = systemUsagesAidl.size();
+    if (size > MAX_ITEMS_PER_LIST) {
+        size = MAX_ITEMS_PER_LIST;
+    }
+    std::vector<audio_usage_t> systemUsages;
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            convertRange(systemUsagesAidl.begin(), systemUsagesAidl.begin() + size,
+                         std::back_inserter(systemUsages), aidl2legacy_AudioUsage_audio_usage_t)));
+
     Mutex::Autolock _l(mLock);
     if(!modifyAudioRoutingAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
 
     bool areAllSystemUsages = std::all_of(begin(systemUsages), end(systemUsages),
         [](audio_usage_t usage) { return isSystemUsage(usage); });
     if (!areAllSystemUsages) {
-        return BAD_VALUE;
+        return binderStatusFromStatusT(BAD_VALUE);
     }
 
     mSupportedSystemUsages = systemUsages;
-    return NO_ERROR;
+    return Status::ok();
 }
 
-status_t AudioPolicyService::setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy) {
+Status AudioPolicyService::setAllowedCapturePolicy(int32_t uidAidl, int32_t capturePolicyAidl) {
+    uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
+    audio_flags_mask_t capturePolicy = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_flags_mask_t_mask(capturePolicyAidl));
+
     Mutex::Autolock _l(mLock);
     if (mAudioPolicyManager == NULL) {
         ALOGV("%s() mAudioPolicyManager == NULL", __func__);
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
-    return mAudioPolicyManager->setAllowedCapturePolicy(uid, capturePolicy);
+    return binderStatusFromStatusT(
+            mAudioPolicyManager->setAllowedCapturePolicy(uid, capturePolicy));
 }
 
-audio_offload_mode_t AudioPolicyService::getOffloadSupport(const audio_offload_info_t& info)
-{
+Status AudioPolicyService::getOffloadSupport(const media::AudioOffloadInfo& infoAidl,
+                                             media::AudioOffloadMode* _aidl_return) {
+    audio_offload_info_t info = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioOffloadInfo_audio_offload_info_t(infoAidl));
     if (mAudioPolicyManager == NULL) {
         ALOGV("mAudioPolicyManager == NULL");
-        return AUDIO_OFFLOAD_NOT_SUPPORTED;
+        return binderStatusFromStatusT(AUDIO_OFFLOAD_NOT_SUPPORTED);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->getOffloadSupport(info);
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_offload_mode_t_AudioOffloadMode(
+            mAudioPolicyManager->getOffloadSupport(info)));
+    return Status::ok();
 }
 
-bool AudioPolicyService::isDirectOutputSupported(const audio_config_base_t& config,
-                                                 const audio_attributes_t& attributes) {
+Status AudioPolicyService::isDirectOutputSupported(
+        const media::AudioConfigBase& configAidl,
+        const media::AudioAttributesInternal& attributesAidl,
+        bool* _aidl_return) {
+    audio_config_base_t config = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioConfigBase_audio_config_base_t(configAidl));
+    audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioAttributesInternal_audio_attributes_t(attributesAidl));
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            AudioValidator::validateAudioAttributes(attributes, "169572641")));
+
     if (mAudioPolicyManager == NULL) {
         ALOGV("mAudioPolicyManager == NULL");
-        return false;
+        return binderStatusFromStatusT(NO_INIT);
     }
 
-    status_t result = validateUsage(attributes.usage);
-    if (result != NO_ERROR) {
-        return result;
-    }
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attributes.usage)));
 
     Mutex::Autolock _l(mLock);
-    return mAudioPolicyManager->isDirectOutputSupported(config, attributes);
+    *_aidl_return = mAudioPolicyManager->isDirectOutputSupported(config, attributes);
+    return Status::ok();
 }
 
 
-status_t AudioPolicyService::listAudioPorts(audio_port_role_t role,
-                                            audio_port_type_t type,
-                                            unsigned int *num_ports,
-                                            struct audio_port_v7 *ports,
-                                            unsigned int *generation)
-{
+Status AudioPolicyService::listAudioPorts(media::AudioPortRole roleAidl,
+                                          media::AudioPortType typeAidl, media::Int* count,
+                                          std::vector<media::AudioPort>* portsAidl,
+                                          int32_t* _aidl_return) {
+    audio_port_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioPortRole_audio_port_role_t(roleAidl));
+    audio_port_type_t type = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioPortType_audio_port_type_t(typeAidl));
+    unsigned int num_ports = VALUE_OR_RETURN_BINDER_STATUS(
+            convertIntegral<unsigned int>(count->value));
+    if (num_ports > MAX_ITEMS_PER_LIST) {
+        num_ports = MAX_ITEMS_PER_LIST;
+    }
+    unsigned int numPortsReq = num_ports;
+    std::unique_ptr<audio_port_v7[]> ports(new audio_port_v7[num_ports]);
+    unsigned int generation;
+
     Mutex::Autolock _l(mLock);
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     AutoCallerClear acc;
-    return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            mAudioPolicyManager->listAudioPorts(role, type, &num_ports, ports.get(), &generation)));
+    numPortsReq = std::min(numPortsReq, num_ports);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            convertRange(ports.get(), ports.get() + numPortsReq, std::back_inserter(*portsAidl),
+                         legacy2aidl_audio_port_v7_AudioPort)));
+    count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(num_ports));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(generation));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::getAudioPort(struct audio_port_v7 *port)
-{
+Status AudioPolicyService::getAudioPort(const media::AudioPort& portAidl,
+                                        media::AudioPort* _aidl_return) {
+    audio_port_v7 port = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioPort_audio_port_v7(portAidl));
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(AudioValidator::validateAudioPort(port)));
+
     Mutex::Autolock _l(mLock);
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     AutoCallerClear acc;
-    return mAudioPolicyManager->getAudioPort(port);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(mAudioPolicyManager->getAudioPort(&port)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_port_v7_AudioPort(port));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch,
-        audio_patch_handle_t *handle)
-{
+Status AudioPolicyService::createAudioPatch(const media::AudioPatch& patchAidl, int32_t handleAidl,
+                                            int32_t* _aidl_return) {
+    audio_patch patch = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioPatch_audio_patch(patchAidl));
+    audio_patch_handle_t handle = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_port_handle_t(handleAidl));
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(AudioValidator::validateAudioPatch(patch)));
+
     Mutex::Autolock _l(mLock);
     if(!modifyAudioRoutingAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     AutoCallerClear acc;
-    return mAudioPolicyManager->createAudioPatch(patch, handle,
-                                                  IPCThreadState::self()->getCallingUid());
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            mAudioPolicyManager->createAudioPatch(&patch, &handle,
+                                                  IPCThreadState::self()->getCallingUid())));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(handle));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle)
+Status AudioPolicyService::releaseAudioPatch(int32_t handleAidl)
 {
+    audio_patch_handle_t handle = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_patch_handle_t(handleAidl));
     Mutex::Autolock _l(mLock);
     if(!modifyAudioRoutingAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     AutoCallerClear acc;
-    return mAudioPolicyManager->releaseAudioPatch(handle,
-                                                     IPCThreadState::self()->getCallingUid());
+    return binderStatusFromStatusT(
+            mAudioPolicyManager->releaseAudioPatch(handle,
+                                                   IPCThreadState::self()->getCallingUid()));
 }
 
-status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches,
-        struct audio_patch *patches,
-        unsigned int *generation)
-{
+Status AudioPolicyService::listAudioPatches(media::Int* count,
+                                            std::vector<media::AudioPatch>* patchesAidl,
+                                            int32_t* _aidl_return) {
+    unsigned int num_patches = VALUE_OR_RETURN_BINDER_STATUS(
+            convertIntegral<unsigned int>(count->value));
+    if (num_patches > MAX_ITEMS_PER_LIST) {
+        num_patches = MAX_ITEMS_PER_LIST;
+    }
+    unsigned int numPatchesReq = num_patches;
+    std::unique_ptr<audio_patch[]> patches(new audio_patch[num_patches]);
+    unsigned int generation;
+
     Mutex::Autolock _l(mLock);
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     AutoCallerClear acc;
-    return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            mAudioPolicyManager->listAudioPatches(&num_patches, patches.get(), &generation)));
+    numPatchesReq = std::min(numPatchesReq, num_patches);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            convertRange(patches.get(), patches.get() + numPatchesReq,
+                         std::back_inserter(*patchesAidl), legacy2aidl_audio_patch_AudioPatch)));
+    count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(num_patches));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(generation));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config)
+Status AudioPolicyService::setAudioPortConfig(const media::AudioPortConfig& configAidl)
 {
+    audio_port_config config = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioPortConfig_audio_port_config(configAidl));
+    RETURN_IF_BINDER_ERROR(
+            binderStatusFromStatusT(AudioValidator::validateAudioPortConfig(config)));
+
     Mutex::Autolock _l(mLock);
     if(!modifyAudioRoutingAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     AutoCallerClear acc;
-    return mAudioPolicyManager->setAudioPortConfig(config);
+    return binderStatusFromStatusT(mAudioPolicyManager->setAudioPortConfig(&config));
 }
 
-status_t AudioPolicyService::acquireSoundTriggerSession(audio_session_t *session,
-                                       audio_io_handle_t *ioHandle,
-                                       audio_devices_t *device)
+Status AudioPolicyService::acquireSoundTriggerSession(media::SoundTriggerSession* _aidl_return)
 {
+    audio_session_t session;
+    audio_io_handle_t ioHandle;
+    audio_devices_t device;
+
+    {
+        Mutex::Autolock _l(mLock);
+        if (mAudioPolicyManager == NULL) {
+            return binderStatusFromStatusT(NO_INIT);
+        }
+        AutoCallerClear acc;
+        RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+                mAudioPolicyManager->acquireSoundTriggerSession(&session, &ioHandle, &device)));
+    }
+
+    _aidl_return->session = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_audio_session_t_int32_t(session));
+    _aidl_return->ioHandle = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
+    _aidl_return->device = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_audio_devices_t_int32_t(device));
+    return Status::ok();
+}
+
+Status AudioPolicyService::releaseSoundTriggerSession(int32_t sessionAidl)
+{
+    audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_session_t(sessionAidl));
     Mutex::Autolock _l(mLock);
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     AutoCallerClear acc;
-    return mAudioPolicyManager->acquireSoundTriggerSession(session, ioHandle, device);
+    return binderStatusFromStatusT(mAudioPolicyManager->releaseSoundTriggerSession(session));
 }
 
-status_t AudioPolicyService::releaseSoundTriggerSession(audio_session_t session)
-{
-    Mutex::Autolock _l(mLock);
-    if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+Status AudioPolicyService::registerPolicyMixes(const std::vector<media::AudioMix>& mixesAidl,
+                                               bool registration) {
+    size_t size = mixesAidl.size();
+    if (size > MAX_MIXES_PER_POLICY) {
+        size = MAX_MIXES_PER_POLICY;
     }
-    AutoCallerClear acc;
-    return mAudioPolicyManager->releaseSoundTriggerSession(session);
-}
+    Vector<AudioMix> mixes;
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            convertRange(mixesAidl.begin(), mixesAidl.begin() + size, std::back_inserter(mixes),
+                         aidl2legacy_AudioMix)));
 
-status_t AudioPolicyService::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
-{
     Mutex::Autolock _l(mLock);
 
     // loopback|render only need a MediaProjection (checked in caller AudioService.java)
     bool needModifyAudioRouting = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
             return !is_mix_loopback_render(mix.mRouteFlags); });
     if (needModifyAudioRouting && !modifyAudioRoutingAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
 
     // If one of the mixes has needCaptureVoiceCommunicationOutput set to true, then we
@@ -1247,352 +1620,519 @@
     const pid_t callingPid = IPCThreadState::self()->getCallingPid();
 
     if (needCaptureMediaOutput && !captureMediaOutputAllowed(callingPid, callingUid)) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
 
     if (needCaptureVoiceCommunicationOutput &&
         !captureVoiceCommunicationOutputAllowed(callingPid, callingUid)) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
 
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     AutoCallerClear acc;
     if (registration) {
-        return mAudioPolicyManager->registerPolicyMixes(mixes);
+        return binderStatusFromStatusT(mAudioPolicyManager->registerPolicyMixes(mixes));
     } else {
-        return mAudioPolicyManager->unregisterPolicyMixes(mixes);
+        return binderStatusFromStatusT(mAudioPolicyManager->unregisterPolicyMixes(mixes));
     }
 }
 
-status_t AudioPolicyService::setUidDeviceAffinities(uid_t uid,
-        const AudioDeviceTypeAddrVector& devices) {
+Status AudioPolicyService::setUidDeviceAffinities(
+        int32_t uidAidl,
+        const std::vector<media::AudioDevice>& devicesAidl) {
+    uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
+    AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
+            convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+                                                        aidl2legacy_AudioDeviceTypeAddress));
+
     Mutex::Autolock _l(mLock);
     if(!modifyAudioRoutingAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     AutoCallerClear acc;
-    return mAudioPolicyManager->setUidDeviceAffinities(uid, devices);
+    return binderStatusFromStatusT(mAudioPolicyManager->setUidDeviceAffinities(uid, devices));
 }
 
-status_t AudioPolicyService::removeUidDeviceAffinities(uid_t uid) {
+Status AudioPolicyService::removeUidDeviceAffinities(int32_t uidAidl) {
+    uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
+
     Mutex::Autolock _l(mLock);
     if(!modifyAudioRoutingAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     AutoCallerClear acc;
-    return mAudioPolicyManager->removeUidDeviceAffinities(uid);
+    return binderStatusFromStatusT(mAudioPolicyManager->removeUidDeviceAffinities(uid));
 }
 
-status_t AudioPolicyService::setUserIdDeviceAffinities(int userId,
-        const AudioDeviceTypeAddrVector& devices) {
+Status AudioPolicyService::setUserIdDeviceAffinities(
+        int32_t userIdAidl,
+        const std::vector<media::AudioDevice>& devicesAidl) {
+    int userId = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(userIdAidl));
+    AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
+            convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+                                                        aidl2legacy_AudioDeviceTypeAddress));
+
     Mutex::Autolock _l(mLock);
     if(!modifyAudioRoutingAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     AutoCallerClear acc;
-    return mAudioPolicyManager->setUserIdDeviceAffinities(userId, devices);
+    return binderStatusFromStatusT(mAudioPolicyManager->setUserIdDeviceAffinities(userId, devices));
 }
 
-status_t AudioPolicyService::removeUserIdDeviceAffinities(int userId) {
+Status AudioPolicyService::removeUserIdDeviceAffinities(int32_t userIdAidl) {
+    int userId = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(userIdAidl));
+
     Mutex::Autolock _l(mLock);
     if(!modifyAudioRoutingAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     AutoCallerClear acc;
-    return mAudioPolicyManager->removeUserIdDeviceAffinities(userId);
+    return binderStatusFromStatusT(mAudioPolicyManager->removeUserIdDeviceAffinities(userId));
 }
 
-status_t AudioPolicyService::startAudioSource(const struct audio_port_config *source,
-                                              const audio_attributes_t *attributes,
-                                              audio_port_handle_t *portId)
-{
+Status AudioPolicyService::startAudioSource(const media::AudioPortConfig& sourceAidl,
+                                            const media::AudioAttributesInternal& attributesAidl,
+                                            int32_t* _aidl_return) {
+    audio_port_config source = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioPortConfig_audio_port_config(sourceAidl));
+    audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioAttributesInternal_audio_attributes_t(attributesAidl));
+    audio_port_handle_t portId;
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            AudioValidator::validateAudioPortConfig(source)));
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            AudioValidator::validateAudioAttributes(attributes, "68953950")));
+
     Mutex::Autolock _l(mLock);
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
 
-    status_t result = validateUsage(attributes->usage);
-    if (result != NO_ERROR) {
-        return result;
-    }
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attributes.usage)));
 
     // startAudioSource should be created as the calling uid
     const uid_t callingUid = IPCThreadState::self()->getCallingUid();
     AutoCallerClear acc;
-    return mAudioPolicyManager->startAudioSource(source, attributes, portId, callingUid);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            mAudioPolicyManager->startAudioSource(&source, &attributes, &portId, callingUid)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::stopAudioSource(audio_port_handle_t portId)
+Status AudioPolicyService::stopAudioSource(int32_t portIdAidl)
 {
+    audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
+
     Mutex::Autolock _l(mLock);
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     AutoCallerClear acc;
-    return mAudioPolicyManager->stopAudioSource(portId);
+    return binderStatusFromStatusT(mAudioPolicyManager->stopAudioSource(portId));
 }
 
-status_t AudioPolicyService::setMasterMono(bool mono)
+Status AudioPolicyService::setMasterMono(bool mono)
 {
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     if (!settingsAllowed()) {
-        return PERMISSION_DENIED;
+        return binderStatusFromStatusT(PERMISSION_DENIED);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->setMasterMono(mono);
+    return binderStatusFromStatusT(mAudioPolicyManager->setMasterMono(mono));
 }
 
-status_t AudioPolicyService::getMasterMono(bool *mono)
+Status AudioPolicyService::getMasterMono(bool* _aidl_return)
 {
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->getMasterMono(mono);
+    return binderStatusFromStatusT(mAudioPolicyManager->getMasterMono(_aidl_return));
 }
 
 
-float AudioPolicyService::getStreamVolumeDB(
-            audio_stream_type_t stream, int index, audio_devices_t device)
-{
+Status AudioPolicyService::getStreamVolumeDB(media::AudioStreamType streamAidl, int32_t indexAidl,
+                                             int32_t deviceAidl, float* _aidl_return) {
+    audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+    int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
+    audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_audio_devices_t(deviceAidl));
+
     if (mAudioPolicyManager == NULL) {
-        return NAN;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->getStreamVolumeDB(stream, index, device);
+    *_aidl_return = mAudioPolicyManager->getStreamVolumeDB(stream, index, device);
+    return Status::ok();
 }
 
-status_t AudioPolicyService::getSurroundFormats(unsigned int *numSurroundFormats,
-                                                audio_format_t *surroundFormats,
-                                                bool *surroundFormatsEnabled,
-                                                bool reported)
-{
+Status AudioPolicyService::getSurroundFormats(
+        bool reported, media::Int* count,
+        std::vector<media::audio::common::AudioFormat>* formats,
+        bool* _aidl_return) {
+    unsigned int numSurroundFormats = VALUE_OR_RETURN_BINDER_STATUS(
+            convertIntegral<unsigned int>(count->value));
+    if (numSurroundFormats > MAX_ITEMS_PER_LIST) {
+        numSurroundFormats = MAX_ITEMS_PER_LIST;
+    }
+    unsigned int numSurroundFormatsReq = numSurroundFormats;
+    std::unique_ptr<audio_format_t[]>surroundFormats(new audio_format_t[numSurroundFormats]);
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->getSurroundFormats(numSurroundFormats, surroundFormats,
-                                                   surroundFormatsEnabled, reported);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            mAudioPolicyManager->getSurroundFormats(&numSurroundFormats, surroundFormats.get(),
+                                                    _aidl_return, reported)));
+    numSurroundFormatsReq = std::min(numSurroundFormats, numSurroundFormatsReq);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            convertRange(surroundFormats.get(), surroundFormats.get() + numSurroundFormatsReq,
+                         std::back_inserter(*formats), legacy2aidl_audio_format_t_AudioFormat)));
+    count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(numSurroundFormats));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::getHwOffloadEncodingFormatsSupportedForA2DP(
-                                        std::vector<audio_format_t> *formats)
-{
+Status AudioPolicyService::getHwOffloadEncodingFormatsSupportedForA2DP(
+        std::vector<media::audio::common::AudioFormat>* _aidl_return) {
+    std::vector<audio_format_t> formats;
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->getHwOffloadEncodingFormatsSupportedForA2DP(formats);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            mAudioPolicyManager->getHwOffloadEncodingFormatsSupportedForA2DP(&formats)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            convertContainer<std::vector<media::audio::common::AudioFormat>>(
+                    formats,
+                    legacy2aidl_audio_format_t_AudioFormat));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
-{
+Status AudioPolicyService::setSurroundFormatEnabled(
+        media::audio::common::AudioFormat audioFormatAidl, bool enabled) {
+    audio_format_t audioFormat = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioFormat_audio_format_t(audioFormatAidl));
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled);
+    return binderStatusFromStatusT(
+            mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled));
 }
 
-status_t AudioPolicyService::setAssistantUid(uid_t uid)
+Status AudioPolicyService::setAssistantUid(int32_t uidAidl)
 {
+    uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
     Mutex::Autolock _l(mLock);
     mUidPolicy->setAssistantUid(uid);
-    return NO_ERROR;
+    return Status::ok();
 }
 
-status_t AudioPolicyService::setA11yServicesUids(const std::vector<uid_t>& uids)
+Status AudioPolicyService::setA11yServicesUids(const std::vector<int32_t>& uidsAidl)
 {
+    size_t size = uidsAidl.size();
+    if (size > MAX_ITEMS_PER_LIST) {
+        size = MAX_ITEMS_PER_LIST;
+    }
+    std::vector<uid_t> uids;
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            convertRange(uidsAidl.begin(),
+                         uidsAidl.begin() + size,
+                         std::back_inserter(uids),
+                         aidl2legacy_int32_t_uid_t)));
     Mutex::Autolock _l(mLock);
     mUidPolicy->setA11yUids(uids);
-    return NO_ERROR;
+    return Status::ok();
 }
 
-status_t AudioPolicyService::setCurrentImeUid(uid_t uid)
+Status AudioPolicyService::setCurrentImeUid(int32_t uidAidl)
 {
+    uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
     Mutex::Autolock _l(mLock);
     mUidPolicy->setCurrentImeUid(uid);
-    return NO_ERROR;
+    return Status::ok();
 }
 
-bool AudioPolicyService::isHapticPlaybackSupported()
+Status AudioPolicyService::isHapticPlaybackSupported(bool* _aidl_return)
 {
     if (mAudioPolicyManager == NULL) {
-        ALOGW("%s, mAudioPolicyManager == NULL", __func__);
-        return false;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->isHapticPlaybackSupported();
+    *_aidl_return = mAudioPolicyManager->isHapticPlaybackSupported();
+    return Status::ok();
 }
 
-status_t AudioPolicyService::listAudioProductStrategies(AudioProductStrategyVector &strategies)
-{
+Status AudioPolicyService::listAudioProductStrategies(
+        std::vector<media::AudioProductStrategy>* _aidl_return) {
+    AudioProductStrategyVector strategies;
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
-    return mAudioPolicyManager->listAudioProductStrategies(strategies);
+    RETURN_IF_BINDER_ERROR(
+            binderStatusFromStatusT(mAudioPolicyManager->listAudioProductStrategies(strategies)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            convertContainer<std::vector<media::AudioProductStrategy>>(
+                    strategies,
+                    legacy2aidl_AudioProductStrategy));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::getProductStrategyFromAudioAttributes(
-        const AudioAttributes &aa, product_strategy_t &productStrategy)
-{
+Status AudioPolicyService::getProductStrategyFromAudioAttributes(
+        const media::AudioAttributesEx& aaAidl, int32_t* _aidl_return) {
+    AudioAttributes aa = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioAttributesEx_AudioAttributes(aaAidl));
+    product_strategy_t productStrategy;
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
-    return mAudioPolicyManager->getProductStrategyFromAudioAttributes(aa, productStrategy);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            mAudioPolicyManager->getProductStrategyFromAudioAttributes(aa,
+                                                                       productStrategy)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            legacy2aidl_product_strategy_t_int32_t(productStrategy));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::listAudioVolumeGroups(AudioVolumeGroupVector &groups)
+Status AudioPolicyService::listAudioVolumeGroups(std::vector<media::AudioVolumeGroup>* _aidl_return)
 {
+    AudioVolumeGroupVector groups;
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
-    return mAudioPolicyManager->listAudioVolumeGroups(groups);
+    RETURN_IF_BINDER_ERROR(
+            binderStatusFromStatusT(mAudioPolicyManager->listAudioVolumeGroups(groups)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            convertContainer<std::vector<media::AudioVolumeGroup>>(groups,
+                                                                   legacy2aidl_AudioVolumeGroup));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
-                                                               volume_group_t &volumeGroup)
-{
+Status AudioPolicyService::getVolumeGroupFromAudioAttributes(const media::AudioAttributesEx& aaAidl,
+                                                             int32_t* _aidl_return) {
+    AudioAttributes aa = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioAttributesEx_AudioAttributes(aaAidl));
+    volume_group_t volumeGroup;
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
-    return mAudioPolicyManager->getVolumeGroupFromAudioAttributes(aa, volumeGroup);
+    RETURN_IF_BINDER_ERROR(
+            binderStatusFromStatusT(
+                    mAudioPolicyManager->getVolumeGroupFromAudioAttributes(aa, volumeGroup)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_volume_group_t_int32_t(volumeGroup));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::setRttEnabled(bool enabled)
+Status AudioPolicyService::setRttEnabled(bool enabled)
 {
     Mutex::Autolock _l(mLock);
     mUidPolicy->setRttEnabled(enabled);
-    return NO_ERROR;
+    return Status::ok();
 }
 
-bool AudioPolicyService::isCallScreenModeSupported()
+Status AudioPolicyService::isCallScreenModeSupported(bool* _aidl_return)
 {
     if (mAudioPolicyManager == NULL) {
-        ALOGW("%s, mAudioPolicyManager == NULL", __func__);
-        return false;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
     AutoCallerClear acc;
-    return mAudioPolicyManager->isCallScreenModeSupported();
+    *_aidl_return = mAudioPolicyManager->isCallScreenModeSupported();
+    return Status::ok();
 }
 
-status_t AudioPolicyService::setDevicesRoleForStrategy(product_strategy_t strategy,
-                                                       device_role_t role,
-                                                       const AudioDeviceTypeAddrVector &devices)
-{
+Status AudioPolicyService::setDevicesRoleForStrategy(
+        int32_t strategyAidl,
+        media::DeviceRole roleAidl,
+        const std::vector<media::AudioDevice>& devicesAidl) {
+    product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_product_strategy_t(strategyAidl));
+    device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_DeviceRole_device_role_t(roleAidl));
+    AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
+            convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+                                                        aidl2legacy_AudioDeviceTypeAddress));
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
-    return mAudioPolicyManager->setDevicesRoleForStrategy(strategy, role, devices);
+    return binderStatusFromStatusT(
+            mAudioPolicyManager->setDevicesRoleForStrategy(strategy, role, devices));
 }
 
-status_t AudioPolicyService::removeDevicesRoleForStrategy(product_strategy_t strategy,
-                                                          device_role_t role)
-{
+Status AudioPolicyService::removeDevicesRoleForStrategy(int32_t strategyAidl,
+                                                        media::DeviceRole roleAidl) {
+     product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_product_strategy_t(strategyAidl));
+    device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_DeviceRole_device_role_t(roleAidl));
+   if (mAudioPolicyManager == NULL) {
+        return binderStatusFromStatusT(NO_INIT);
+    }
+    Mutex::Autolock _l(mLock);
+    return binderStatusFromStatusT(
+            mAudioPolicyManager->removeDevicesRoleForStrategy(strategy, role));
+}
+
+Status AudioPolicyService::getDevicesForRoleAndStrategy(
+        int32_t strategyAidl,
+        media::DeviceRole roleAidl,
+        std::vector<media::AudioDevice>* _aidl_return) {
+    product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_int32_t_product_strategy_t(strategyAidl));
+    device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_DeviceRole_device_role_t(roleAidl));
+    AudioDeviceTypeAddrVector devices;
+
     if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
-    return mAudioPolicyManager->removeDevicesRoleForStrategy(strategy, role);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            mAudioPolicyManager->getDevicesForRoleAndStrategy(strategy, role, devices)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            convertContainer<std::vector<media::AudioDevice>>(devices,
+                                                              legacy2aidl_AudioDeviceTypeAddress));
+    return Status::ok();
 }
 
-status_t AudioPolicyService::getDevicesForRoleAndStrategy(product_strategy_t strategy,
-                                                          device_role_t role,
-                                                          AudioDeviceTypeAddrVector &devices)
-{
-    if (mAudioPolicyManager == NULL) {
-        return NO_INIT;
-    }
-    Mutex::Autolock _l(mLock);
-    return mAudioPolicyManager->getDevicesForRoleAndStrategy(strategy, role, devices);
+Status AudioPolicyService::registerSoundTriggerCaptureStateListener(
+        const sp<media::ICaptureStateListener>& listener, bool* _aidl_return) {
+    *_aidl_return = mCaptureStateNotifier.RegisterListener(listener);
+    return Status::ok();
 }
 
-status_t AudioPolicyService::registerSoundTriggerCaptureStateListener(
-    const sp<media::ICaptureStateListener>& listener,
-    bool* result)
-{
-    *result = mCaptureStateNotifier.RegisterListener(listener);
-    return NO_ERROR;
-}
+Status AudioPolicyService::setDevicesRoleForCapturePreset(
+        media::AudioSourceType audioSourceAidl,
+        media::DeviceRole roleAidl,
+        const std::vector<media::AudioDevice>& devicesAidl) {
+    audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
+    device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_DeviceRole_device_role_t(roleAidl));
+    AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
+            convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+                                                        aidl2legacy_AudioDeviceTypeAddress));
 
-status_t AudioPolicyService::setDevicesRoleForCapturePreset(
-        audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector &devices)
-{
     if (mAudioPolicyManager == nullptr) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
-    return mAudioPolicyManager->setDevicesRoleForCapturePreset(audioSource, role, devices);
+    return binderStatusFromStatusT(
+            mAudioPolicyManager->setDevicesRoleForCapturePreset(audioSource, role, devices));
 }
 
-status_t AudioPolicyService::addDevicesRoleForCapturePreset(
-        audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector &devices)
-{
+Status AudioPolicyService::addDevicesRoleForCapturePreset(
+        media::AudioSourceType audioSourceAidl,
+        media::DeviceRole roleAidl,
+        const std::vector<media::AudioDevice>& devicesAidl) {
+    audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
+    device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_DeviceRole_device_role_t(roleAidl));
+    AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
+            convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+                                                        aidl2legacy_AudioDeviceTypeAddress));
+
     if (mAudioPolicyManager == nullptr) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
-    return mAudioPolicyManager->addDevicesRoleForCapturePreset(audioSource, role, devices);
+    return binderStatusFromStatusT(
+            mAudioPolicyManager->addDevicesRoleForCapturePreset(audioSource, role, devices));
 }
 
-status_t AudioPolicyService::removeDevicesRoleForCapturePreset(
-        audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector& devices)
-{
-    if (mAudioPolicyManager == nullptr) {
-        return NO_INIT;
+Status AudioPolicyService::removeDevicesRoleForCapturePreset(
+        media::AudioSourceType audioSourceAidl,
+        media::DeviceRole roleAidl,
+        const std::vector<media::AudioDevice>& devicesAidl) {
+    audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
+    device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_DeviceRole_device_role_t(roleAidl));
+    AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
+            convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+                                                        aidl2legacy_AudioDeviceTypeAddress));
+
+   if (mAudioPolicyManager == nullptr) {
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
-    return mAudioPolicyManager->removeDevicesRoleForCapturePreset(audioSource, role, devices);
+    return binderStatusFromStatusT(
+            mAudioPolicyManager->removeDevicesRoleForCapturePreset(audioSource, role, devices));
 }
 
-status_t AudioPolicyService::clearDevicesRoleForCapturePreset(audio_source_t audioSource,
-                                                              device_role_t role)
-{
+Status AudioPolicyService::clearDevicesRoleForCapturePreset(media::AudioSourceType audioSourceAidl,
+                                                            media::DeviceRole roleAidl) {
+    audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
+    device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_DeviceRole_device_role_t(roleAidl));
+
     if (mAudioPolicyManager == nullptr) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
-    return mAudioPolicyManager->clearDevicesRoleForCapturePreset(audioSource, role);
+    return binderStatusFromStatusT(
+            mAudioPolicyManager->clearDevicesRoleForCapturePreset(audioSource, role));
 }
 
-status_t AudioPolicyService::getDevicesForRoleAndCapturePreset(audio_source_t audioSource,
-                                                               device_role_t role,
-                                                               AudioDeviceTypeAddrVector &devices)
-{
+Status AudioPolicyService::getDevicesForRoleAndCapturePreset(
+        media::AudioSourceType audioSourceAidl,
+        media::DeviceRole roleAidl,
+        std::vector<media::AudioDevice>* _aidl_return) {
+    audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
+    device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+            aidl2legacy_DeviceRole_device_role_t(roleAidl));
+    AudioDeviceTypeAddrVector devices;
+
     if (mAudioPolicyManager == nullptr) {
-        return NO_INIT;
+        return binderStatusFromStatusT(NO_INIT);
     }
     Mutex::Autolock _l(mLock);
-    return mAudioPolicyManager->getDevicesForRoleAndCapturePreset(audioSource, role, devices);
+    RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+            mAudioPolicyManager->getDevicesForRoleAndCapturePreset(audioSource, role, devices)));
+    *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+            convertContainer<std::vector<media::AudioDevice>>(devices,
+                                                              legacy2aidl_AudioDeviceTypeAddress));
+    return Status::ok();
 }
 
 } // namespace android
diff --git a/services/audiopolicy/service/AudioPolicyService.cpp b/services/audiopolicy/service/AudioPolicyService.cpp
index 80022c8..4ce6dc1 100644
--- a/services/audiopolicy/service/AudioPolicyService.cpp
+++ b/services/audiopolicy/service/AudioPolicyService.cpp
@@ -39,12 +39,14 @@
 #include <media/AudioEffect.h>
 #include <media/AudioParameter.h>
 #include <mediautils/ServiceUtilities.h>
+#include <mediautils/TimeCheck.h>
 #include <sensorprivacy/SensorPrivacyManager.h>
 
 #include <system/audio.h>
 #include <system/audio_policy.h>
 
 namespace android {
+using binder::Status;
 
 static const char kDeadlockedString[] = "AudioPolicyService may be deadlocked\n";
 static const char kCmdDeadlockedString[] = "AudioPolicyService command thread may be deadlocked\n";
@@ -112,11 +114,11 @@
 
 // A notification client is always registered by AudioSystem when the client process
 // connects to AudioPolicyService.
-void AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
+Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
 {
     if (client == 0) {
         ALOGW("%s got NULL client", __FUNCTION__);
-        return;
+        return Status::ok();
     }
     Mutex::Autolock _l(mNotificationClientsLock);
 
@@ -136,9 +138,10 @@
         sp<IBinder> binder = IInterface::asBinder(client);
         binder->linkToDeath(notificationClient);
     }
+        return Status::ok();
 }
 
-void AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
+Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
 {
     Mutex::Autolock _l(mNotificationClientsLock);
 
@@ -147,12 +150,13 @@
     int64_t token = ((int64_t)uid<<32) | pid;
 
     if (mNotificationClients.indexOfKey(token) < 0) {
-        return;
+        return Status::ok();
     }
     mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
+    return Status::ok();
 }
 
-void AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
+Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
 {
     Mutex::Autolock _l(mNotificationClientsLock);
 
@@ -161,9 +165,10 @@
     int64_t token = ((int64_t)uid<<32) | pid;
 
     if (mNotificationClients.indexOfKey(token) < 0) {
-        return;
+        return Status::ok();
     }
     mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
+    return Status::ok();
 }
 
 // removeNotificationClient() is called when the client process dies.
@@ -816,6 +821,92 @@
 
 status_t AudioPolicyService::onTransact(
         uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
+    // make sure transactions reserved to AudioFlinger do not come from other processes
+    switch (code) {
+        case TRANSACTION_startOutput:
+        case TRANSACTION_stopOutput:
+        case TRANSACTION_releaseOutput:
+        case TRANSACTION_getInputForAttr:
+        case TRANSACTION_startInput:
+        case TRANSACTION_stopInput:
+        case TRANSACTION_releaseInput:
+        case TRANSACTION_getOutputForEffect:
+        case TRANSACTION_registerEffect:
+        case TRANSACTION_unregisterEffect:
+        case TRANSACTION_setEffectEnabled:
+        case TRANSACTION_getStrategyForStream:
+        case TRANSACTION_getOutputForAttr:
+        case TRANSACTION_moveEffectsToIo:
+            ALOGW("%s: transaction %d received from PID %d",
+                  __func__, code, IPCThreadState::self()->getCallingPid());
+            return INVALID_OPERATION;
+        default:
+            break;
+    }
+
+    // make sure the following transactions come from system components
+    switch (code) {
+        case TRANSACTION_setDeviceConnectionState:
+        case TRANSACTION_handleDeviceConfigChange:
+        case TRANSACTION_setPhoneState:
+//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
+//      case TRANSACTION_setForceUse:
+        case TRANSACTION_initStreamVolume:
+        case TRANSACTION_setStreamVolumeIndex:
+        case TRANSACTION_setVolumeIndexForAttributes:
+        case TRANSACTION_getStreamVolumeIndex:
+        case TRANSACTION_getVolumeIndexForAttributes:
+        case TRANSACTION_getMinVolumeIndexForAttributes:
+        case TRANSACTION_getMaxVolumeIndexForAttributes:
+        case TRANSACTION_isStreamActive:
+        case TRANSACTION_isStreamActiveRemotely:
+        case TRANSACTION_isSourceActive:
+        case TRANSACTION_getDevicesForStream:
+        case TRANSACTION_registerPolicyMixes:
+        case TRANSACTION_setMasterMono:
+        case TRANSACTION_getSurroundFormats:
+        case TRANSACTION_setSurroundFormatEnabled:
+        case TRANSACTION_setAssistantUid:
+        case TRANSACTION_setA11yServicesUids:
+        case TRANSACTION_setUidDeviceAffinities:
+        case TRANSACTION_removeUidDeviceAffinities:
+        case TRANSACTION_setUserIdDeviceAffinities:
+        case TRANSACTION_removeUserIdDeviceAffinities:
+        case TRANSACTION_getHwOffloadEncodingFormatsSupportedForA2DP:
+        case TRANSACTION_listAudioVolumeGroups:
+        case TRANSACTION_getVolumeGroupFromAudioAttributes:
+        case TRANSACTION_acquireSoundTriggerSession:
+        case TRANSACTION_releaseSoundTriggerSession:
+        case TRANSACTION_setRttEnabled:
+        case TRANSACTION_isCallScreenModeSupported:
+        case TRANSACTION_setDevicesRoleForStrategy:
+        case TRANSACTION_setSupportedSystemUsages:
+        case TRANSACTION_removeDevicesRoleForStrategy:
+        case TRANSACTION_getDevicesForRoleAndStrategy:
+        case TRANSACTION_getDevicesForAttributes:
+        case TRANSACTION_setAllowedCapturePolicy:
+        case TRANSACTION_onNewAudioModulesAvailable:
+        case TRANSACTION_setCurrentImeUid:
+        case TRANSACTION_registerSoundTriggerCaptureStateListener:
+        case TRANSACTION_setDevicesRoleForCapturePreset:
+        case TRANSACTION_addDevicesRoleForCapturePreset:
+        case TRANSACTION_removeDevicesRoleForCapturePreset:
+        case TRANSACTION_clearDevicesRoleForCapturePreset:
+        case TRANSACTION_getDevicesForRoleAndCapturePreset: {
+            if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
+                ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
+                      __func__, code, IPCThreadState::self()->getCallingPid(),
+                      IPCThreadState::self()->getCallingUid());
+                return INVALID_OPERATION;
+            }
+        } break;
+        default:
+            break;
+    }
+
+    std::string tag("IAudioPolicyService command " + std::to_string(code));
+    TimeCheck check(tag.c_str());
+
     switch (code) {
         case SHELL_COMMAND_TRANSACTION: {
             int in = data.readFileDescriptor();
@@ -2022,9 +2113,10 @@
     mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
 }
 
-void AudioPolicyService::onNewAudioModulesAvailable()
+Status AudioPolicyService::onNewAudioModulesAvailable()
 {
     mOutputCommandThread->audioModulesUpdateCommand();
+    return Status::ok();
 }
 
 
diff --git a/services/audiopolicy/service/AudioPolicyService.h b/services/audiopolicy/service/AudioPolicyService.h
index 2cb8759..c22ed9b 100644
--- a/services/audiopolicy/service/AudioPolicyService.h
+++ b/services/audiopolicy/service/AudioPolicyService.h
@@ -17,6 +17,7 @@
 #ifndef ANDROID_AUDIOPOLICYSERVICE_H
 #define ANDROID_AUDIOPOLICYSERVICE_H
 
+#include <android/media/BnAudioPolicyService.h>
 #include <android-base/thread_annotations.h>
 #include <cutils/misc.h>
 #include <cutils/config_utils.h>
@@ -29,7 +30,6 @@
 #include <binder/IUidObserver.h>
 #include <system/audio.h>
 #include <system/audio_policy.h>
-#include <media/IAudioPolicyService.h>
 #include <media/ToneGenerator.h>
 #include <media/AudioEffect.h>
 #include <media/AudioPolicy.h>
@@ -47,7 +47,7 @@
 
 class AudioPolicyService :
     public BinderService<AudioPolicyService>,
-    public BnAudioPolicyService,
+    public media::BnAudioPolicyService,
     public IBinder::DeathRecipient
 {
     friend class BinderService<AudioPolicyService>;
@@ -61,108 +61,175 @@
     //
     // BnAudioPolicyService (see AudioPolicyInterface for method descriptions)
     //
-
-    void onNewAudioModulesAvailable() override;
-    virtual status_t setDeviceConnectionState(audio_devices_t device,
-                                              audio_policy_dev_state_t state,
-                                              const char *device_address,
-                                              const char *device_name,
-                                              audio_format_t encodedFormat);
-    virtual audio_policy_dev_state_t getDeviceConnectionState(
-                                                                audio_devices_t device,
-                                                                const char *device_address);
-    virtual status_t handleDeviceConfigChange(audio_devices_t device,
-                                              const char *device_address,
-                                              const char *device_name,
-                                              audio_format_t encodedFormat);
-    virtual status_t setPhoneState(audio_mode_t state, uid_t uid);
-    virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config);
-    virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage);
-    virtual audio_io_handle_t getOutput(audio_stream_type_t stream);
-    status_t getOutputForAttr(audio_attributes_t *attr,
-                              audio_io_handle_t *output,
-                              audio_session_t session,
-                              audio_stream_type_t *stream,
-                              pid_t pid,
-                              uid_t uid,
-                              const audio_config_t *config,
-                              audio_output_flags_t flags,
-                              audio_port_handle_t *selectedDeviceId,
-                              audio_port_handle_t *portId,
-                              std::vector<audio_io_handle_t> *secondaryOutputs) override;
-    virtual status_t startOutput(audio_port_handle_t portId);
-    virtual status_t stopOutput(audio_port_handle_t portId);
-    virtual void releaseOutput(audio_port_handle_t portId);
-    virtual status_t getInputForAttr(const audio_attributes_t *attr,
-                                     audio_io_handle_t *input,
-                                     audio_unique_id_t riid,
-                                     audio_session_t session,
-                                     pid_t pid,
-                                     uid_t uid,
-                                     const String16& opPackageName,
-                                     const audio_config_base_t *config,
-                                     audio_input_flags_t flags,
-                                     audio_port_handle_t *selectedDeviceId = NULL,
-                                     audio_port_handle_t *portId = NULL);
-    virtual status_t startInput(audio_port_handle_t portId);
-    virtual status_t stopInput(audio_port_handle_t portId);
-    virtual void releaseInput(audio_port_handle_t portId);
-    virtual status_t initStreamVolume(audio_stream_type_t stream,
-                                      int indexMin,
-                                      int indexMax);
-    virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
-                                          int index,
-                                          audio_devices_t device);
-    virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
-                                          int *index,
-                                          audio_devices_t device);
-
-    virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr,
-                                                 int index,
-                                                 audio_devices_t device);
-    virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr,
-                                                 int &index,
-                                                 audio_devices_t device);
-    virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr,
-                                                    int &index);
-    virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr,
-                                                    int &index);
-
-    virtual uint32_t getStrategyForStream(audio_stream_type_t stream);
-    virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream);
-    virtual status_t getDevicesForAttributes(const AudioAttributes &aa,
-                                             AudioDeviceTypeAddrVector *devices) const;
-
-    virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc);
-    virtual status_t registerEffect(const effect_descriptor_t *desc,
-                                    audio_io_handle_t io,
-                                    uint32_t strategy,
-                                    audio_session_t session,
-                                    int id);
-    virtual status_t unregisterEffect(int id);
-    virtual status_t setEffectEnabled(int id, bool enabled);
-    status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) override;
-    virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const;
-    virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs = 0) const;
-    virtual bool isSourceActive(audio_source_t source) const;
-
-    virtual status_t queryDefaultPreProcessing(audio_session_t audioSession,
-                                              effect_descriptor_t *descriptors,
-                                              uint32_t *count);
-    virtual status_t addSourceDefaultEffect(const effect_uuid_t *type,
-                                            const String16& opPackageName,
-                                            const effect_uuid_t *uuid,
-                                            int32_t priority,
-                                            audio_source_t source,
-                                            audio_unique_id_t* id);
-    virtual status_t addStreamDefaultEffect(const effect_uuid_t *type,
-                                            const String16& opPackageName,
-                                            const effect_uuid_t *uuid,
-                                            int32_t priority,
-                                            audio_usage_t usage,
-                                            audio_unique_id_t* id);
-    virtual status_t removeSourceDefaultEffect(audio_unique_id_t id);
-    virtual status_t removeStreamDefaultEffect(audio_unique_id_t id);
+    binder::Status onNewAudioModulesAvailable() override;
+    binder::Status setDeviceConnectionState(
+            const media::AudioDevice& device,
+            media::AudioPolicyDeviceState state,
+            const std::string& deviceName,
+            media::audio::common::AudioFormat encodedFormat) override;
+    binder::Status getDeviceConnectionState(const media::AudioDevice& device,
+                                            media::AudioPolicyDeviceState* _aidl_return) override;
+    binder::Status handleDeviceConfigChange(
+            const media::AudioDevice& device,
+            const std::string& deviceName,
+            media::audio::common::AudioFormat encodedFormat) override;
+    binder::Status setPhoneState(media::AudioMode state, int32_t uid) override;
+    binder::Status setForceUse(media::AudioPolicyForceUse usage,
+                               media::AudioPolicyForcedConfig config) override;
+    binder::Status getForceUse(media::AudioPolicyForceUse usage,
+                               media::AudioPolicyForcedConfig* _aidl_return) override;
+    binder::Status getOutput(media::AudioStreamType stream, int32_t* _aidl_return) override;
+    binder::Status getOutputForAttr(const media::AudioAttributesInternal& attr, int32_t session,
+                                    int32_t pid, int32_t uid, const media::AudioConfig& config,
+                                    int32_t flags,
+                                    media::GetOutputForAttrResponse* _aidl_return) override;
+    binder::Status startOutput(int32_t portId) override;
+    binder::Status stopOutput(int32_t portId) override;
+    binder::Status releaseOutput(int32_t portId) override;
+    binder::Status getInputForAttr(const media::AudioAttributesInternal& attr, int32_t input,
+                                   int32_t riid, int32_t session, int32_t pid, int32_t uid,
+                                   const std::string& opPackageName,
+                                   const media::AudioConfigBase& config, int32_t flags,
+                                   media::GetInputForAttrResponse* _aidl_return) override;
+    binder::Status startInput(int32_t portId) override;
+    binder::Status stopInput(int32_t portId) override;
+    binder::Status releaseInput(int32_t portId) override;
+    binder::Status initStreamVolume(media::AudioStreamType stream, int32_t indexMin,
+                                    int32_t indexMax) override;
+    binder::Status setStreamVolumeIndex(media::AudioStreamType stream, int32_t device,
+                                        int32_t index) override;
+    binder::Status getStreamVolumeIndex(media::AudioStreamType stream, int32_t device,
+                                        int32_t* _aidl_return) override;
+    binder::Status setVolumeIndexForAttributes(const media::AudioAttributesInternal& attr,
+                                               int32_t device, int32_t index) override;
+    binder::Status getVolumeIndexForAttributes(const media::AudioAttributesInternal& attr,
+                                               int32_t device, int32_t* _aidl_return) override;
+    binder::Status getMaxVolumeIndexForAttributes(const media::AudioAttributesInternal& attr,
+                                                  int32_t* _aidl_return) override;
+    binder::Status getMinVolumeIndexForAttributes(const media::AudioAttributesInternal& attr,
+                                                  int32_t* _aidl_return) override;
+    binder::Status getStrategyForStream(media::AudioStreamType stream,
+                                        int32_t* _aidl_return) override;
+    binder::Status getDevicesForStream(media::AudioStreamType stream,
+                                       int32_t* _aidl_return) override;
+    binder::Status getDevicesForAttributes(const media::AudioAttributesEx& attr,
+                                           std::vector<media::AudioDevice>* _aidl_return) override;
+    binder::Status getOutputForEffect(const media::EffectDescriptor& desc,
+                                      int32_t* _aidl_return) override;
+    binder::Status registerEffect(const media::EffectDescriptor& desc, int32_t io, int32_t strategy,
+                                  int32_t session, int32_t id) override;
+    binder::Status unregisterEffect(int32_t id) override;
+    binder::Status setEffectEnabled(int32_t id, bool enabled) override;
+    binder::Status moveEffectsToIo(const std::vector<int32_t>& ids, int32_t io) override;
+    binder::Status isStreamActive(media::AudioStreamType stream, int32_t inPastMs,
+                                  bool* _aidl_return) override;
+    binder::Status isStreamActiveRemotely(media::AudioStreamType stream, int32_t inPastMs,
+                                          bool* _aidl_return) override;
+    binder::Status isSourceActive(media::AudioSourceType source, bool* _aidl_return) override;
+    binder::Status queryDefaultPreProcessing(
+            int32_t audioSession, media::Int* count,
+            std::vector<media::EffectDescriptor>* _aidl_return) override;
+    binder::Status addSourceDefaultEffect(const media::AudioUuid& type,
+                                          const std::string& opPackageName,
+                                          const media::AudioUuid& uuid, int32_t priority,
+                                          media::AudioSourceType source,
+                                          int32_t* _aidl_return) override;
+    binder::Status addStreamDefaultEffect(const media::AudioUuid& type,
+                                          const std::string& opPackageName,
+                                          const media::AudioUuid& uuid, int32_t priority,
+                                          media::AudioUsage usage, int32_t* _aidl_return) override;
+    binder::Status removeSourceDefaultEffect(int32_t id) override;
+    binder::Status removeStreamDefaultEffect(int32_t id) override;
+    binder::Status setSupportedSystemUsages(
+            const std::vector<media::AudioUsage>& systemUsages) override;
+    binder::Status setAllowedCapturePolicy(int32_t uid, int32_t capturePolicy) override;
+    binder::Status getOffloadSupport(const media::AudioOffloadInfo& info,
+                                     media::AudioOffloadMode* _aidl_return) override;
+    binder::Status isDirectOutputSupported(const media::AudioConfigBase& config,
+                                           const media::AudioAttributesInternal& attributes,
+                                           bool* _aidl_return) override;
+    binder::Status listAudioPorts(media::AudioPortRole role, media::AudioPortType type,
+                                  media::Int* count, std::vector<media::AudioPort>* ports,
+                                  int32_t* _aidl_return) override;
+    binder::Status getAudioPort(const media::AudioPort& port,
+                                media::AudioPort* _aidl_return) override;
+    binder::Status createAudioPatch(const media::AudioPatch& patch, int32_t handle,
+                                    int32_t* _aidl_return) override;
+    binder::Status releaseAudioPatch(int32_t handle) override;
+    binder::Status listAudioPatches(media::Int* count, std::vector<media::AudioPatch>* patches,
+                                    int32_t* _aidl_return) override;
+    binder::Status setAudioPortConfig(const media::AudioPortConfig& config) override;
+    binder::Status registerClient(const sp<media::IAudioPolicyServiceClient>& client) override;
+    binder::Status setAudioPortCallbacksEnabled(bool enabled) override;
+    binder::Status setAudioVolumeGroupCallbacksEnabled(bool enabled) override;
+    binder::Status acquireSoundTriggerSession(media::SoundTriggerSession* _aidl_return) override;
+    binder::Status releaseSoundTriggerSession(int32_t session) override;
+    binder::Status getPhoneState(media::AudioMode* _aidl_return) override;
+    binder::Status registerPolicyMixes(const std::vector<media::AudioMix>& mixes,
+                                       bool registration) override;
+    binder::Status setUidDeviceAffinities(int32_t uid,
+                                          const std::vector<media::AudioDevice>& devices) override;
+    binder::Status removeUidDeviceAffinities(int32_t uid) override;
+    binder::Status setUserIdDeviceAffinities(
+            int32_t userId,
+            const std::vector<media::AudioDevice>& devices) override;
+    binder::Status removeUserIdDeviceAffinities(int32_t userId) override;
+    binder::Status startAudioSource(const media::AudioPortConfig& source,
+                                    const media::AudioAttributesInternal& attributes,
+                                    int32_t* _aidl_return) override;
+    binder::Status stopAudioSource(int32_t portId) override;
+    binder::Status setMasterMono(bool mono) override;
+    binder::Status getMasterMono(bool* _aidl_return) override;
+    binder::Status getStreamVolumeDB(media::AudioStreamType stream, int32_t index, int32_t device,
+                                     float* _aidl_return) override;
+    binder::Status getSurroundFormats(bool reported, media::Int* count,
+                                      std::vector<media::audio::common::AudioFormat>* formats,
+                                      bool* _aidl_return) override;
+    binder::Status getHwOffloadEncodingFormatsSupportedForA2DP(
+            std::vector<media::audio::common::AudioFormat>* _aidl_return) override;
+    binder::Status setSurroundFormatEnabled(media::audio::common::AudioFormat audioFormat,
+                                            bool enabled) override;
+    binder::Status setAssistantUid(int32_t uid) override;
+    binder::Status setA11yServicesUids(const std::vector<int32_t>& uids) override;
+    binder::Status setCurrentImeUid(int32_t uid) override;
+    binder::Status isHapticPlaybackSupported(bool* _aidl_return) override;
+    binder::Status listAudioProductStrategies(
+            std::vector<media::AudioProductStrategy>* _aidl_return) override;
+    binder::Status getProductStrategyFromAudioAttributes(const media::AudioAttributesEx& aa,
+                                                         int32_t* _aidl_return) override;
+    binder::Status listAudioVolumeGroups(
+            std::vector<media::AudioVolumeGroup>* _aidl_return) override;
+    binder::Status getVolumeGroupFromAudioAttributes(const media::AudioAttributesEx& aa,
+                                                     int32_t* _aidl_return) override;
+    binder::Status setRttEnabled(bool enabled) override;
+    binder::Status isCallScreenModeSupported(bool* _aidl_return) override;
+    binder::Status setDevicesRoleForStrategy(
+            int32_t strategy, media::DeviceRole role,
+            const std::vector<media::AudioDevice>& devices) override;
+    binder::Status removeDevicesRoleForStrategy(int32_t strategy, media::DeviceRole role) override;
+    binder::Status getDevicesForRoleAndStrategy(
+            int32_t strategy, media::DeviceRole role,
+            std::vector<media::AudioDevice>* _aidl_return) override;
+    binder::Status setDevicesRoleForCapturePreset(
+            media::AudioSourceType audioSource,
+            media::DeviceRole role,
+            const std::vector<media::AudioDevice>& devices) override;
+    binder::Status addDevicesRoleForCapturePreset(
+            media::AudioSourceType audioSource,
+            media::DeviceRole role,
+            const std::vector<media::AudioDevice>& devices) override;
+    binder::Status removeDevicesRoleForCapturePreset(
+            media::AudioSourceType audioSource,
+            media::DeviceRole role,
+            const std::vector<media::AudioDevice>& devices) override;
+    binder::Status clearDevicesRoleForCapturePreset(media::AudioSourceType audioSource,
+                                                    media::DeviceRole role) override;
+    binder::Status getDevicesForRoleAndCapturePreset(
+            media::AudioSourceType audioSource,
+            media::DeviceRole role,
+            std::vector<media::AudioDevice>* _aidl_return) override;
+    binder::Status registerSoundTriggerCaptureStateListener(
+            const sp<media::ICaptureStateListener>& listener, bool* _aidl_return) override;
 
     virtual     status_t    onTransact(
                                 uint32_t code,
@@ -190,170 +257,53 @@
                                      audio_io_handle_t output,
                                      int delayMs = 0);
     virtual status_t setVoiceVolume(float volume, int delayMs = 0);
-    status_t setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages);
-    status_t setAllowedCapturePolicy(uint_t uid, audio_flags_mask_t capturePolicy) override;
-    virtual audio_offload_mode_t getOffloadSupport(const audio_offload_info_t &config);
-    virtual bool isDirectOutputSupported(const audio_config_base_t& config,
-                                         const audio_attributes_t& attributes);
 
-    virtual status_t listAudioPorts(audio_port_role_t role,
-                                    audio_port_type_t type,
-                                    unsigned int *num_ports,
-                                    struct audio_port_v7 *ports,
-                                    unsigned int *generation);
-    virtual status_t getAudioPort(struct audio_port_v7 *port);
-    virtual status_t createAudioPatch(const struct audio_patch *patch,
-                                       audio_patch_handle_t *handle);
-    virtual status_t releaseAudioPatch(audio_patch_handle_t handle);
-    virtual status_t listAudioPatches(unsigned int *num_patches,
-                                      struct audio_patch *patches,
-                                      unsigned int *generation);
-    virtual status_t setAudioPortConfig(const struct audio_port_config *config);
+    void doOnNewAudioModulesAvailable();
+    status_t doStopOutput(audio_port_handle_t portId);
+    void doReleaseOutput(audio_port_handle_t portId);
 
-    virtual void registerClient(const sp<media::IAudioPolicyServiceClient>& client);
+    status_t clientCreateAudioPatch(const struct audio_patch *patch,
+                              audio_patch_handle_t *handle,
+                              int delayMs);
+    status_t clientReleaseAudioPatch(audio_patch_handle_t handle,
+                                     int delayMs);
+    virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config,
+                                              int delayMs);
 
-    virtual void setAudioPortCallbacksEnabled(bool enabled);
+    void removeNotificationClient(uid_t uid, pid_t pid);
+    void onAudioPortListUpdate();
+    void doOnAudioPortListUpdate();
+    void onAudioPatchListUpdate();
+    void doOnAudioPatchListUpdate();
 
-    virtual void setAudioVolumeGroupCallbacksEnabled(bool enabled);
+    void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
+    void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
+    void onRecordingConfigurationUpdate(int event,
+                                        const record_client_info_t *clientInfo,
+                                        const audio_config_base_t *clientConfig,
+                                        std::vector<effect_descriptor_t> clientEffects,
+                                        const audio_config_base_t *deviceConfig,
+                                        std::vector<effect_descriptor_t> effects,
+                                        audio_patch_handle_t patchHandle,
+                                        audio_source_t source);
+    void doOnRecordingConfigurationUpdate(int event,
+                                          const record_client_info_t *clientInfo,
+                                          const audio_config_base_t *clientConfig,
+                                          std::vector<effect_descriptor_t> clientEffects,
+                                          const audio_config_base_t *deviceConfig,
+                                          std::vector<effect_descriptor_t> effects,
+                                          audio_patch_handle_t patchHandle,
+                                          audio_source_t source);
 
-    virtual status_t acquireSoundTriggerSession(audio_session_t *session,
-                                           audio_io_handle_t *ioHandle,
-                                           audio_devices_t *device);
+    void onAudioVolumeGroupChanged(volume_group_t group, int flags);
+    void doOnAudioVolumeGroupChanged(volume_group_t group, int flags);
 
-    virtual status_t releaseSoundTriggerSession(audio_session_t session);
+    void onRoutingUpdated();
+    void doOnRoutingUpdated();
 
-    virtual audio_mode_t getPhoneState();
-
-    virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration);
-
-    virtual status_t setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices);
-
-    virtual status_t removeUidDeviceAffinities(uid_t uid);
-
-    virtual status_t setDevicesRoleForStrategy(product_strategy_t strategy,
-                                               device_role_t role,
-                                               const AudioDeviceTypeAddrVector &devices);
-
-    virtual status_t removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role);
-
-    virtual status_t getDevicesForRoleAndStrategy(product_strategy_t strategy,
-                                                  device_role_t role,
-                                                  AudioDeviceTypeAddrVector &devices);
-
-    virtual status_t setDevicesRoleForCapturePreset(audio_source_t audioSource,
-                                                    device_role_t role,
-                                                    const AudioDeviceTypeAddrVector &devices);
-
-    virtual status_t addDevicesRoleForCapturePreset(audio_source_t audioSource,
-                                                    device_role_t role,
-                                                    const AudioDeviceTypeAddrVector &devices);
-
-    virtual status_t removeDevicesRoleForCapturePreset(
-            audio_source_t audioSource, device_role_t role,
-            const AudioDeviceTypeAddrVector& devices);
-
-    virtual status_t clearDevicesRoleForCapturePreset(audio_source_t audioSource,
-                                                      device_role_t role);
-
-    virtual status_t getDevicesForRoleAndCapturePreset(audio_source_t audioSource,
-                                                       device_role_t role,
-                                                       AudioDeviceTypeAddrVector &devices);
-
-    virtual status_t setUserIdDeviceAffinities(int userId,
-            const AudioDeviceTypeAddrVector& devices);
-
-    virtual status_t removeUserIdDeviceAffinities(int userId);
-
-    virtual status_t startAudioSource(const struct audio_port_config *source,
-                                      const audio_attributes_t *attributes,
-                                      audio_port_handle_t *portId);
-    virtual status_t stopAudioSource(audio_port_handle_t portId);
-
-    virtual status_t setMasterMono(bool mono);
-    virtual status_t getMasterMono(bool *mono);
-
-    virtual float    getStreamVolumeDB(
-                audio_stream_type_t stream, int index, audio_devices_t device);
-
-    virtual status_t getSurroundFormats(unsigned int *numSurroundFormats,
-                                        audio_format_t *surroundFormats,
-                                        bool *surroundFormatsEnabled,
-                                        bool reported);
-    virtual status_t getHwOffloadEncodingFormatsSupportedForA2DP(
-                                        std::vector<audio_format_t> *formats);
-    virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled);
-
-    virtual status_t setAssistantUid(uid_t uid);
-    virtual status_t setA11yServicesUids(const std::vector<uid_t>& uids);
-    virtual status_t setCurrentImeUid(uid_t uid);
-
-    virtual bool     isHapticPlaybackSupported();
-
-    virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies);
-    virtual status_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
-                                                           product_strategy_t &productStrategy);
-
-    virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups);
-
-    virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
-                                                       volume_group_t &volumeGroup);
-
-    status_t registerSoundTriggerCaptureStateListener(
-        const sp<media::ICaptureStateListener>& listener,
-        bool* result) override;
-
-    virtual status_t setRttEnabled(bool enabled);
-
-    virtual bool isUserSensorPrivacyEnabledForUid(uid_t uid);
-
-            bool isCallScreenModeSupported() override;
-
-            void doOnNewAudioModulesAvailable();
-            status_t doStopOutput(audio_port_handle_t portId);
-            void doReleaseOutput(audio_port_handle_t portId);
-
-            status_t clientCreateAudioPatch(const struct audio_patch *patch,
-                                      audio_patch_handle_t *handle,
-                                      int delayMs);
-            status_t clientReleaseAudioPatch(audio_patch_handle_t handle,
-                                             int delayMs);
-            virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config,
-                                                      int delayMs);
-
-            void removeNotificationClient(uid_t uid, pid_t pid);
-            void onAudioPortListUpdate();
-            void doOnAudioPortListUpdate();
-            void onAudioPatchListUpdate();
-            void doOnAudioPatchListUpdate();
-
-            void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
-            void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
-            void onRecordingConfigurationUpdate(int event,
-                                                const record_client_info_t *clientInfo,
-                                                const audio_config_base_t *clientConfig,
-                                                std::vector<effect_descriptor_t> clientEffects,
-                                                const audio_config_base_t *deviceConfig,
-                                                std::vector<effect_descriptor_t> effects,
-                                                audio_patch_handle_t patchHandle,
-                                                audio_source_t source);
-            void doOnRecordingConfigurationUpdate(int event,
-                                                  const record_client_info_t *clientInfo,
-                                                  const audio_config_base_t *clientConfig,
-                                                  std::vector<effect_descriptor_t> clientEffects,
-                                                  const audio_config_base_t *deviceConfig,
-                                                  std::vector<effect_descriptor_t> effects,
-                                                  audio_patch_handle_t patchHandle,
-                                                  audio_source_t source);
-
-            void onAudioVolumeGroupChanged(volume_group_t group, int flags);
-            void doOnAudioVolumeGroupChanged(volume_group_t group, int flags);
-
-            void onRoutingUpdated();
-            void doOnRoutingUpdated();
-
-            void setEffectSuspended(int effectId,
-                                    audio_session_t sessionId,
-                                    bool suspended);
+    void setEffectSuspended(int effectId,
+                            audio_session_t sessionId,
+                            bool suspended);
 
 private:
                         AudioPolicyService() ANDROID_API;
@@ -389,6 +339,8 @@
     status_t validateUsage(audio_usage_t usage);
     status_t validateUsage(audio_usage_t usage, pid_t pid, uid_t uid);
 
+    bool isUserSensorPrivacyEnabledForUid(uid_t uid);
+
     void updateUidStates();
     void updateUidStates_l() REQUIRES(mLock);
 
diff --git a/services/camera/libcameraservice/device3/Camera3Device.cpp b/services/camera/libcameraservice/device3/Camera3Device.cpp
index e80404b..db6d3cf 100644
--- a/services/camera/libcameraservice/device3/Camera3Device.cpp
+++ b/services/camera/libcameraservice/device3/Camera3Device.cpp
@@ -4694,6 +4694,10 @@
                 buffer.status = CAMERA_BUFFER_STATUS_OK;
                 buffer.acquire_fence = -1;
                 buffer.release_fence = -1;
+                // Mark the output stream as unpreparable to block clients from calling
+                // 'prepare' after this request reaches CameraHal and before the respective
+                // buffers are requested.
+                outputStream->markUnpreparable();
             } else {
                 res = outputStream->getBuffer(&outputBuffers->editItemAt(j),
                         waitDuration,
diff --git a/services/camera/libcameraservice/device3/Camera3Stream.cpp b/services/camera/libcameraservice/device3/Camera3Stream.cpp
index 8d72b4c..ffdb90b 100644
--- a/services/camera/libcameraservice/device3/Camera3Stream.cpp
+++ b/services/camera/libcameraservice/device3/Camera3Stream.cpp
@@ -417,6 +417,13 @@
     return mStreamUnpreparable;
 }
 
+void Camera3Stream::markUnpreparable() {
+    ATRACE_CALL();
+
+    Mutex::Autolock l(mLock);
+    mStreamUnpreparable = true;
+}
+
 status_t Camera3Stream::startPrepare(int maxCount, bool blockRequest) {
     ATRACE_CALL();
 
diff --git a/services/camera/libcameraservice/device3/Camera3Stream.h b/services/camera/libcameraservice/device3/Camera3Stream.h
index 47dc252..72914f8 100644
--- a/services/camera/libcameraservice/device3/Camera3Stream.h
+++ b/services/camera/libcameraservice/device3/Camera3Stream.h
@@ -223,6 +223,11 @@
     bool             isUnpreparable();
 
     /**
+     * Mark the stream as unpreparable.
+     */
+    void             markUnpreparable() override;
+
+    /**
      * Start stream preparation. May only be called in the CONFIGURED state,
      * when no valid buffers have yet been returned to this stream. Prepares
      * up to maxCount buffers, or the maximum number of buffers needed by the
diff --git a/services/camera/libcameraservice/device3/Camera3StreamInterface.h b/services/camera/libcameraservice/device3/Camera3StreamInterface.h
index b48636e..d417252 100644
--- a/services/camera/libcameraservice/device3/Camera3StreamInterface.h
+++ b/services/camera/libcameraservice/device3/Camera3StreamInterface.h
@@ -207,6 +207,11 @@
     virtual bool     isUnpreparable() = 0;
 
     /**
+     * Mark the stream as unpreparable.
+     */
+    virtual void     markUnpreparable() = 0;
+
+    /**
      * Start stream preparation. May only be called in the CONFIGURED state,
      * when no valid buffers have yet been returned to this stream. Prepares
      * up to maxCount buffers, or the maximum number of buffers needed by the
diff --git a/services/tuner/TunerService.cpp b/services/tuner/TunerService.cpp
index f97cbfe..cbcea91 100644
--- a/services/tuner/TunerService.cpp
+++ b/services/tuner/TunerService.cpp
@@ -17,6 +17,7 @@
 #define LOG_TAG "TunerService"
 
 #include <android/binder_manager.h>
+#include <fmq/ConvertMQDescriptors.h>
 #include <utils/Log.h>
 #include "TunerService.h"
 #include "TunerFrontend.h"
@@ -57,50 +58,6 @@
     AServiceManager_addService(service->asBinder().get(), getServiceName());
 }
 
-template <typename HidlPayload, typename AidlPayload, typename AidlFlavor>
-bool TunerService::unsafeHidlToAidlMQDescriptor(
-        const hardware::MQDescriptor<HidlPayload, FlavorTypeToValue<AidlFlavor>::value>& hidlDesc,
-        MQDescriptor<AidlPayload, AidlFlavor>* aidlDesc) {
-    // TODO: use the builtin coversion method when it's merged.
-    ALOGD("unsafeHidlToAidlMQDescriptor");
-    static_assert(sizeof(HidlPayload) == sizeof(AidlPayload), "Payload types are incompatible");
-    static_assert(
-            has_typedef_fixed_size<AidlPayload>::value == true ||
-            is_fundamental<AidlPayload>::value ||
-            is_enum<AidlPayload>::value,
-            "Only fundamental types, enums, and AIDL parcelables annotated with @FixedSize "
-            "and built for the NDK backend are supported as AIDL payload types.");
-    aidlDesc->fileDescriptor = ndk::ScopedFileDescriptor(dup(hidlDesc.handle()->data[0]));
-    for (const auto& grantor : hidlDesc.grantors()) {
-        if (static_cast<int32_t>(grantor.offset) < 0 || static_cast<int64_t>(grantor.extent) < 0) {
-            ALOGD("Unsafe static_cast of grantor fields. offset=%d, extend=%ld",
-                    static_cast<int32_t>(grantor.offset), static_cast<long>(grantor.extent));
-            logError(
-                    "Unsafe static_cast of grantor fields. Either the hardware::MQDescriptor is "
-                    "invalid, or the MessageQueue is too large to be described by AIDL.");
-            return false;
-        }
-        aidlDesc->grantors.push_back(
-                GrantorDescriptor {
-                        .offset = static_cast<int32_t>(grantor.offset),
-                        .extent = static_cast<int64_t>(grantor.extent)
-                });
-    }
-    if (static_cast<int32_t>(hidlDesc.getQuantum()) < 0 ||
-            static_cast<int32_t>(hidlDesc.getFlags()) < 0) {
-        ALOGD("Unsafe static_cast of quantum or flags. Quantum=%d, flags=%d",
-                static_cast<int32_t>(hidlDesc.getQuantum()),
-                static_cast<int32_t>(hidlDesc.getFlags()));
-        logError(
-                "Unsafe static_cast of quantum or flags. Either the hardware::MQDescriptor is "
-                "invalid, or the MessageQueue is too large to be described by AIDL.");
-        return false;
-    }
-    aidlDesc->quantum = static_cast<int32_t>(hidlDesc.getQuantum());
-    aidlDesc->flags = static_cast<int32_t>(hidlDesc.getFlags());
-    return true;
-}
-
 bool TunerService::getITuner() {
     ALOGD("getITuner");
     if (mTuner != nullptr) {
diff --git a/services/tuner/TunerService.h b/services/tuner/TunerService.h
index 197e4f3..856b54a 100644
--- a/services/tuner/TunerService.h
+++ b/services/tuner/TunerService.h
@@ -105,11 +105,6 @@
     Status openDemux(int32_t demuxHandle, std::shared_ptr<ITunerDemux>* _aidl_return) override;
 
 private:
-    template <typename HidlPayload, typename AidlPayload, typename AidlFlavor>
-    bool unsafeHidlToAidlMQDescriptor(
-            const hardware::MQDescriptor<HidlPayload, FlavorTypeToValue<AidlFlavor>::value>& hidl,
-            MQDescriptor<AidlPayload, AidlFlavor>* aidl);
-
     bool getITuner();
     Result configFilter();