You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
470 lines
18 KiB
470 lines
18 KiB
/*
|
|
* 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
|