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

Commit d97d37cb authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge changes I10b52b1e,I22ffe28a,I4587e350,I3f1ad6e8 

* changes:
  Match conversion function names to type names
  Rename AudioPatch to AudioPatchFw
  Rename AudioPort to AudioPortFw
  Rename AudioPortConfig to AudioPortConfigFw
parents 8646f33d 87227251

media/libaudioclient/AidlConversion.cpp

+20 −20
Original line number Diff line number Diff line
@@ -416,8 +416,8 @@ status_t legacy2aidl_AudioPortExt( 
    LOG_ALWAYS_FATAL("Shouldn't get here"); // with -Werror,-Wswitch may compile-time fail

}



ConversionResult<audio_port_config> aidl2legacy_AudioPortConfig_audio_port_config(

        const media::AudioPortConfig& aidl) {

ConversionResult<audio_port_config> aidl2legacy_AudioPortConfigFw_audio_port_config(

        const media::AudioPortConfigFw& aidl) {

    audio_port_config legacy{};

    legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.hal.id));

    legacy.role = VALUE_OR_RETURN(aidl2legacy_AudioPortRole_audio_port_role_t(aidl.sys.role));
@@ -457,9 +457,9 @@ ConversionResult<audio_port_config> aidl2legacy_AudioPortConfig_audio_port_confi 
    return legacy;

}



ConversionResult<media::AudioPortConfig> legacy2aidl_audio_port_config_AudioPortConfig(

ConversionResult<media::AudioPortConfigFw> legacy2aidl_audio_port_config_AudioPortConfigFw(

        const audio_port_config& legacy) {

    media::AudioPortConfig aidl;

    media::AudioPortConfigFw aidl;

    aidl.hal.id = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.id));

    aidl.sys.role = VALUE_OR_RETURN(legacy2aidl_audio_port_role_t_AudioPortRole(legacy.role));

    aidl.sys.type = VALUE_OR_RETURN(legacy2aidl_audio_port_type_t_AudioPortType(legacy.type));
@@ -491,8 +491,8 @@ ConversionResult<media::AudioPortConfig> legacy2aidl_audio_port_config_AudioPort 
    return aidl;

}



ConversionResult<struct audio_patch> aidl2legacy_AudioPatch_audio_patch(

        const media::AudioPatch& aidl) {

ConversionResult<struct audio_patch> aidl2legacy_AudioPatchFw_audio_patch(

        const media::AudioPatchFw& aidl) {

    struct audio_patch legacy;

    legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_patch_handle_t(aidl.id));

    legacy.num_sinks = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.sinks.size()));
@@ -501,7 +501,7 @@ ConversionResult<struct audio_patch> aidl2legacy_AudioPatch_audio_patch( 
    }

    for (size_t i = 0; i < legacy.num_sinks; ++i) {

        legacy.sinks[i] =

                VALUE_OR_RETURN(aidl2legacy_AudioPortConfig_audio_port_config(aidl.sinks[i]));

                VALUE_OR_RETURN(aidl2legacy_AudioPortConfigFw_audio_port_config(aidl.sinks[i]));

    }

    legacy.num_sources = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.sources.size()));

    if (legacy.num_sources > AUDIO_PATCH_PORTS_MAX) {
@@ -509,14 +509,14 @@ ConversionResult<struct audio_patch> aidl2legacy_AudioPatch_audio_patch( 
    }

    for (size_t i = 0; i < legacy.num_sources; ++i) {

        legacy.sources[i] =

                VALUE_OR_RETURN(aidl2legacy_AudioPortConfig_audio_port_config(aidl.sources[i]));

                VALUE_OR_RETURN(aidl2legacy_AudioPortConfigFw_audio_port_config(aidl.sources[i]));

    }

    return legacy;

}



