Merge "Introduce device(s) role for strategy." (e8a66c66) · Commits · e / os / android_frameworks_av

media/libaudioclient/AudioSystem.cpp

+10 −8

Original line number	Diff line number	Diff line
		@@ -1604,33 +1604,35 @@ bool AudioSystem::isCallScreenModeSupported()
		return aps->isCallScreenModeSupported();
		}

		status_t AudioSystem::setPreferredDeviceForStrategy(product_strategy_t strategy,
		const AudioDeviceTypeAddr &device)
		status_t AudioSystem::setDevicesRoleForStrategy(product_strategy_t strategy,
		device_role_t role,
		const AudioDeviceTypeAddrVector &devices)
		{
		const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
		if (aps == 0) {
		return PERMISSION_DENIED;
		}
		return aps->setPreferredDeviceForStrategy(strategy, device);
		return aps->setDevicesRoleForStrategy(strategy, role, devices);
		}

		status_t AudioSystem::removePreferredDeviceForStrategy(product_strategy_t strategy)
		status_t AudioSystem::removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role)
		{
		const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
		if (aps == 0) {
		return PERMISSION_DENIED;
		}
		return aps->removePreferredDeviceForStrategy(strategy);
		return aps->removeDevicesRoleForStrategy(strategy, role);
		}

		status_t AudioSystem::getPreferredDeviceForStrategy(product_strategy_t strategy,
		AudioDeviceTypeAddr &device)
		status_t AudioSystem::getDevicesForRoleAndStrategy(product_strategy_t strategy,
		device_role_t role,
		AudioDeviceTypeAddrVector &devices)
		{
		const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
		if (aps == 0) {
		return PERMISSION_DENIED;
		}
		return aps->getPreferredDeviceForStrategy(strategy, device);
		return aps->getDevicesForRoleAndStrategy(strategy, role, devices);
		}

		class CaptureStateListenerImpl : public media::BnCaptureStateListener,

media/libaudioclient/IAudioPolicyService.cpp

+32 −27

