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

Commit 9b9fd940 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Update APM XML deserializer for HAL V7" am: 34da2e29 am: f7795707 am: 52d87e41 

Original change: https://android-review.googlesource.com/c/platform/frameworks/av/+/1576904

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: If720a6262e1abbc4ed3c7682e2629bd2588ac6de
parents 4e4193a3 52d87e41

services/audiopolicy/common/managerdefinitions/src/Serializer.cpp

+99 −62
Original line number Diff line number Diff line
@@ -39,6 +39,7 @@ namespace { 
// TODO(mnaganov): Consider finding an alternative for using HIDL code.

using hardware::Return;

using hardware::Status;

using hardware::Void;

using utilities::convertTo;



template<typename E, typename C>
@@ -89,7 +90,6 @@ struct AudioGainTraits : public AndroidCollectionTraits<AudioGain, AudioGains> 


    };



    static Return<Element> deserialize(const xmlNode *cur, PtrSerializingCtx serializingContext);

    // No children

};
@@ -106,8 +106,6 @@ struct AudioProfileTraits : public AndroidCollectionTraits<AudioProfile, AudioPr 
        static constexpr const char *format = "format";

        static constexpr const char *channelMasks = "channelMasks";

    };



    static Return<Element> deserialize(const xmlNode *cur, PtrSerializingCtx serializingContext);

};



struct MixPortTraits : public AndroidCollectionTraits<IOProfile, IOProfileCollection>
@@ -125,7 +123,6 @@ struct MixPortTraits : public AndroidCollectionTraits<IOProfile, IOProfileCollec 
        static constexpr const char *maxActiveCount = "maxActiveCount";

    };



    static Return<Element> deserialize(const xmlNode *cur, PtrSerializingCtx serializingContext);

    // Children: GainTraits

};
@@ -147,7 +144,6 @@ struct DevicePortTraits : public AndroidCollectionTraits<DeviceDescriptor, Devic 
        static constexpr const char *encodedFormats = "encodedFormats";

    };



    static Return<Element> deserialize(const xmlNode *cur, PtrSerializingCtx serializingContext);

    // Children: GainTraits (optional)

};
@@ -166,8 +162,6 @@ struct RouteTraits : public AndroidCollectionTraits<AudioRoute, AudioRouteVector 
    };



    typedef HwModule *PtrSerializingCtx;



    static Return<Element> deserialize(const xmlNode *cur, PtrSerializingCtx serializingContext);

};



struct ModuleTraits : public AndroidCollectionTraits<HwModule, HwModuleCollection>
@@ -187,13 +181,14 @@ struct ModuleTraits : public AndroidCollectionTraits<HwModule, HwModuleCollectio 


    typedef AudioPolicyConfig *PtrSerializingCtx;



    static Return<Element> deserialize(const xmlNode *cur, PtrSerializingCtx serializingContext);

    // Children: mixPortTraits, devicePortTraits, and routeTraits

    // Need to call deserialize on each child

};



struct GlobalConfigTraits

{

    typedef void Element;



    static constexpr const char *tag = "globalConfiguration";



    struct Attributes
@@ -203,14 +198,16 @@ struct GlobalConfigTraits 
        static constexpr const char *engineLibrarySuffix = "engine_library";

    };



    static status_t deserialize(const xmlNode *root, AudioPolicyConfig *config);

    typedef AudioPolicyConfig *PtrSerializingCtx;

};



struct SurroundSoundTraits

{

    typedef void Element;



    static constexpr const char *tag = "surroundSound";



    static status_t deserialize(const xmlNode *root, AudioPolicyConfig *config);

    typedef AudioPolicyConfig *PtrSerializingCtx;

    // Children: SurroundSoundFormatTraits

};
@@ -224,28 +221,30 @@ struct SurroundSoundFormatTraits : public StdCollectionTraits<AudioPolicyConfig: 
        static constexpr const char *name = "name";

        static constexpr const char *subformats = "subformats";

    };



    static Return<Element> deserialize(const xmlNode *cur, PtrSerializingCtx serializingContext);

};



class PolicySerializer

{

public:

    PolicySerializer() : mVersion{std::to_string(gMajor) + "." + std::to_string(gMinor)}

    {

        ALOGV("%s: Version=%s Root=%s", __func__, mVersion.c_str(), rootName);

    }