ConversionResult<media::AudioPatch> legacy2aidl_audio_patch_AudioPatch(

ConversionResult<media::AudioPatchFw> legacy2aidl_audio_patch_AudioPatchFw(

        const struct audio_patch& legacy) {

    media::AudioPatch aidl;

    media::AudioPatchFw aidl;

    aidl.id = VALUE_OR_RETURN(legacy2aidl_audio_patch_handle_t_int32_t(legacy.id));



    if (legacy.num_sinks > AUDIO_PATCH_PORTS_MAX) {
@@ -524,14 +524,14 @@ ConversionResult<media::AudioPatch> legacy2aidl_audio_patch_AudioPatch( 
    }

    for (unsigned int i = 0; i < legacy.num_sinks; ++i) {

        aidl.sinks.push_back(

                VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfig(legacy.sinks[i])));

                VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfigFw(legacy.sinks[i])));

    }

    if (legacy.num_sources > AUDIO_PATCH_PORTS_MAX) {

        return unexpected(BAD_VALUE);

    }

    for (unsigned int i = 0; i < legacy.num_sources; ++i) {

        aidl.sources.push_back(

                VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfig(legacy.sources[i])));

                VALUE_OR_RETURN(legacy2aidl_audio_port_config_AudioPortConfigFw(legacy.sources[i])));

    }

    return aidl;

}
@@ -541,7 +541,7 @@ ConversionResult<sp<AudioIoDescriptor>> aidl2legacy_AudioIoDescriptor_AudioIoDes 
    const audio_io_handle_t io_handle = VALUE_OR_RETURN(

            aidl2legacy_int32_t_audio_io_handle_t(aidl.ioHandle));

    const struct audio_patch patch = VALUE_OR_RETURN(

            aidl2legacy_AudioPatch_audio_patch(aidl.patch));

            aidl2legacy_AudioPatchFw_audio_patch(aidl.patch));

    const bool isInput = aidl.isInput;

    const uint32_t sampling_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.samplingRate));

    const audio_format_t format = VALUE_OR_RETURN(
@@ -561,7 +561,7 @@ ConversionResult<media::AudioIoDescriptor> legacy2aidl_AudioIoDescriptor_AudioIo 
        const sp<AudioIoDescriptor>& legacy) {

    media::AudioIoDescriptor aidl;

    aidl.ioHandle = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(legacy->getIoHandle()));

    aidl.patch = VALUE_OR_RETURN(legacy2aidl_audio_patch_AudioPatch(legacy->getPatch()));

    aidl.patch = VALUE_OR_RETURN(legacy2aidl_audio_patch_AudioPatchFw(legacy->getPatch()));

    aidl.isInput = legacy->getIsInput();

    aidl.samplingRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy->getSamplingRate()));

    aidl.format = VALUE_OR_RETURN(
@@ -930,7 +930,7 @@ status_t legacy2aidl_AudioPortExt( 
}



ConversionResult<audio_port_v7>

aidl2legacy_AudioPort_audio_port_v7(const media::AudioPort& aidl) {

aidl2legacy_AudioPortFw_audio_port_v7(const media::AudioPortFw& aidl) {

    audio_port_v7 legacy;

    legacy.id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.hal.id));

    legacy.role = VALUE_OR_RETURN(aidl2legacy_AudioPortRole_audio_port_role_t(aidl.sys.role));
@@ -969,15 +969,15 @@ aidl2legacy_AudioPort_audio_port_v7(const media::AudioPort& aidl) { 
    legacy.num_gains = aidl.hal.gains.size();



    legacy.active_config = VALUE_OR_RETURN(

            aidl2legacy_AudioPortConfig_audio_port_config(aidl.sys.activeConfig));

            aidl2legacy_AudioPortConfigFw_audio_port_config(aidl.sys.activeConfig));

    legacy.ext = VALUE_OR_RETURN(

            aidl2legacy_AudioPortExt_audio_port_v7_ext(aidl.hal.ext, aidl.sys.type, aidl.sys.ext));

    return legacy;

}



ConversionResult<media::AudioPort>

legacy2aidl_audio_port_v7_AudioPort(const audio_port_v7& legacy) {

    media::AudioPort aidl;

ConversionResult<media::AudioPortFw>

legacy2aidl_audio_port_v7_AudioPortFw(const audio_port_v7& legacy) {

    media::AudioPortFw aidl;

    aidl.hal.id = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.id));

    aidl.sys.role = VALUE_OR_RETURN(legacy2aidl_audio_port_role_t_AudioPortRole(legacy.role));

    aidl.sys.type = VALUE_OR_RETURN(legacy2aidl_audio_port_type_t_AudioPortType(legacy.type));
