Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 10506121 authored by Mikhail Naganov's avatar Mikhail Naganov
Browse files

audio: Add fields belonged to APM XSD schema to HAL structs 

Since APM XML configuration is being replaced with data
provided by the HAL, add data fields used to be in the APM XSD
schema to HAL structures. Summary of changes:

- Audio*Flags enum types moved to HAL types because flags
  are specified for mixPorts in the APM config;
- AudioGainSys.useForVolume -> AudioGain
- added AudioPort.flags because they are specified in the
  APM config for mixPorts; since AudioIoFlags is a union,
  it will be used for determining the mix port role;
- AudioPortConfigSys.flags -> AudioPortConfig
  this is for symmetry with AudioPort;

In C++:
- DeviceDescriptor.mEncodedFormats -> DeviceDescriptorBase
- IOProfile.max{Open|Active}Count -> AudioPort
- IOProfile.recommendedMuteDurationMs -> AudioPort

Flags are not moved out from PolicyAudioPort to AudioPort as it's
a non-trivial change.

Bug: 198812639
Test: atest audiofoundation_parcelable_test
Test: atest audiopolicy_tests
Change-Id: I7aca107f7e7f20c6cd97080327cb9e4589cbe544
parent bad5fbf1

media/libaudioclient/AidlConversion.cpp

+90 −84
Original line number Diff line number Diff line
@@ -50,8 +50,12 @@ using media::audio::common::AudioFormatType; 
using media::audio::common::AudioGain;

using media::audio::common::AudioGainConfig;

using media::audio::common::AudioGainMode;

using media::audio::common::AudioInputFlags;

using media::audio::common::AudioIoFlags;

using media::audio::common::AudioMode;

using media::audio::common::AudioOffloadInfo;

using media::audio::common::AudioOutputFlags;

using media::audio::common::AudioPortDeviceExt;

using media::audio::common::AudioPortExt;

using media::audio::common::AudioPortMixExt;

using media::audio::common::AudioPortMixExtUseCase;
@@ -1281,129 +1285,129 @@ ConversionResult<AudioGainConfig> legacy2aidl_audio_gain_config_AudioGainConfig( 
}