    status_t deserialize(const char *configFile, AudioPolicyConfig *config);



    template <class Trait>

    status_t deserializeCollection(const xmlNode *cur,

            typename Trait::Collection *collection,

            typename Trait::PtrSerializingCtx serializingContext);

    template <class Trait>

    Return<typename Trait::Element> deserialize(const xmlNode *cur,

            typename Trait::PtrSerializingCtx serializingContext);



private:

    static constexpr const char *rootName = "audioPolicyConfiguration";

    static constexpr const char *versionAttribute = "version";

    static constexpr uint32_t gMajor = 1; /**< the major number of the policy xml format version. */

    static constexpr uint32_t gMinor = 0; /**< the minor number of the policy xml format version. */



    typedef AudioPolicyConfig Element;



    const std::string mVersion;

    std::string mChannelMasksSeparator = ",";

    std::string mSamplingRatesSeparator = ",";

    std::string mFlagsSeparator = "|";



    // Children: ModulesTraits, VolumeTraits, SurroundSoundTraits (optional)

};
@@ -295,7 +294,7 @@ const xmlNode* getReference(const xmlNode *cur, const std::string &refName) 
}



template <class Trait>

status_t deserializeCollection(const xmlNode *cur,

status_t PolicySerializer::deserializeCollection(const xmlNode *cur,

        typename Trait::Collection *collection,

        typename Trait::PtrSerializingCtx serializingContext)

{
@@ -308,7 +307,7 @@ status_t deserializeCollection(const xmlNode *cur, 
        }

        for (; child != NULL; child = child->next) {

            if (!xmlStrcmp(child->name, reinterpret_cast<const xmlChar*>(Trait::tag))) {

                auto element = Trait::deserialize(child, serializingContext);

                auto element = deserialize<Trait>(child, serializingContext);

                if (element.isOk()) {

                    status_t status = Trait::addElementToCollection(element, collection);

                    if (status != NO_ERROR) {
@@ -328,11 +327,14 @@ status_t deserializeCollection(const xmlNode *cur, 
    return NO_ERROR;

}



Return<AudioGainTraits::Element> AudioGainTraits::deserialize(const xmlNode *cur,

        PtrSerializingCtx /*serializingContext*/)

template<>

Return<AudioGainTraits::Element> PolicySerializer::deserialize<AudioGainTraits>(const xmlNode *cur,

        AudioGainTraits::PtrSerializingCtx /*serializingContext*/)

{

    using Attributes = AudioGainTraits::Attributes;



    static uint32_t index = 0;

    Element gain = new AudioGain(index++, true);

    AudioGainTraits::Element gain = new AudioGain(index++, true);



    std::string mode = getXmlAttribute(cur, Attributes::mode);

    if (!mode.empty()) {
@@ -395,16 +397,19 @@ Return<AudioGainTraits::Element> AudioGainTraits::deserialize(const xmlNode *cur 
    }

}



Return<AudioProfileTraits::Element> AudioProfileTraits::deserialize(const xmlNode *cur,

        PtrSerializingCtx /*serializingContext*/)

template<>

Return<AudioProfileTraits::Element> PolicySerializer::deserialize<AudioProfileTraits>(

        const xmlNode *cur, AudioProfileTraits::PtrSerializingCtx /*serializingContext*/)

{

    using Attributes = AudioProfileTraits::Attributes;



    std::string samplingRates = getXmlAttribute(cur, Attributes::samplingRates);

    std::string format = getXmlAttribute(cur, Attributes::format);

    std::string channels = getXmlAttribute(cur, Attributes::channelMasks);



    Element profile = new AudioProfile(formatFromString(format, gDynamicFormat),

            channelMasksFromString(channels, ","),

            samplingRatesFromString(samplingRates, ","));

    AudioProfileTraits::Element profile = new AudioProfile(formatFromString(format, gDynamicFormat),

            channelMasksFromString(channels, mChannelMasksSeparator.c_str()),

            samplingRatesFromString(samplingRates, mSamplingRatesSeparator.c_str()));



    profile->setDynamicFormat(profile->getFormat() == gDynamicFormat);

    profile->setDynamicChannels(profile->getChannels().empty());
@@ -413,15 +418,18 @@ Return<AudioProfileTraits::Element> AudioProfileTraits::deserialize(const xmlNod 
    return profile;

}



Return<MixPortTraits::Element> MixPortTraits::deserialize(const xmlNode *child,

        PtrSerializingCtx /*serializingContext*/)

template<>

Return<MixPortTraits::Element> PolicySerializer::deserialize<MixPortTraits>(const xmlNode *child,

        MixPortTraits::PtrSerializingCtx /*serializingContext*/)

{

    using Attributes = MixPortTraits::Attributes;



    std::string name = getXmlAttribute(child, Attributes::name);

    if (name.empty()) {

        ALOGE("%s: No %s found", __func__, Attributes::name);

        return Status::fromStatusT(BAD_VALUE);

    }

    ALOGV("%s: %s %s=%s", __func__, tag, Attributes::name, name.c_str());

    ALOGV("%s: %s %s=%s", __func__, MixPortTraits::tag, Attributes::name, name.c_str());

    std::string role = getXmlAttribute(child, Attributes::role);

    if (role.empty()) {

        ALOGE("%s: No %s found", __func__, Attributes::role);
@@ -431,7 +439,7 @@ Return<MixPortTraits::Element> MixPortTraits::deserialize(const xmlNode *child, 
    audio_port_role_t portRole = (role == Attributes::roleSource) ?

            AUDIO_PORT_ROLE_SOURCE : AUDIO_PORT_ROLE_SINK;



    Element mixPort = new IOProfile(name, portRole);

    MixPortTraits::Element mixPort = new IOProfile(name, portRole);



    AudioProfileTraits::Collection profiles;

    status_t status = deserializeCollection<AudioProfileTraits>(child, &profiles, NULL);
@@ -450,10 +458,10 @@ Return<MixPortTraits::Element> MixPortTraits::deserialize(const xmlNode *child, 
    if (!flags.empty()) {

        // Source role

        if (portRole == AUDIO_PORT_ROLE_SOURCE) {

            mixPort->setFlags(OutputFlagConverter::maskFromString(flags));

            mixPort->setFlags(OutputFlagConverter::maskFromString(flags, mFlagsSeparator.c_str()));

        } else {

            // Sink role

            mixPort->setFlags(InputFlagConverter::maskFromString(flags));

            mixPort->setFlags(InputFlagConverter::maskFromString(flags, mFlagsSeparator.c_str()));

        }

    }

    std::string maxOpenCount = getXmlAttribute(child, Attributes::maxOpenCount);
@@ -475,9 +483,13 @@ Return<MixPortTraits::Element> MixPortTraits::deserialize(const xmlNode *child, 
    return mixPort;

}



Return<DevicePortTraits::Element> DevicePortTraits::deserialize(const xmlNode *cur,

        PtrSerializingCtx /*serializingContext*/)

template<>

Return<DevicePortTraits::Element> PolicySerializer::deserialize<DevicePortTraits>(

        const xmlNode *cur, DevicePortTraits::PtrSerializingCtx /*serializingContext*/)

{

    using Attributes = DevicePortTraits::Attributes;

    auto& tag = DevicePortTraits::tag;



    std::string name = getXmlAttribute(cur, Attributes::tagName);

    if (name.empty()) {

        ALOGE("%s: No %s found", __func__, Attributes::tagName);
@@ -513,7 +525,8 @@ Return<DevicePortTraits::Element> DevicePortTraits::deserialize(const xmlNode *c 
        encodedFormats = formatsFromString(encodedFormatsLiteral, " ");

    }

    std::string address = getXmlAttribute(cur, Attributes::address);

    Element deviceDesc = new DeviceDescriptor(type, name, address, encodedFormats);

    DevicePortTraits::Element deviceDesc =

            new DeviceDescriptor(type, name, address, encodedFormats);



    AudioProfileTraits::Collection profiles;

    status_t status = deserializeCollection<AudioProfileTraits>(cur, &profiles, NULL);
@@ -538,8 +551,12 @@ Return<DevicePortTraits::Element> DevicePortTraits::deserialize(const xmlNode *c 
    return deviceDesc;

}



Return<RouteTraits::Element> RouteTraits::deserialize(const xmlNode *cur, PtrSerializingCtx ctx)

template<>

Return<RouteTraits::Element> PolicySerializer::deserialize<RouteTraits>(

        const xmlNode *cur, RouteTraits::PtrSerializingCtx ctx)

{

    using Attributes = RouteTraits::Attributes;



    std::string type = getXmlAttribute(cur, Attributes::type);

    if (type.empty()) {

        ALOGE("%s: No %s found", __func__, Attributes::type);
@@ -548,8 +565,8 @@ Return<RouteTraits::Element> RouteTraits::deserialize(const xmlNode *cur, PtrSer 
    audio_route_type_t routeType = (type == Attributes::typeMix) ?

                AUDIO_ROUTE_MIX : AUDIO_ROUTE_MUX;



    ALOGV("%s: %s %s=%s", __func__, tag, Attributes::type, type.c_str());

    Element route = new AudioRoute(routeType);

    ALOGV("%s: %s %s=%s", __func__, RouteTraits::tag, Attributes::type, type.c_str());

    RouteTraits::Element route = new AudioRoute(routeType);



    std::string sinkAttr = getXmlAttribute(cur, Attributes::sink);

    if (sinkAttr.empty()) {
@@ -595,8 +612,16 @@ Return<RouteTraits::Element> RouteTraits::deserialize(const xmlNode *cur, PtrSer 
    return route;

}



Return<ModuleTraits::Element> ModuleTraits::deserialize(const xmlNode *cur, PtrSerializingCtx ctx)

template<>

Return<ModuleTraits::Element> PolicySerializer::deserialize<ModuleTraits>(

        const xmlNode *cur, ModuleTraits::PtrSerializingCtx ctx)

{

    using Attributes = ModuleTraits::Attributes;

    auto& tag = ModuleTraits::tag;

    auto& childAttachedDevicesTag = ModuleTraits::childAttachedDevicesTag;

    auto& childAttachedDeviceTag = ModuleTraits::childAttachedDeviceTag;

    auto& childDefaultOutputDeviceTag = ModuleTraits::childDefaultOutputDeviceTag;



    std::string name = getXmlAttribute(cur, Attributes::name);

    if (name.empty()) {

        ALOGE("%s: No %s found", __func__, Attributes::name);
@@ -610,11 +635,11 @@ Return<ModuleTraits::Element> ModuleTraits::deserialize(const xmlNode *cur, PtrS 
              versionMajor, versionMajor);

    }



    ALOGV("%s: %s %s=%s", __func__, tag, Attributes::name, name.c_str());

    ALOGV("%s: %s %s=%s", __func__, ModuleTraits::tag, Attributes::name, name.c_str());



    Element module = new HwModule(name.c_str(), versionMajor, versionMinor);

    ModuleTraits::Element module = new HwModule(name.c_str(), versionMajor, versionMinor);



    // Deserialize childrens: Audio Mix Port, Audio Device Ports (Source/Sink), Audio Routes

    // Deserialize children: Audio Mix Port, Audio Device Ports (Source/Sink), Audio Routes

    MixPortTraits::Collection mixPorts;

    status_t status = deserializeCollection<MixPortTraits>(cur, &mixPorts, NULL);

    if (status != NO_ERROR) {
@@ -677,10 +702,14 @@ Return<ModuleTraits::Element> ModuleTraits::deserialize(const xmlNode *cur, PtrS 
    return module;

}



status_t GlobalConfigTraits::deserialize(const xmlNode *root, AudioPolicyConfig *config)

template<>

Return<GlobalConfigTraits::Element> PolicySerializer::deserialize<GlobalConfigTraits>(

        const xmlNode *root, GlobalConfigTraits::PtrSerializingCtx config)

{

    using Attributes = GlobalConfigTraits::Attributes;



    for (const xmlNode *cur = root->xmlChildrenNode; cur != NULL; cur = cur->next) {

        if (!xmlStrcmp(cur->name, reinterpret_cast<const xmlChar*>(tag))) {

        if (!xmlStrcmp(cur->name, reinterpret_cast<const xmlChar*>(GlobalConfigTraits::tag))) {

            bool value;

            std::string attr = getXmlAttribute(cur, Attributes::speakerDrcEnabled);

            if (!attr.empty() &&
@@ -696,33 +725,38 @@ status_t GlobalConfigTraits::deserialize(const xmlNode *root, AudioPolicyConfig 
            if (!engineLibrarySuffix.empty()) {

                config->setEngineLibraryNameSuffix(engineLibrarySuffix);

            }

            return NO_ERROR;

            return Void();

        }

    }

    return NO_ERROR;

    return Void();

}



status_t SurroundSoundTraits::deserialize(const xmlNode *root, AudioPolicyConfig *config)

template<>

Return<SurroundSoundTraits::Element> PolicySerializer::deserialize<SurroundSoundTraits>(

        const xmlNode *root, SurroundSoundTraits::PtrSerializingCtx config)

{

    config->setDefaultSurroundFormats();



    for (const xmlNode *cur = root->xmlChildrenNode; cur != NULL; cur = cur->next) {

        if (!xmlStrcmp(cur->name, reinterpret_cast<const xmlChar*>(tag))) {

        if (!xmlStrcmp(cur->name, reinterpret_cast<const xmlChar*>(SurroundSoundTraits::tag))) {

            AudioPolicyConfig::SurroundFormats formats;

            status_t status = deserializeCollection<SurroundSoundFormatTraits>(

                    cur, &formats, nullptr);

            if (status == NO_ERROR) {

                config->setSurroundFormats(formats);

            }

            return NO_ERROR;

            return Void();

        }

    }

    return NO_ERROR;

    return Void();

}



Return<SurroundSoundFormatTraits::Element> SurroundSoundFormatTraits::deserialize(

        const xmlNode *cur, PtrSerializingCtx /*serializingContext*/)

template<>

Return<SurroundSoundFormatTraits::Element> PolicySerializer::deserialize<SurroundSoundFormatTraits>(

        const xmlNode *cur, SurroundSoundFormatTraits::PtrSerializingCtx /*serializingContext*/)

{

    using Attributes = SurroundSoundFormatTraits::Attributes;



    std::string formatLiteral = getXmlAttribute(cur, Attributes::name);

    if (formatLiteral.empty()) {

        ALOGE("%s: No %s found for a surround format", __func__, Attributes::name);
@@ -733,7 +767,8 @@ Return<SurroundSoundFormatTraits::Element> SurroundSoundFormatTraits::deserializ 
        ALOGE("%s: Unrecognized format %s", __func__, formatLiteral.c_str());

        return Status::fromStatusT(BAD_VALUE);

    }

    Element pair = std::make_pair(format, Collection::mapped_type{});

    SurroundSoundFormatTraits::Element pair = std::make_pair(

            format, SurroundSoundFormatTraits::Collection::mapped_type{});



    std::string subformatsLiteral = getXmlAttribute(cur, Attributes::subformats);

    if (subformatsLiteral.empty()) return pair;
@@ -775,12 +810,14 @@ status_t PolicySerializer::deserialize(const char *configFile, AudioPolicyConfig 
        ALOGE("%s: No version found in root node %s", __func__, rootName);

        return BAD_VALUE;

    }

    if (version != mVersion) {

        ALOGE("%s: Version does not match; expect %s got %s", __func__, mVersion.c_str(),

              version.c_str());

    if (version == "7.0") {

        mChannelMasksSeparator = mSamplingRatesSeparator = mFlagsSeparator = " ";

    } else if (version != "1.0") {

        ALOGE("%s: Version does not match; expected \"1.0\" or \"7.0\" got \"%s\"",

                __func__, version.c_str());

        return BAD_VALUE;

    }

    // Lets deserialize children

    // Let's deserialize children

    // Modules

    ModuleTraits::Collection modules;

    status_t status = deserializeCollection<ModuleTraits>(root, &modules, config);
@@ -790,10 +827,10 @@ status_t PolicySerializer::deserialize(const char *configFile, AudioPolicyConfig 
    config->setHwModules(modules);



    // Global Configuration

    GlobalConfigTraits::deserialize(root, config);

    deserialize<GlobalConfigTraits>(root, config);



    // Surround configuration

    SurroundSoundTraits::deserialize(root, config);

    deserialize<SurroundSoundTraits>(root, config);



    return android::OK;

}

services/audiopolicy/config/audio_policy_configuration_7_0.xml

+1 −1
Original line number Diff line number Diff line
@@ -14,7 +14,7 @@ 
     limitations under the License.

-->



<audioPolicyConfiguration version="1.0" xmlns:xi="http://www.w3.org/2001/XInclude">

<audioPolicyConfiguration version="7.0" xmlns:xi="http://www.w3.org/2001/XInclude">

    <!-- version section contains a “version” tag in the form “major.minor” e.g version=”1.0” -->



    <!-- Global configuration Decalaration -->