@@ -1016,7 +1016,7 @@ legacy2aidl_audio_port_v7_AudioPort(const audio_port_v7& legacy) { 
    aidl.sys.gains.resize(legacy.num_gains);



    aidl.sys.activeConfig = VALUE_OR_RETURN(

            legacy2aidl_audio_port_config_AudioPortConfig(legacy.active_config));

            legacy2aidl_audio_port_config_AudioPortConfigFw(legacy.active_config));

    aidl.sys.activeConfig.hal.portId = aidl.hal.id;

    RETURN_IF_ERROR(

            legacy2aidl_AudioPortExt(legacy.ext, legacy.type, &aidl.hal.ext, &aidl.sys.ext));

media/libaudioclient/Android.bp

+3 −3
Original line number Diff line number Diff line
@@ -287,10 +287,10 @@ aidl_interface { 
        "aidl/android/media/AudioHalVersion.aidl",

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

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

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

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

        "aidl/android/media/AudioPatchFw.aidl",

        "aidl/android/media/AudioPortFw.aidl",

        "aidl/android/media/AudioPortSys.aidl",

        "aidl/android/media/AudioPortConfig.aidl",

        "aidl/android/media/AudioPortConfigFw.aidl",

        "aidl/android/media/AudioPortConfigSys.aidl",

        "aidl/android/media/AudioPortDeviceExtSys.aidl",

        "aidl/android/media/AudioPortExtSys.aidl",

media/libaudioclient/AudioSystem.cpp

+12 −12
Original line number Diff line number Diff line
@@ -1532,7 +1532,7 @@ status_t AudioSystem::listAudioPorts(audio_port_role_t role, 
            legacy2aidl_audio_port_type_t_AudioPortType(type));

    Int numPortsAidl;

    numPortsAidl.value = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*num_ports));

    std::vector<media::AudioPort> portsAidl;

    std::vector<media::AudioPortFw> portsAidl;

    int32_t generationAidl;



    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
@@ -1540,7 +1540,7 @@ status_t AudioSystem::listAudioPorts(audio_port_role_t role, 
    *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));

                                        aidl2legacy_AudioPortFw_audio_port_v7));

    return OK;

}
@@ -1551,10 +1551,10 @@ status_t AudioSystem::getAudioPort(struct audio_port_v7* port) { 
    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();

    if (aps == 0) return PERMISSION_DENIED;



    media::AudioPort portAidl;

    media::AudioPortFw portAidl;

    RETURN_STATUS_IF_ERROR(

            statusTFromBinderStatus(aps->getAudioPort(port->id, &portAidl)));

    *port = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioPort_audio_port_v7(portAidl));

    *port = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioPortFw_audio_port_v7(portAidl));

    return OK;

}
@@ -1567,8 +1567,8 @@ status_t AudioSystem::createAudioPatch(const struct audio_patch* patch, 
    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();

    if (aps == 0) return PERMISSION_DENIED;



    media::AudioPatch patchAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_patch_AudioPatch(*patch));

    media::AudioPatchFw patchAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_patch_AudioPatchFw(*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)));
@@ -1598,7 +1598,7 @@ status_t AudioSystem::listAudioPatches(unsigned int* num_patches, 


    Int numPatchesAidl;

    numPatchesAidl.value = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*num_patches));

    std::vector<media::AudioPatch> patchesAidl;

    std::vector<media::AudioPatchFw> patchesAidl;

    int32_t generationAidl;



    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