Original line number	Diff line number	Diff line
		@@ -112,9 +112,9 @@ enum {
		MOVE_EFFECTS_TO_IO,
		SET_RTT_ENABLED,
		IS_CALL_SCREEN_MODE_SUPPORTED,
		SET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,
		REMOVE_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,
		GET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,
		SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY,
		REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY,
		GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY,
		GET_DEVICES_FOR_ATTRIBUTES,
		AUDIO_MODULES_UPDATED, // oneway
		SET_CURRENT_IME_UID,
		@@ -1357,30 +1357,31 @@ public:
		return reply.readBool();
		}

		virtual status_t setPreferredDeviceForStrategy(product_strategy_t strategy,
		const AudioDeviceTypeAddr &device)
		virtual status_t setDevicesRoleForStrategy(product_strategy_t strategy,
		device_role_t role, const AudioDeviceTypeAddrVector &devices)
		{
		Parcel data, reply;
		data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
		data.writeUint32(static_cast<uint32_t>(strategy));
		status_t status = device.writeToParcel(&data);
		data.writeUint32(static_cast<uint32_t>(role));
		status_t status = data.writeParcelableVector(devices);
		if (status != NO_ERROR) {
		return BAD_VALUE;
		}
		status = remote()->transact(SET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,
		data, &reply);
		status = remote()->transact(SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY, data, &reply);
		if (status != NO_ERROR) {
		return status;
		}
		return static_cast<status_t>(reply.readInt32());
		}

		virtual status_t removePreferredDeviceForStrategy(product_strategy_t strategy)
		virtual status_t removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role)
		{
		Parcel data, reply;
		data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
		data.writeUint32(static_cast<uint32_t>(strategy));
		status_t status = remote()->transact(REMOVE_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,
		data.writeUint32(static_cast<uint32_t>(role));
		status_t status = remote()->transact(REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY,
		data, &reply);
		if (status != NO_ERROR) {
		return status;
		@@ -1388,18 +1389,19 @@ public:
		return static_cast<status_t>(reply.readInt32());
		}

		virtual status_t getPreferredDeviceForStrategy(product_strategy_t strategy,
		AudioDeviceTypeAddr &device)
		virtual status_t getDevicesForRoleAndStrategy(product_strategy_t strategy,
		device_role_t role, AudioDeviceTypeAddrVector &devices)
		{
		Parcel data, reply;
		data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
		data.writeUint32(static_cast<uint32_t>(strategy));
		status_t status = remote()->transact(GET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,
		data.writeUint32(static_cast<uint32_t>(role));
		status_t status = remote()->transact(GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY,
		data, &reply);
		if (status != NO_ERROR) {
		return status;
		}
		status = device.readFromParcel(&reply);
		status = reply.readParcelableVector(&devices);
		if (status != NO_ERROR) {
		return status;
		}
		@@ -1534,10 +1536,10 @@ status_t BnAudioPolicyService::onTransact(
		case RELEASE_SOUNDTRIGGER_SESSION:
		case SET_RTT_ENABLED:
		case IS_CALL_SCREEN_MODE_SUPPORTED:
		case SET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY:
		case SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY:
		case SET_SUPPORTED_SYSTEM_USAGES:
		case REMOVE_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY:
		case GET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY:
		case REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY:
		case GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY:
		case GET_DEVICES_FOR_ATTRIBUTES:
		case SET_ALLOWED_CAPTURE_POLICY:
		case AUDIO_MODULES_UPDATED:
		@@ -2616,33 +2618,36 @@ status_t BnAudioPolicyService::onTransact(
		return NO_ERROR;
		}

		case SET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY: {
		case SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY: {
		CHECK_INTERFACE(IAudioPolicyService, data, reply);
		product_strategy_t strategy = (product_strategy_t) data.readUint32();
		AudioDeviceTypeAddr device;
		status_t status = device.readFromParcel((Parcel*)&data);
		device_role_t role = (device_role_t) data.readUint32();
		AudioDeviceTypeAddrVector devices;
		status_t status = data.readParcelableVector(&devices);
		if (status != NO_ERROR) {
		return status;
		}
		status = setPreferredDeviceForStrategy(strategy, device);
		status = setDevicesRoleForStrategy(strategy, role, devices);
		reply->writeInt32(status);
		return NO_ERROR;
		}

		case REMOVE_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY: {
		case REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY: {
		CHECK_INTERFACE(IAudioPolicyService, data, reply);
		product_strategy_t strategy = (product_strategy_t) data.readUint32();
		status_t status = removePreferredDeviceForStrategy(strategy);
		device_role_t role = (device_role_t) data.readUint32();
		status_t status = removeDevicesRoleForStrategy(strategy, role);
		reply->writeInt32(status);
		return NO_ERROR;
		}

		case GET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY: {
		case GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY: {
		CHECK_INTERFACE(IAudioPolicyService, data, reply);
		product_strategy_t strategy = (product_strategy_t) data.readUint32();
		AudioDeviceTypeAddr device;
		status_t status = getPreferredDeviceForStrategy(strategy, device);
		status_t marshall_status = device.writeToParcel(reply);
		device_role_t role = (device_role_t) data.readUint32();
		AudioDeviceTypeAddrVector devices;
		status_t status = getDevicesForRoleAndStrategy(strategy, role, devices);
		status_t marshall_status = reply->writeParcelableVector(devices);
		if (marshall_status != NO_ERROR) {
		return marshall_status;
		}

media/libaudioclient/include/media/AudioSystem.h

+5 −5

Original line number	Diff line number	Diff line
		@@ -425,13 +425,13 @@ public:
		*/
		static status_t setAudioHalPids(const std::vector<pid_t>& pids);

		static status_t setPreferredDeviceForStrategy(product_strategy_t strategy,
		const AudioDeviceTypeAddr &device);
		static status_t setDevicesRoleForStrategy(product_strategy_t strategy,
		device_role_t role, const AudioDeviceTypeAddrVector &devices);

		static status_t removePreferredDeviceForStrategy(product_strategy_t strategy);
		static status_t removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role);

		static status_t getPreferredDeviceForStrategy(product_strategy_t strategy,
		AudioDeviceTypeAddr &device);
		static status_t getDevicesForRoleAndStrategy(product_strategy_t strategy,
		device_role_t role, AudioDeviceTypeAddrVector &devices);

		static status_t getDeviceForStrategy(product_strategy_t strategy,
		AudioDeviceTypeAddr &device);

media/libaudioclient/include/media/IAudioPolicyService.h

+8 −5

Original line number	Diff line number	Diff line
		@@ -241,13 +241,16 @@ public:

		virtual bool isCallScreenModeSupported() = 0;

		virtual status_t setPreferredDeviceForStrategy(product_strategy_t strategy,
		const AudioDeviceTypeAddr &device) = 0;
		virtual status_t setDevicesRoleForStrategy(product_strategy_t strategy,
		device_role_t role,
		const AudioDeviceTypeAddrVector &devices) = 0;

		virtual status_t removePreferredDeviceForStrategy(product_strategy_t strategy) = 0;
		virtual status_t removeDevicesRoleForStrategy(product_strategy_t strategy,
		device_role_t role) = 0;

		virtual status_t getPreferredDeviceForStrategy(product_strategy_t strategy,
		AudioDeviceTypeAddr &device) = 0;
		virtual status_t getDevicesForRoleAndStrategy(product_strategy_t strategy,
		device_role_t role,
		AudioDeviceTypeAddrVector &devices) = 0;

		// The return code here is only intended to represent transport errors. The
		// actual server implementation should always return NO_ERROR.

media/libaudiofoundation/AudioDeviceTypeAddr.cpp

+67 −1

Original line number	Diff line number	Diff line
		@@ -16,12 +16,56 @@

		#include <media/AudioDeviceTypeAddr.h>

		#include <arpa/inet.h>
		#include <iostream>
		#include <regex>
		#include <sstream>

		namespace android {

		namespace {

		static const std::string SUPPRESSED = "SUPPRESSED";
		static const std::regex MAC_ADDRESS_REGEX("([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}");

		bool isSenstiveAddress(const std::string &address) {
		if (std::regex_match(address, MAC_ADDRESS_REGEX)) {
		return true;
		}

		sockaddr_storage ss4;
		if (inet_pton(AF_INET, address.c_str(), &ss4) > 0) {
		return true;
		}

		sockaddr_storage ss6;
		if (inet_pton(AF_INET6, address.c_str(), &ss6) > 0) {
		return true;
		}

		return false;
		}

		} // namespace

		AudioDeviceTypeAddr::AudioDeviceTypeAddr(audio_devices_t type, const std::string &address) :
		mType(type), mAddress(address) {
		mIsAddressSensitive = isSenstiveAddress(mAddress);
		}

		const char* AudioDeviceTypeAddr::getAddress() const {
		return mAddress.c_str();
		}

		const std::string& AudioDeviceTypeAddr::address() const {
		return mAddress;
		}

		void AudioDeviceTypeAddr::setAddress(const std::string& address) {
		mAddress = address;
		mIsAddressSensitive = isSenstiveAddress(mAddress);
		}

		bool AudioDeviceTypeAddr::equals(const AudioDeviceTypeAddr& other) const {
		return mType == other.mType && mAddress == other.mAddress;
		}
		@@ -38,7 +82,17 @@ bool AudioDeviceTypeAddr::operator<(const AudioDeviceTypeAddr& other) const {

		void AudioDeviceTypeAddr::reset() {
		mType = AUDIO_DEVICE_NONE;
		mAddress = "";
		setAddress("");
		}

		std::string AudioDeviceTypeAddr::toString(bool includeSensitiveInfo) const {
		std::stringstream sstream;
		sstream << "type:0x" << std::hex << mType;
		// IP and MAC address are sensitive information. The sensitive information will be suppressed
		// is `includeSensitiveInfo` is false.
		sstream << ",@:"
		<< (!includeSensitiveInfo && mIsAddressSensitive ? SUPPRESSED : mAddress);
		return sstream.str();
		}

		status_t AudioDeviceTypeAddr::readFromParcel(const Parcel *parcel) {
		@@ -66,4 +120,16 @@ DeviceTypeSet getAudioDeviceTypes(const AudioDeviceTypeAddrVector& deviceTypeAdd
		return deviceTypes;
		}

		std::string dumpAudioDeviceTypeAddrVector(const AudioDeviceTypeAddrVector& deviceTypeAddrs,
		bool includeSensitiveInfo) {
		std::stringstream stream;
		for (auto it = deviceTypeAddrs.begin(); it != deviceTypeAddrs.end(); ++it) {
		if (it != deviceTypeAddrs.begin()) {
		stream << " ";
		}
		stream << it->toString(includeSensitiveInfo);
		}
		return stream.str();
		}

		} // namespace android