audiopolicy: engine: cleanup to enable VTS testing (bb1eac65) · Commits · e / os / android_frameworks_av

services/audiopolicy/engine/config/Android.bp

+3 −6

Original line number	Diff line number	Diff line
		cc_library_static {
		cc_library {
		name: "libaudiopolicyengine_config",
		export_include_dirs: ["include"],
		include_dirs: [
		@@ -14,17 +14,14 @@ cc_library_static {
		],
		shared_libs: [
		"libmedia_helper",
		"libandroidicu",
		"libxml2",
		"libutils",
		"liblog",
		"libcutils",
		],
		static_libs: [
		"libaudiopolicycomponents",
		],
		header_libs: [
		"libaudio_system_headers",
		"libaudiopolicycommon",
		"libmedia_headers",
		"libaudioclient_headers",
		],
		}

services/audiopolicy/engine/config/src/EngineConfig.cpp

+0 −1

Original line number	Diff line number	Diff line
		@@ -18,7 +18,6 @@
		//#define LOG_NDEBUG 0

		#include "EngineConfig.h"
		#include <policy.h>
		#include <cutils/properties.h>
		#include <media/TypeConverter.h>
		#include <media/convert.h>

services/audiopolicy/engineconfigurable/src/Engine.cpp

+9 −8

Original line number	Diff line number	Diff line
		@@ -80,8 +80,9 @@ Engine::~Engine()

		status_t Engine::initCheck()
		{
		if (mPolicyParameterMgr == nullptr \|\| mPolicyParameterMgr->start() != NO_ERROR) {
		ALOGE("%s: could not start Policy PFW", __FUNCTION__);
		std::string error;
		if (mPolicyParameterMgr == nullptr \|\| mPolicyParameterMgr->start(error) != NO_ERROR) {
		ALOGE("%s: could not start Policy PFW: %s", __FUNCTION__, error.c_str());
		return NO_INIT;
		}
		return EngineBase::initCheck();
		@@ -162,21 +163,21 @@ audio_policy_forced_cfg_t Engine::getForceUse(audio_policy_force_use_t usage) co
		return mPolicyParameterMgr->getForceUse(usage);
		}

		status_t Engine::setDeviceConnectionState(const sp<DeviceDescriptor> devDesc,
		status_t Engine::setDeviceConnectionState(const sp<DeviceDescriptor> device,
		audio_policy_dev_state_t state)
		{
		mPolicyParameterMgr->setDeviceConnectionState(devDesc, state);

		if (audio_is_output_device(devDesc->type())) {
		mPolicyParameterMgr->setDeviceConnectionState(
		device->type(), device->address().c_str(), state);
		if (audio_is_output_device(device->type())) {
		// FIXME: Use DeviceTypeSet when the interface is ready
		return mPolicyParameterMgr->setAvailableOutputDevices(
		deviceTypesToBitMask(getApmObserver()->getAvailableOutputDevices().types()));
		} else if (audio_is_input_device(devDesc->type())) {
		} else if (audio_is_input_device(device->type())) {
		// FIXME: Use DeviceTypeSet when the interface is ready
		return mPolicyParameterMgr->setAvailableInputDevices(
		deviceTypesToBitMask(getApmObserver()->getAvailableInputDevices().types()));
		}
		return EngineBase::setDeviceConnectionState(devDesc, state);
		return EngineBase::setDeviceConnectionState(device, state);
		}

		status_t Engine::loadAudioPolicyEngineConfig()

services/audiopolicy/engineconfigurable/wrapper/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -11,7 +11,6 @@ cc_library {
		"libbase_headers",
		"libaudiopolicycommon",
		],
		static_libs: ["libaudiopolicycomponents"],
		shared_libs: [
		"liblog",
		"libutils",

services/audiopolicy/engineconfigurable/wrapper/ParameterManagerWrapper.cpp

+18 −9

Original line number	Diff line number	Diff line
		@@ -92,7 +92,8 @@ struct ParameterManagerWrapper::parameterManagerElementSupported<ISelectionCrite
		template <>
		struct ParameterManagerWrapper::parameterManagerElementSupported<ISelectionCriterionTypeInterface> {};

		ParameterManagerWrapper::ParameterManagerWrapper()
		ParameterManagerWrapper::ParameterManagerWrapper(bool enableSchemaVerification,
		const std::string &schemaUri)
		: mPfwConnectorLogger(new ParameterMgrPlatformConnectorLogger)
		{
		// Connector
		@@ -104,6 +105,15 @@ ParameterManagerWrapper::ParameterManagerWrapper()

		// Logger
		mPfwConnector->setLogger(mPfwConnectorLogger);

		// Schema validation
		std::string error;
		bool ret = mPfwConnector->setValidateSchemasOnStart(enableSchemaVerification, error);
		ALOGE_IF(!ret, "Failed to activate schema validation: %s", error.c_str());
		if (enableSchemaVerification && ret && !schemaUri.empty()) {
		ALOGE("Schema verification activated with schema URI: %s", schemaUri.c_str());
		mPfwConnector->setSchemaUri(schemaUri);
		}
		}

		status_t ParameterManagerWrapper::addCriterion(const std::string &name, bool isInclusive,
		@@ -145,11 +155,10 @@ ParameterManagerWrapper::~ParameterManagerWrapper()
		delete mPfwConnector;
		}

		status_t ParameterManagerWrapper::start()
		status_t ParameterManagerWrapper::start(std::string &error)
		{
		ALOGD("%s: in", __FUNCTION__);
		/// Start PFW
		std::string error;
		if (!mPfwConnector->start(error)) {
		ALOGE("%s: Policy PFW start error: %s", __FUNCTION__, error.c_str());
		return NO_INIT;
		@@ -253,13 +262,13 @@ bool ParameterManagerWrapper::isValueValidForCriterion(ISelectionCriterionInterf
		return interface->getLiteralValue(valueToCheck, literalValue);
		}

		status_t ParameterManagerWrapper::setDeviceConnectionState(const sp<DeviceDescriptor> devDesc,
		audio_policy_dev_state_t state)
		status_t ParameterManagerWrapper::setDeviceConnectionState(
		audio_devices_t type, const std::string address, audio_policy_dev_state_t state)
		{
		std::string criterionName = audio_is_output_device(devDesc->type()) ?
		std::string criterionName = audio_is_output_device(type) ?
		gOutputDeviceAddressCriterionName : gInputDeviceAddressCriterionName;

		ALOGV("%s: device with address %s %s", __FUNCTION__, devDesc->address().c_str(),
		ALOGV("%s: device with address %s %s", __FUNCTION__, address.c_str(),
		state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE? "disconnected" : "connected");
		ISelectionCriterionInterface *criterion =
		getElement<ISelectionCriterionInterface>(criterionName, mPolicyCriteria);
		@@ -271,8 +280,8 @@ status_t ParameterManagerWrapper::setDeviceConnectionState(const sp<DeviceDescri

		auto criterionType = criterion->getCriterionType();
		int deviceAddressId;
		if (not criterionType->getNumericalValue(devDesc->address().c_str(), deviceAddressId)) {
		ALOGW("%s: unknown device address reported (%s)", __FUNCTION__, devDesc->address().c_str());
		if (not criterionType->getNumericalValue(address.c_str(), deviceAddressId)) {
		ALOGW("%s: unknown device address reported (%s)", __FUNCTION__, address.c_str());
		return BAD_TYPE;
		}
		int currentValueMask = criterion->getCriterionState();