@@ -1606,7 +1606,7 @@ status_t AudioSystem::listAudioPatches(unsigned int* num_patches, 
    *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));

                                        aidl2legacy_AudioPatchFw_audio_patch));

    return OK;

}
@@ -1618,8 +1618,8 @@ status_t AudioSystem::setAudioPortConfig(const struct audio_port_config* config) 
    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();

    if (aps == 0) return PERMISSION_DENIED;



    media::AudioPortConfig configAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_port_config_AudioPortConfig(*config));

    media::AudioPortConfigFw configAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_port_config_AudioPortConfigFw(*config));

    return statusTFromBinderStatus(aps->setAudioPortConfig(configAidl));

}
@@ -1839,8 +1839,8 @@ status_t AudioSystem::startAudioSource(const struct audio_port_config* source, 
    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();

    if (aps == 0) return PERMISSION_DENIED;



    media::AudioPortConfig sourceAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_port_config_AudioPortConfig(*source));

    media::AudioPortConfigFw sourceAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_port_config_AudioPortConfigFw(*source));

    media::AudioAttributesInternal attributesAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_attributes_t_AudioAttributesInternal(*attributes));

    int32_t portIdAidl;

media/libaudioclient/IAudioFlinger.cpp

+24 −22
Original line number Diff line number Diff line
@@ -666,17 +666,19 @@ status_t AudioFlingerClientAdapter::setLowRamDevice(bool isLowRamDevice, int64_t 
}



status_t AudioFlingerClientAdapter::getAudioPort(struct audio_port_v7* port) {

    media::AudioPort portAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_v7_AudioPort(*port));

    media::AudioPort aidlRet;

    media::AudioPortFw portAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_port_v7_AudioPortFw(*port));

    media::AudioPortFw aidlRet;

    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(

            mDelegate->getAudioPort(portAidl, &aidlRet)));

    *port = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioPort_audio_port_v7(aidlRet));

    *port = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioPortFw_audio_port_v7(aidlRet));

    return OK;

}



status_t AudioFlingerClientAdapter::createAudioPatch(const struct audio_patch* patch,

                                                     audio_patch_handle_t* handle) {

    media::AudioPatch patchAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_AudioPatch(*patch));

    media::AudioPatchFw patchAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_patch_AudioPatchFw(*patch));

    int32_t aidlRet = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(

                    AUDIO_PATCH_HANDLE_NONE));

    if (handle != nullptr) {
@@ -697,18 +699,18 @@ status_t AudioFlingerClientAdapter::releaseAudioPatch(audio_patch_handle_t handl 


status_t AudioFlingerClientAdapter::listAudioPatches(unsigned int* num_patches,

                                                     struct audio_patch* patches) {

    std::vector<media::AudioPatch> aidlRet;

    std::vector<media::AudioPatchFw> aidlRet;

    int32_t maxPatches = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*num_patches));

    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(

            mDelegate->listAudioPatches(maxPatches, &aidlRet)));

    *num_patches = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(aidlRet.size()));

    return convertRange(aidlRet.begin(), aidlRet.end(), patches,

                        aidl2legacy_AudioPatch_audio_patch);

                        aidl2legacy_AudioPatchFw_audio_patch);

}



status_t AudioFlingerClientAdapter::setAudioPortConfig(const struct audio_port_config* config) {

    media::AudioPortConfig configAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_port_config_AudioPortConfig(*config));

    media::AudioPortConfigFw configAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_port_config_AudioPortConfigFw(*config));

    return statusTFromBinderStatus(mDelegate->setAudioPortConfig(configAidl));

}
@@ -805,8 +807,8 @@ int32_t AudioFlingerClientAdapter::getAAudioHardwareBurstMinUsec() { 


status_t AudioFlingerClientAdapter::setDeviceConnectedState(

        const struct audio_port_v7 *port, bool connected) {

    media::AudioPort aidlPort = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_port_v7_AudioPort(*port));

    media::AudioPortFw aidlPort = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_port_v7_AudioPortFw(*port));

    return statusTFromBinderStatus(mDelegate->setDeviceConnectedState(aidlPort, connected));

}
@@ -1237,17 +1239,17 @@ Status AudioFlingerServerAdapter::setLowRamDevice(bool isLowRamDevice, int64_t t 
    return Status::fromStatusT(mDelegate->setLowRamDevice(isLowRamDevice, totalMemory));

}



Status AudioFlingerServerAdapter::getAudioPort(const media::AudioPort& port,

                                               media::AudioPort* _aidl_return) {

    audio_port_v7 portLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_AudioPort_audio_port_v7(port));

