Merge "Use managed pointer for 'ParameterManagerWrapper'" into main

#include <EngineConfig.h>

#include <policy.h>

#include <AudioIODescriptorInterface.h>

#include <ParameterManagerWrapper.h>

#include <media/AudioContainers.h>

#include <media/TypeConverter.h>

        return loadFromXmlConfigWithFallback(engineConfig::DEFAULT_PATH);

    }

#endif

    mPolicyParameterMgr = new ParameterManagerWrapper();

    mPolicyParameterMgr = std::make_unique<ParameterManagerWrapper>();

    auto capResult = capEngineConfig::convert(aidlConfig);

    if (capResult.parsedConfig == nullptr) {

        ALOGE("%s CapEngine Config invalid", __func__);

status_t Engine::loadFromXmlConfigWithFallback(const std::string& xmlFilePath)

{

    mPolicyParameterMgr = new ParameterManagerWrapper(/* useLegacyVendorFile= */ true);

    mPolicyParameterMgr = std::make_unique<ParameterManagerWrapper>(true /*useLegacyVendorFile*/);

    status_t status = loadWithFallback(xmlFilePath);

    std::string error;

    if (mPolicyParameterMgr->start(error) != NO_ERROR) {

#pragma once

#include <memory>

#include "Collection.h"

#include "EngineBase.h"

#include <AudioPolicyPluginInterface.h>

#include <CapEngineConfig.h>

#include <EngineInterface.h>

#include <ParameterManagerWrapper.h>

namespace android {

class AudioPolicyManagerObserver;

namespace audio_policy {

class ParameterManagerWrapper;

class VolumeProfile;

class Engine : public EngineBase, AudioPolicyPluginInterface

{

public:

    Engine() {}

    Engine() = default;

    virtual ~Engine() = default;

    template <class RequestedInterface>

    /**

     * Policy Parameter Manager hidden through a wrapper.

     */

    ParameterManagerWrapper *mPolicyParameterMgr;

    std::unique_ptr<ParameterManagerWrapper> mPolicyParameterMgr;

};

} // namespace audio_policy