ConversionResult<audio_input_flags_t> aidl2legacy_AudioInputFlags_audio_input_flags_t(

        media::AudioInputFlags aidl) {

        AudioInputFlags aidl) {

    switch (aidl) {

        case media::AudioInputFlags::FAST:

        case AudioInputFlags::FAST:

            return AUDIO_INPUT_FLAG_FAST;

        case media::AudioInputFlags::HW_HOTWORD:

        case AudioInputFlags::HW_HOTWORD:

            return AUDIO_INPUT_FLAG_HW_HOTWORD;

        case media::AudioInputFlags::RAW:

        case AudioInputFlags::RAW:

            return AUDIO_INPUT_FLAG_RAW;

        case media::AudioInputFlags::SYNC:

        case AudioInputFlags::SYNC:

            return AUDIO_INPUT_FLAG_SYNC;

        case media::AudioInputFlags::MMAP_NOIRQ:

        case AudioInputFlags::MMAP_NOIRQ:

            return AUDIO_INPUT_FLAG_MMAP_NOIRQ;

        case media::AudioInputFlags::VOIP_TX:

        case AudioInputFlags::VOIP_TX:

            return AUDIO_INPUT_FLAG_VOIP_TX;

        case media::AudioInputFlags::HW_AV_SYNC:

        case AudioInputFlags::HW_AV_SYNC:

            return AUDIO_INPUT_FLAG_HW_AV_SYNC;

        case media::AudioInputFlags::DIRECT:

        case AudioInputFlags::DIRECT:

            return AUDIO_INPUT_FLAG_DIRECT;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<media::AudioInputFlags> legacy2aidl_audio_input_flags_t_AudioInputFlags(

ConversionResult<AudioInputFlags> legacy2aidl_audio_input_flags_t_AudioInputFlags(

        audio_input_flags_t legacy) {

    switch (legacy) {

        case AUDIO_INPUT_FLAG_NONE:

            break; // shouldn't get here. must be listed  -Werror,-Wswitch

        case AUDIO_INPUT_FLAG_FAST:

            return media::AudioInputFlags::FAST;

            return AudioInputFlags::FAST;

        case AUDIO_INPUT_FLAG_HW_HOTWORD:

            return media::AudioInputFlags::HW_HOTWORD;

            return AudioInputFlags::HW_HOTWORD;

        case AUDIO_INPUT_FLAG_RAW:

            return media::AudioInputFlags::RAW;

            return AudioInputFlags::RAW;

        case AUDIO_INPUT_FLAG_SYNC:

            return media::AudioInputFlags::SYNC;

            return AudioInputFlags::SYNC;

        case AUDIO_INPUT_FLAG_MMAP_NOIRQ:

            return media::AudioInputFlags::MMAP_NOIRQ;

            return AudioInputFlags::MMAP_NOIRQ;

        case AUDIO_INPUT_FLAG_VOIP_TX:

            return media::AudioInputFlags::VOIP_TX;

            return AudioInputFlags::VOIP_TX;

        case AUDIO_INPUT_FLAG_HW_AV_SYNC:

            return media::AudioInputFlags::HW_AV_SYNC;

            return AudioInputFlags::HW_AV_SYNC;

        case AUDIO_INPUT_FLAG_DIRECT:

            return media::AudioInputFlags::DIRECT;

            return AudioInputFlags::DIRECT;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<audio_output_flags_t> aidl2legacy_AudioOutputFlags_audio_output_flags_t(

        media::AudioOutputFlags aidl) {

        AudioOutputFlags aidl) {

    switch (aidl) {

        case media::AudioOutputFlags::DIRECT:

        case AudioOutputFlags::DIRECT:

            return AUDIO_OUTPUT_FLAG_DIRECT;

        case media::AudioOutputFlags::PRIMARY:

        case AudioOutputFlags::PRIMARY:

            return AUDIO_OUTPUT_FLAG_PRIMARY;

        case media::AudioOutputFlags::FAST:

        case AudioOutputFlags::FAST:

            return AUDIO_OUTPUT_FLAG_FAST;

        case media::AudioOutputFlags::DEEP_BUFFER:

        case AudioOutputFlags::DEEP_BUFFER:

            return AUDIO_OUTPUT_FLAG_DEEP_BUFFER;

        case media::AudioOutputFlags::COMPRESS_OFFLOAD:

        case AudioOutputFlags::COMPRESS_OFFLOAD:

            return AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD;

        case media::AudioOutputFlags::NON_BLOCKING:

        case AudioOutputFlags::NON_BLOCKING:

            return AUDIO_OUTPUT_FLAG_NON_BLOCKING;

        case media::AudioOutputFlags::HW_AV_SYNC:

        case AudioOutputFlags::HW_AV_SYNC:

            return AUDIO_OUTPUT_FLAG_HW_AV_SYNC;

        case media::AudioOutputFlags::TTS:

        case AudioOutputFlags::TTS:

            return AUDIO_OUTPUT_FLAG_TTS;

        case media::AudioOutputFlags::RAW:

        case AudioOutputFlags::RAW:

            return AUDIO_OUTPUT_FLAG_RAW;

        case media::AudioOutputFlags::SYNC:

        case AudioOutputFlags::SYNC:

            return AUDIO_OUTPUT_FLAG_SYNC;

        case media::AudioOutputFlags::IEC958_NONAUDIO:

        case AudioOutputFlags::IEC958_NONAUDIO:

            return AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO;

        case media::AudioOutputFlags::DIRECT_PCM:

        case AudioOutputFlags::DIRECT_PCM:

            return AUDIO_OUTPUT_FLAG_DIRECT_PCM;

        case media::AudioOutputFlags::MMAP_NOIRQ:

        case AudioOutputFlags::MMAP_NOIRQ:

            return AUDIO_OUTPUT_FLAG_MMAP_NOIRQ;

        case media::AudioOutputFlags::VOIP_RX:

        case AudioOutputFlags::VOIP_RX:

            return AUDIO_OUTPUT_FLAG_VOIP_RX;

        case media::AudioOutputFlags::INCALL_MUSIC:

        case AudioOutputFlags::INCALL_MUSIC:

            return AUDIO_OUTPUT_FLAG_INCALL_MUSIC;

        case media::AudioOutputFlags::GAPLESS_OFFLOAD:

        case AudioOutputFlags::GAPLESS_OFFLOAD:

            return AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<media::AudioOutputFlags> legacy2aidl_audio_output_flags_t_AudioOutputFlags(

ConversionResult<AudioOutputFlags> legacy2aidl_audio_output_flags_t_AudioOutputFlags(

        audio_output_flags_t legacy) {

    switch (legacy) {

        case AUDIO_OUTPUT_FLAG_NONE:

            break; // shouldn't get here. must be listed  -Werror,-Wswitch

        case AUDIO_OUTPUT_FLAG_DIRECT:

            return media::AudioOutputFlags::DIRECT;

            return AudioOutputFlags::DIRECT;

        case AUDIO_OUTPUT_FLAG_PRIMARY:

            return media::AudioOutputFlags::PRIMARY;

            return AudioOutputFlags::PRIMARY;

        case AUDIO_OUTPUT_FLAG_FAST:

            return media::AudioOutputFlags::FAST;

            return AudioOutputFlags::FAST;

        case AUDIO_OUTPUT_FLAG_DEEP_BUFFER:

            return media::AudioOutputFlags::DEEP_BUFFER;

            return AudioOutputFlags::DEEP_BUFFER;

        case AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD:

            return media::AudioOutputFlags::COMPRESS_OFFLOAD;

            return AudioOutputFlags::COMPRESS_OFFLOAD;

        case AUDIO_OUTPUT_FLAG_NON_BLOCKING:

            return media::AudioOutputFlags::NON_BLOCKING;

            return AudioOutputFlags::NON_BLOCKING;

        case AUDIO_OUTPUT_FLAG_HW_AV_SYNC:

            return media::AudioOutputFlags::HW_AV_SYNC;

            return AudioOutputFlags::HW_AV_SYNC;

        case AUDIO_OUTPUT_FLAG_TTS:

            return media::AudioOutputFlags::TTS;

            return AudioOutputFlags::TTS;

        case AUDIO_OUTPUT_FLAG_RAW:

            return media::AudioOutputFlags::RAW;

            return AudioOutputFlags::RAW;

        case AUDIO_OUTPUT_FLAG_SYNC:

            return media::AudioOutputFlags::SYNC;

            return AudioOutputFlags::SYNC;

        case AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO:

            return media::AudioOutputFlags::IEC958_NONAUDIO;

            return AudioOutputFlags::IEC958_NONAUDIO;

        case AUDIO_OUTPUT_FLAG_DIRECT_PCM:

            return media::AudioOutputFlags::DIRECT_PCM;

            return AudioOutputFlags::DIRECT_PCM;

        case AUDIO_OUTPUT_FLAG_MMAP_NOIRQ:

            return media::AudioOutputFlags::MMAP_NOIRQ;

            return AudioOutputFlags::MMAP_NOIRQ;

        case AUDIO_OUTPUT_FLAG_VOIP_RX:

            return media::AudioOutputFlags::VOIP_RX;

            return AudioOutputFlags::VOIP_RX;

        case AUDIO_OUTPUT_FLAG_INCALL_MUSIC:

            return media::AudioOutputFlags::INCALL_MUSIC;

            return AudioOutputFlags::INCALL_MUSIC;

        case AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD:

            return media::AudioOutputFlags::GAPLESS_OFFLOAD;

            return AudioOutputFlags::GAPLESS_OFFLOAD;

    }

    return unexpected(BAD_VALUE);

}
@@ -1413,9 +1417,9 @@ ConversionResult<audio_input_flags_t> aidl2legacy_int32_t_audio_input_flags_t_ma 
    using LegacyMask = std::underlying_type_t<audio_input_flags_t>;



    LegacyMask converted = VALUE_OR_RETURN(

            (convertBitmask<LegacyMask, int32_t, audio_input_flags_t, media::AudioInputFlags>(

            (convertBitmask<LegacyMask, int32_t, audio_input_flags_t, AudioInputFlags>(

                    aidl, aidl2legacy_AudioInputFlags_audio_input_flags_t,

                    indexToEnum_index<media::AudioInputFlags>,

                    indexToEnum_index<AudioInputFlags>,

                    enumToMask_bitmask<LegacyMask, audio_input_flags_t>)));

    return static_cast<audio_input_flags_t>(converted);

}
@@ -1425,10 +1429,10 @@ ConversionResult<int32_t> legacy2aidl_audio_input_flags_t_int32_t_mask( 
    using LegacyMask = std::underlying_type_t<audio_input_flags_t>;



    LegacyMask legacyMask = static_cast<LegacyMask>(legacy);

    return convertBitmask<int32_t, LegacyMask, media::AudioInputFlags, audio_input_flags_t>(

    return convertBitmask<int32_t, LegacyMask, AudioInputFlags, audio_input_flags_t>(

            legacyMask, legacy2aidl_audio_input_flags_t_AudioInputFlags,

            indexToEnum_bitmask<audio_input_flags_t>,

            enumToMask_index<int32_t, media::AudioInputFlags>);

            enumToMask_index<int32_t, AudioInputFlags>);

}



ConversionResult<audio_output_flags_t> aidl2legacy_int32_t_audio_output_flags_t_mask(
@@ -1436,9 +1440,9 @@ ConversionResult<audio_output_flags_t> aidl2legacy_int32_t_audio_output_flags_t_ 
    return convertBitmask<audio_output_flags_t,

            int32_t,

            audio_output_flags_t,

            media::AudioOutputFlags>(

            AudioOutputFlags>(

            aidl, aidl2legacy_AudioOutputFlags_audio_output_flags_t,

            indexToEnum_index<media::AudioOutputFlags>,

            indexToEnum_index<AudioOutputFlags>,

            enumToMask_bitmask<audio_output_flags_t, audio_output_flags_t>);

}
@@ -1447,14 +1451,14 @@ ConversionResult<int32_t> legacy2aidl_audio_output_flags_t_int32_t_mask( 
    using LegacyMask = std::underlying_type_t<audio_output_flags_t>;



    LegacyMask legacyMask = static_cast<LegacyMask>(legacy);

    return convertBitmask<int32_t, LegacyMask, media::AudioOutputFlags, audio_output_flags_t>(

    return convertBitmask<int32_t, LegacyMask, AudioOutputFlags, audio_output_flags_t>(

            legacyMask, legacy2aidl_audio_output_flags_t_AudioOutputFlags,

            indexToEnum_bitmask<audio_output_flags_t>,

            enumToMask_index<int32_t, media::AudioOutputFlags>);

            enumToMask_index<int32_t, AudioOutputFlags>);

}



ConversionResult<audio_io_flags> aidl2legacy_AudioIoFlags_audio_io_flags(

        const media::AudioIoFlags& aidl, media::AudioPortRole role, media::AudioPortType type) {

        const AudioIoFlags& aidl, media::AudioPortRole role, media::AudioPortType type) {

    audio_io_flags legacy;

    Direction dir = VALUE_OR_RETURN(direction(role, type));

    switch (dir) {
@@ -1476,9 +1480,9 @@ ConversionResult<audio_io_flags> aidl2legacy_AudioIoFlags_audio_io_flags( 
    return legacy;

}



ConversionResult<media::AudioIoFlags> legacy2aidl_audio_io_flags_AudioIoFlags(

ConversionResult<AudioIoFlags> legacy2aidl_audio_io_flags_AudioIoFlags(

        const audio_io_flags& legacy, audio_port_role_t role, audio_port_type_t type) {

    media::AudioIoFlags aidl;

    AudioIoFlags aidl;



    Direction dir = VALUE_OR_RETURN(direction(role, type));

    switch (dir) {
@@ -1497,21 +1501,22 @@ ConversionResult<media::AudioIoFlags> legacy2aidl_audio_io_flags_AudioIoFlags( 
}



ConversionResult<audio_port_config_device_ext>

aidl2legacy_AudioDevice_audio_port_config_device_ext(

        const AudioDevice& aidl, const media::AudioPortDeviceExtSys& aidlDeviceExt) {

aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(

        const AudioPortDeviceExt& aidl, const media::AudioPortDeviceExtSys& aidlDeviceExt) {

    audio_port_config_device_ext legacy;

    legacy.hw_module = VALUE_OR_RETURN(

            aidl2legacy_int32_t_audio_module_handle_t(aidlDeviceExt.hwModule));

    RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(aidl, &legacy.type, legacy.address));

    RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(

                    aidl.device, &legacy.type, legacy.address));

    return legacy;

}



status_t legacy2aidl_audio_port_config_device_ext_AudioDevice(

status_t legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt(

        const audio_port_config_device_ext& legacy,

        AudioDevice* aidl, media::AudioPortDeviceExtSys* aidlDeviceExt) {

        AudioPortDeviceExt* aidl, media::AudioPortDeviceExtSys* aidlDeviceExt) {

    aidlDeviceExt->hwModule = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));

    *aidl = VALUE_OR_RETURN_STATUS(

    aidl->device = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_device_AudioDevice(legacy.type, legacy.address));

    return OK;

}
@@ -1777,7 +1782,7 @@ ConversionResult<audio_port_config_ext> aidl2legacy_AudioPortExt_audio_port_conf 
            return legacy;

        case media::AudioPortType::DEVICE:

            legacy.device = VALUE_OR_RETURN(

                    aidl2legacy_AudioDevice_audio_port_config_device_ext(

                    aidl2legacy_AudioPortDeviceExt_audio_port_config_device_ext(

                            VALUE_OR_RETURN(UNION_GET(aidl, device)),

                            VALUE_OR_RETURN(UNION_GET(aidlSys, device))));

            return legacy;
@@ -1806,10 +1811,10 @@ status_t legacy2aidl_AudioPortExt( 
            UNION_SET(*aidlSys, unspecified, false);

            return OK;

        case AUDIO_PORT_TYPE_DEVICE: {

            AudioDevice device;

            AudioPortDeviceExt device;

            media::AudioPortDeviceExtSys deviceSys;

            RETURN_STATUS_IF_ERROR(

                    legacy2aidl_audio_port_config_device_ext_AudioDevice(

                    legacy2aidl_audio_port_config_device_ext_AudioPortDeviceExt(

                            legacy.device, &device, &deviceSys));

            UNION_SET(*aidl, device, device);

            UNION_SET(*aidlSys, device, deviceSys);
@@ -1862,10 +1867,10 @@ ConversionResult<audio_port_config> aidl2legacy_AudioPortConfig_audio_port_confi 
                        aidl.hal.gain.value(), isInput));

        legacy.config_mask |= AUDIO_PORT_CONFIG_GAIN;

    }

    if (aidl.sys.flags.has_value()) {

    if (aidl.hal.flags.has_value()) {

        legacy.flags = VALUE_OR_RETURN(

                aidl2legacy_AudioIoFlags_audio_io_flags(

                        aidl.sys.flags.value(), aidl.sys.role, aidl.sys.type));

                        aidl.hal.flags.value(), aidl.sys.role, aidl.sys.type));

        legacy.config_mask |= AUDIO_PORT_CONFIG_FLAGS;

    }

    legacy.ext = VALUE_OR_RETURN(
@@ -1900,7 +1905,7 @@ ConversionResult<media::AudioPortConfig> legacy2aidl_audio_port_config_AudioPort 
                legacy2aidl_audio_gain_config_AudioGainConfig(legacy.gain, isInput));

    }

    if (legacy.config_mask & AUDIO_PORT_CONFIG_FLAGS) {

        aidl.sys.flags = VALUE_OR_RETURN(

        aidl.hal.flags = VALUE_OR_RETURN(

                legacy2aidl_audio_io_flags_AudioIoFlags(legacy.flags, legacy.role, legacy.type));

    }

    RETURN_IF_ERROR(legacy2aidl_AudioPortExt(legacy.ext, legacy.type, legacy.role,
@@ -2581,12 +2586,13 @@ legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy) { 
}



ConversionResult<audio_port_device_ext>

aidl2legacy_AudioDevice_audio_port_device_ext(

        const AudioDevice& aidl, const media::AudioPortDeviceExtSys& aidlSys) {

aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(

        const AudioPortDeviceExt& aidl, const media::AudioPortDeviceExtSys& aidlSys) {

    audio_port_device_ext legacy;

    legacy.hw_module = VALUE_OR_RETURN(

            aidl2legacy_int32_t_audio_module_handle_t(aidlSys.hwModule));

    RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(aidl, &legacy.type, legacy.address));

    RETURN_IF_ERROR(aidl2legacy_AudioDevice_audio_device(

                    aidl.device, &legacy.type, legacy.address));

    legacy.encapsulation_modes = VALUE_OR_RETURN(

            aidl2legacy_AudioEncapsulationMode_mask(aidlSys.encapsulationModes));

    legacy.encapsulation_metadata_types = VALUE_OR_RETURN(
@@ -2595,12 +2601,12 @@ aidl2legacy_AudioDevice_audio_port_device_ext( 
    return legacy;

}



status_t legacy2aidl_audio_port_device_ext_AudioDevice(

status_t legacy2aidl_audio_port_device_ext_AudioPortDeviceExt(

        const audio_port_device_ext& legacy,

        AudioDevice* aidl, media::AudioPortDeviceExtSys* aidlDeviceExt) {

        AudioPortDeviceExt* aidl, media::AudioPortDeviceExtSys* aidlDeviceExt) {

    aidlDeviceExt->hwModule = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_module_handle_t_int32_t(legacy.hw_module));

    *aidl = VALUE_OR_RETURN_STATUS(

    aidl->device = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_device_AudioDevice(legacy.type, legacy.address));

    aidlDeviceExt->encapsulationModes = VALUE_OR_RETURN_STATUS(

            legacy2aidl_AudioEncapsulationMode_mask(legacy.encapsulation_modes));
@@ -2653,7 +2659,7 @@ ConversionResult<audio_port_v7_ext> aidl2legacy_AudioPortExt_audio_port_v7_ext( 
            return legacy;

        case media::AudioPortType::DEVICE:

            legacy.device = VALUE_OR_RETURN(

                    aidl2legacy_AudioDevice_audio_port_device_ext(

                    aidl2legacy_AudioPortDeviceExt_audio_port_device_ext(

                            VALUE_OR_RETURN(UNION_GET(aidl, device)),

                            VALUE_OR_RETURN(UNION_GET(aidlSys, device))));

            return legacy;
@@ -2682,10 +2688,10 @@ status_t legacy2aidl_AudioPortExt( 
            UNION_SET(*aidlSys, unspecified, false);

            return OK;

        case AUDIO_PORT_TYPE_DEVICE: {

            AudioDevice device;

            AudioPortDeviceExt device;

            media::AudioPortDeviceExtSys deviceSys;

            RETURN_STATUS_IF_ERROR(

                    legacy2aidl_audio_port_device_ext_AudioDevice(

                    legacy2aidl_audio_port_device_ext_AudioPortDeviceExt(

                            legacy.device, &device, &deviceSys));

            UNION_SET(*aidl, device, device);

            UNION_SET(*aidlSys, device, deviceSys);

media/libaudioclient/Android.bp

+0 −3
Original line number Diff line number Diff line
@@ -316,11 +316,8 @@ aidl_interface { 
        "aidl/android/media/AudioDualMonoMode.aidl",

        "aidl/android/media/AudioFlag.aidl",

        "aidl/android/media/AudioGainSys.aidl",

        "aidl/android/media/AudioInputFlags.aidl",

        "aidl/android/media/AudioIoConfigEvent.aidl",

        "aidl/android/media/AudioIoDescriptor.aidl",

        "aidl/android/media/AudioIoFlags.aidl",

        "aidl/android/media/AudioOutputFlags.aidl",

        "aidl/android/media/AudioPatch.aidl",

        "aidl/android/media/AudioPlaybackRate.aidl",

        "aidl/android/media/AudioPort.aidl",

media/libaudioclient/aidl/android/media/AudioGainSys.aidl

+0 −1
Original line number Diff line number Diff line
@@ -24,5 +24,4 @@ package android.media; 
parcelable AudioGainSys {

    int index;

    boolean isInput;

    boolean useForVolume;

}

media/libaudioclient/aidl/android/media/AudioInputFlags.aidl

deleted100644 → 0
+0 −31
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 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 AudioInputFlags {

    FAST       = 0,

    HW_HOTWORD = 1,

    RAW        = 2,

    SYNC       = 3,

    MMAP_NOIRQ = 4,

    VOIP_TX    = 5,

    HW_AV_SYNC = 6,

    DIRECT     = 7,

}

media/libaudioclient/aidl/android/media/AudioIoFlags.aidl

deleted100644 → 0
+0 −27
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 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}

 */

union AudioIoFlags {

    /** Bitmask indexed by AudioInputFlags. */

    int input;

    /** Bitmask indexed by AudioOutputFlags. */

    int output;

}