Status AudioFlingerServerAdapter::getAudioPort(const media::AudioPortFw& port,

                                               media::AudioPortFw* _aidl_return) {

    audio_port_v7 portLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_AudioPortFw_audio_port_v7(port));

    RETURN_BINDER_IF_ERROR(mDelegate->getAudioPort(&portLegacy));

    *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_port_v7_AudioPort(portLegacy));

    *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_port_v7_AudioPortFw(portLegacy));

    return Status::ok();

}



Status AudioFlingerServerAdapter::createAudioPatch(const media::AudioPatch& patch,

Status AudioFlingerServerAdapter::createAudioPatch(const media::AudioPatchFw& patch,

                                                   int32_t* _aidl_return) {

    audio_patch patchLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_AudioPatch_audio_patch(patch));

    audio_patch patchLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_AudioPatchFw_audio_patch(patch));

    audio_patch_handle_t handleLegacy = VALUE_OR_RETURN_BINDER(

            aidl2legacy_int32_t_audio_patch_handle_t(*_aidl_return));

    RETURN_BINDER_IF_ERROR(mDelegate->createAudioPatch(&patchLegacy, &handleLegacy));
@@ -1262,7 +1264,7 @@ Status AudioFlingerServerAdapter::releaseAudioPatch(int32_t handle) { 
}



Status AudioFlingerServerAdapter::listAudioPatches(int32_t maxCount,

                            std::vector<media::AudioPatch>* _aidl_return) {

                            std::vector<media::AudioPatchFw>* _aidl_return) {

    unsigned int count = VALUE_OR_RETURN_BINDER(convertIntegral<unsigned int>(maxCount));

    count = std::min(count, static_cast<unsigned int>(MAX_ITEMS_PER_LIST));

    std::unique_ptr<audio_patch[]> patchesLegacy(new audio_patch[count]);
@@ -1270,13 +1272,13 @@ Status AudioFlingerServerAdapter::listAudioPatches(int32_t maxCount, 
    RETURN_BINDER_IF_ERROR(convertRange(&patchesLegacy[0],

                           &patchesLegacy[count],

                           std::back_inserter(*_aidl_return),

                           legacy2aidl_audio_patch_AudioPatch));

                           legacy2aidl_audio_patch_AudioPatchFw));

    return Status::ok();

}



Status AudioFlingerServerAdapter::setAudioPortConfig(const media::AudioPortConfig& config) {

Status AudioFlingerServerAdapter::setAudioPortConfig(const media::AudioPortConfigFw& config) {

    audio_port_config configLegacy = VALUE_OR_RETURN_BINDER(

            aidl2legacy_AudioPortConfig_audio_port_config(config));

            aidl2legacy_AudioPortConfigFw_audio_port_config(config));

    return Status::fromStatusT(mDelegate->setAudioPortConfig(&configLegacy));

}
@@ -1354,8 +1356,8 @@ Status AudioFlingerServerAdapter::getAAudioHardwareBurstMinUsec(int32_t* _aidl_r 
}



Status AudioFlingerServerAdapter::setDeviceConnectedState(

        const media::AudioPort& port, bool connected) {

    audio_port_v7 portLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_AudioPort_audio_port_v7(port));

        const media::AudioPortFw& port, bool connected) {

    audio_port_v7 portLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_AudioPortFw_audio_port_v7(port));

    return Status::fromStatusT(mDelegate->setDeviceConnectedState(&portLegacy, connected));

}

media/libaudioclient/aidl/android/media/AudioIoDescriptor.aidl

+2 −2
Original line number Diff line number Diff line
@@ -16,7 +16,7 @@ 


package android.media;



import android.media.AudioPatch;

import android.media.AudioPatchFw;

import android.media.audio.common.AudioChannelLayout;

import android.media.audio.common.AudioFormatDescription;
@@ -26,7 +26,7 @@ import android.media.audio.common.AudioFormatDescription; 
parcelable AudioIoDescriptor {

    /** Interpreted as audio_io_handle_t. */

    int ioHandle;

    AudioPatch patch;

    AudioPatchFw patch;

    boolean isInput;

    int samplingRate;

    AudioFormatDescription format;