Snap for 8408164 from 9378da8b4b48ab761aaa3e778cdb19d8258c01a6 to tm-release (43cda535) · Commits · e / os / android_hardware_interfaces

automotive/audiocontrol/aidl/default/Android.bp

+2 −1

Original line number	Diff line number	Diff line
		@@ -29,8 +29,9 @@ cc_binary {
		vendor: true,
		shared_libs: [
		"android.hardware.audio.common@7.0-enums",
		"android.hardware.audio.common-V1-ndk",
		"android.frameworks.automotive.powerpolicy-V1-ndk",
		"android.hardware.automotive.audiocontrol-V1-ndk",
		"android.hardware.automotive.audiocontrol-V2-ndk",
		"libbase",
		"libbinder_ndk",
		"libcutils",

automotive/audiocontrol/aidl/default/AudioControl.cpp

+251 −3

Original line number	Diff line number	Diff line
		@@ -30,6 +30,8 @@
		#include <android_audio_policy_configuration_V7_0-enums.h>
		#include <private/android_filesystem_config.h>

		#include <numeric>

		#include <stdio.h>

		namespace aidl::android::hardware::automotive::audiocontrol {
		@@ -147,6 +149,47 @@ ndk::ScopedAStatus AudioControl::onDevicesToMuteChange(
		return ndk::ScopedAStatus::ok();
		}

		template <typename aidl_type>
		static inline std::string toString(const std::vector<aidl_type>& in_values) {
		return std::accumulate(std::begin(in_values), std::end(in_values), std::string{},
		[](std::string& ls, const aidl_type& rs) {
		return ls += (ls.empty() ? "" : ",") + rs.toString();
		});
		}
		template <typename aidl_enum_type>
		static inline std::string toEnumString(const std::vector<aidl_enum_type>& in_values) {
		return std::accumulate(std::begin(in_values), std::end(in_values), std::string{},
		[](std::string& ls, const aidl_enum_type& rs) {
		return ls += (ls.empty() ? "" : ",") + toString(rs);
		});
		}

		ndk::ScopedAStatus AudioControl::onAudioFocusChangeWithMetaData(
		const audiohalcommon::PlaybackTrackMetadata& in_playbackMetaData, int32_t in_zoneId,
		AudioFocusChange in_focusChange) {
		LOG(INFO) << "Focus changed: " << toString(in_focusChange).c_str() << " for metadata "
		<< in_playbackMetaData.toString().c_str() << " in zone " << in_zoneId;
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus AudioControl::setAudioDeviceGainsChanged(
		const std::vector<Reasons>& in_reasons, const std::vector<AudioGainConfigInfo>& in_gains) {
		LOG(INFO) << "Audio Device Gains changed: resons:" << toEnumString(in_reasons).c_str()
		<< " for devices: " << toString(in_gains).c_str();
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus AudioControl::registerGainCallback(
		const std::shared_ptr<IAudioGainCallback>& in_callback) {
		LOG(DEBUG) << ": " << __func__;
		if (in_callback) {
		std::atomic_store(&mAudioGainCallback, in_callback);
		} else {
		LOG(ERROR) << "Unexpected nullptr for audio gain callback resulting in no-op.";
		}
		return ndk::ScopedAStatus::ok();
		}

		binder_status_t AudioControl::dump(int fd, const char** args, uint32_t numArgs) {
		if (numArgs == 0) {
		return dumpsys(fd);
		@@ -159,6 +202,12 @@ binder_status_t AudioControl::dump(int fd, const char** args, uint32_t numArgs)
		return cmdRequestFocus(fd, args, numArgs);
		} else if (EqualsIgnoreCase(option, "--abandon")) {
		return cmdAbandonFocus(fd, args, numArgs);
		} else if (EqualsIgnoreCase(option, "--requestFocusWithMetaData")) {
		return cmdRequestFocusWithMetaData(fd, args, numArgs);
		} else if (EqualsIgnoreCase(option, "--abandonFocusWithMetaData")) {
		return cmdAbandonFocusWithMetaData(fd, args, numArgs);
		} else if (EqualsIgnoreCase(option, "--audioGainCallback")) {
		return cmdOnAudioDeviceGainsChanged(fd, args, numArgs);
		} else {
		dprintf(fd, "Invalid option: %s\n", option.c_str());
		return STATUS_BAD_VALUE;
		@@ -171,20 +220,49 @@ binder_status_t AudioControl::dumpsys(int fd) {
		} else {
		dprintf(fd, "Focus listener registered\n");
		}
		dprintf(fd, "AudioGainCallback %sregistered\n", (mAudioGainCallback == nullptr ? "NOT " : ""));
		return STATUS_OK;
		}

		binder_status_t AudioControl::cmdHelp(int fd) const {
		dprintf(fd, "Usage: \n\n");
		dprintf(fd, "[no args]: dumps focus listener status\n");
		dprintf(fd, "[no args]: dumps focus listener / gain callback registered status\n");
		dprintf(fd, "--help: shows this help\n");
		dprintf(fd,
		"--request <USAGE> <ZONE_ID> <FOCUS_GAIN>: requests audio focus for specified "
		"usage (string), audio zone ID (int), and focus gain type (int)\n");
		"usage (string), audio zone ID (int), and focus gain type (int)\n"
		"Deprecated, use MetaData instead\n");
		dprintf(fd,
		"--abandon <USAGE> <ZONE_ID>: abandons audio focus for specified usage (string) and "
		"audio zone ID (int)\n");
		"audio zone ID (int)\n"
		"Deprecated, use MetaData instead\n");
		dprintf(fd, "See audio_policy_configuration.xsd for valid AudioUsage values.\n");

		dprintf(fd,
		"--requestFocusWithMetaData <METADATA> <ZONE_ID> <FOCUS_GAIN>: "
		"requests audio focus for specified metadata, audio zone ID (int), "
		"and focus gain type (int)\n");
		dprintf(fd,
		"--abandonFocusWithMetaData <METADATA> <ZONE_ID>: "
		"abandons audio focus for specified metadata and audio zone ID (int)\n");
		dprintf(fd,
		"--audioGainCallback <ZONE_ID> <REASON_1>[,<REASON_N> ...]"
		"<DEVICE_ADDRESS_1> <GAIN_INDEX_1> [<DEVICE_ADDRESS_N> <GAIN_INDEX_N> ...]: fire audio "
		"gain callback for audio zone ID (int), the given reasons (csv int) for given pairs "
		"of device address (string) and gain index (int) \n");

		dprintf(fd,
		"Note on <METADATA>: <USAGE,CONTENT_TYPE[,TAGS]> specified as where (int)usage, "
		"(int)content type and tags (string)string)\n");
		dprintf(fd,
		"See android/media/audio/common/AudioUsageType.aidl for valid AudioUsage values.\n");
		dprintf(fd,
		"See android/media/audio/common/AudioContentType.aidl for valid AudioContentType "
		"values.\n");
		dprintf(fd,
		"Tags are optional. If provided, it must follow the <key>=<value> pattern, where the "
		"value is namespaced (for example com.google.strategy=VR).\n");

		return STATUS_OK;
		}

		@@ -266,4 +344,174 @@ binder_status_t AudioControl::cmdAbandonFocus(int fd, const char** args, uint32_
		return STATUS_OK;
		}

		binder_status_t AudioControl::parseMetaData(int fd, const std::string& metadataLiteral,
		audiohalcommon::PlaybackTrackMetadata& trackMetadata) {
		std::stringstream csvMetaData(metadataLiteral);
		std::vector<std::string> splitMetaData;
		std::string attribute;
		while (getline(csvMetaData, attribute, ',')) {
		splitMetaData.push_back(attribute);
		}
		if (splitMetaData.size() != 2 && splitMetaData.size() != 3) {
		dprintf(fd,
		"Invalid metadata: %s, please provide <METADATA> as <USAGE,CONTENT_TYPE[,TAGS]> "
		"where (int)usage, (int)content type and tags (string)string)\n",
		metadataLiteral.c_str());
		return STATUS_BAD_VALUE;
		}
		int usage;
		if (!safelyParseInt(splitMetaData[0], &usage)) {
		dprintf(fd, "Non-integer usage provided with request: %s\n", splitMetaData[0].c_str());
		return STATUS_BAD_VALUE;
		}
		int contentType;
		if (!safelyParseInt(splitMetaData[1], &contentType)) {
		dprintf(fd, "Non-integer content type provided with request: %s\n",
		splitMetaData[1].c_str());
		return STATUS_BAD_VALUE;
		}
		const std::string tags = (splitMetaData.size() == 3 ? splitMetaData[2] : "");

		trackMetadata = {.usage = static_cast<audiomediacommon::AudioUsage>(usage),
		.contentType = static_cast<audiomediacommon::AudioContentType>(contentType),
		.tags = {tags}};
		return STATUS_OK;
		}

		binder_status_t AudioControl::cmdRequestFocusWithMetaData(int fd, const char** args,
		uint32_t numArgs) {
		if (!checkCallerHasWritePermissions(fd)) {
		return STATUS_PERMISSION_DENIED;
		}
		if (numArgs != 4) {
		dprintf(fd,
		"Invalid number of arguments: please provide:\n"
		"--requestFocusWithMetaData <METADATA> <ZONE_ID> <FOCUS_GAIN>: "
		"requests audio focus for specified metadata, audio zone ID (int), "
		"and focus gain type (int)\n");
		return STATUS_BAD_VALUE;
		}
		std::string metadataLiteral = std::string(args[1]);
		audiohalcommon::PlaybackTrackMetadata trackMetadata{};
		auto status = parseMetaData(fd, metadataLiteral, trackMetadata);
		if (status != STATUS_OK) {
		return status;
		}

		int zoneId;
		if (!safelyParseInt(std::string(args[2]), &zoneId)) {
		dprintf(fd, "Non-integer zoneId provided with request: %s\n", std::string(args[2]).c_str());
		return STATUS_BAD_VALUE;
		}

		int focusGainValue;
		if (!safelyParseInt(std::string(args[3]), &focusGainValue)) {
		dprintf(fd, "Non-integer focusGain provided with request: %s\n",
		std::string(args[3]).c_str());
		return STATUS_BAD_VALUE;
		}
		AudioFocusChange focusGain = AudioFocusChange(focusGainValue);

		if (mFocusListener == nullptr) {
		dprintf(fd, "Unable to request focus - no focus listener registered\n");
		return STATUS_BAD_VALUE;
		}
		mFocusListener->requestAudioFocusWithMetaData(trackMetadata, zoneId, focusGain);
		dprintf(fd, "Requested focus for metadata %s, zoneId %d, and focusGain %d\n",
		trackMetadata.toString().c_str(), zoneId, focusGain);
		return STATUS_OK;
		}

		binder_status_t AudioControl::cmdAbandonFocusWithMetaData(int fd, const char** args,
		uint32_t numArgs) {
		if (!checkCallerHasWritePermissions(fd)) {
		return STATUS_PERMISSION_DENIED;
		}
		if (numArgs != 3) {
		dprintf(fd,
		"Invalid number of arguments: please provide:\n"
		"--abandonFocusWithMetaData <METADATA> <ZONE_ID>: "
		"abandons audio focus for specified metadata and audio zone ID (int)\n");
		return STATUS_BAD_VALUE;
		}
		std::string metadataLiteral = std::string(args[1]);
		audiohalcommon::PlaybackTrackMetadata trackMetadata{};
		auto status = parseMetaData(fd, metadataLiteral, trackMetadata);
		if (status != STATUS_OK) {
		return status;
		}
		int zoneId;
		if (!safelyParseInt(std::string(args[2]), &zoneId)) {
		dprintf(fd, "Non-integer zoneId provided with request: %s\n", std::string(args[2]).c_str());
		return STATUS_BAD_VALUE;
		}
		if (mFocusListener == nullptr) {
		dprintf(fd, "Unable to abandon focus - no focus listener registered\n");
		return STATUS_BAD_VALUE;
		}

		mFocusListener->abandonAudioFocusWithMetaData(trackMetadata, zoneId);
		dprintf(fd, "Abandoned focus for metadata %s and zoneId %d\n", trackMetadata.toString().c_str(),
		zoneId);
		return STATUS_OK;
		}

		binder_status_t AudioControl::cmdOnAudioDeviceGainsChanged(int fd, const char** args,
		uint32_t numArgs) {
		if (!checkCallerHasWritePermissions(fd)) {
		return STATUS_PERMISSION_DENIED;
		}
		if ((numArgs + 1) % 2 != 0) {
		dprintf(fd,
		"Invalid number of arguments: please provide\n"
		"--audioGainCallback <ZONE_ID> <REASON_1>[,<REASON_N> ...]"
		"<DEVICE_ADDRESS_1> <GAIN_INDEX_1> [<DEVICE_ADDRESS_N> <GAIN_INDEX_N> ...]: "
		"fire audio gain callback for audio zone ID (int), "
		"with the given reasons (csv int) for given pairs of device address (string) "
		"and gain index (int) \n");
		return STATUS_BAD_VALUE;
		}
		int zoneId;
		if (!safelyParseInt(string(args[1]), &zoneId)) {
		dprintf(fd, "Non-integer zoneId provided with request: %s\n", std::string(args[1]).c_str());
		return STATUS_BAD_VALUE;
		}
		std::string reasonsLiteral = std::string(args[2]);
		std::stringstream csvReasonsLiteral(reasonsLiteral);
		std::vector<Reasons> reasons;
		std::string reasonLiteral;
		while (getline(csvReasonsLiteral, reasonLiteral, ',')) {
		int reason;
		if (!safelyParseInt(reasonLiteral, &reason)) {
		dprintf(fd, "Invalid Reason(s) provided %s\n", reasonLiteral.c_str());
		return STATUS_BAD_VALUE;
		}
		reasons.push_back(static_cast<Reasons>(reason));
		}

		std::vector<AudioGainConfigInfo> agcis{};
		for (uint32_t i = 3; i < numArgs; i += 2) {
		std::string deviceAddress = std::string(args[i]);
		int32_t index;
		if (!safelyParseInt(std::string(args[i + 1]), &index)) {
		dprintf(fd, "Non-integer index provided with request: %s\n",
		std::string(args[i + 1]).c_str());
		return STATUS_BAD_VALUE;
		}
		AudioGainConfigInfo agci{zoneId, deviceAddress, index};
		agcis.push_back(agci);
		}
		if (mAudioGainCallback == nullptr) {
		dprintf(fd,
		"Unable to trig audio gain callback for reasons=%s and gains=%s\n"
		" - no audio gain callback registered\n",
		toEnumString(reasons).c_str(), toString(agcis).c_str());
		return STATUS_BAD_VALUE;
		}

		mAudioGainCallback->onAudioDeviceGainsChanged(reasons, agcis);
		dprintf(fd, "Fired audio gain callback for reasons=%s and gains=%s\n",
		toEnumString(reasons).c_str(), toString(agcis).c_str());
		return STATUS_OK;
		}
		} // namespace aidl::android::hardware::automotive::audiocontrol

automotive/audiocontrol/aidl/default/AudioControl.h

+30 −0

Original line number	Diff line number	Diff line
		@@ -17,12 +17,20 @@
		#define ANDROID_HARDWARE_AUTOMOTIVE_AUDIOCONTROL_AUDIOCONTROL_H

		#include <aidl/android/hardware/automotive/audiocontrol/AudioFocusChange.h>
		#include <aidl/android/hardware/automotive/audiocontrol/AudioGainConfigInfo.h>
		#include <aidl/android/hardware/automotive/audiocontrol/BnAudioControl.h>
		#include <aidl/android/hardware/automotive/audiocontrol/DuckingInfo.h>
		#include <aidl/android/hardware/automotive/audiocontrol/IAudioGainCallback.h>
		#include <aidl/android/hardware/automotive/audiocontrol/MutingInfo.h>
		#include <aidl/android/hardware/automotive/audiocontrol/Reasons.h>

		#include <aidl/android/hardware/audio/common/PlaybackTrackMetadata.h>

		namespace aidl::android::hardware::automotive::audiocontrol {

		namespace audiohalcommon = ::aidl::android::hardware::audio::common;
		namespace audiomediacommon = ::aidl::android::media::audio::common;

		class AudioControl : public BnAudioControl {
		public:
		ndk::ScopedAStatus onAudioFocusChange(const std::string& in_usage, int32_t in_zoneId,
		@@ -35,6 +43,15 @@ class AudioControl : public BnAudioControl {
		const std::shared_ptr<IFocusListener>& in_listener) override;
		ndk::ScopedAStatus setBalanceTowardRight(float in_value) override;
		ndk::ScopedAStatus setFadeTowardFront(float in_value) override;
		ndk::ScopedAStatus onAudioFocusChangeWithMetaData(
		const audiohalcommon::PlaybackTrackMetadata& in_playbackMetaData, int32_t in_zoneId,
		AudioFocusChange in_focusChange) override;
		ndk::ScopedAStatus setAudioDeviceGainsChanged(
		const std::vector<Reasons>& in_reasons,
		const std::vector<AudioGainConfigInfo>& in_gains) override;
		ndk::ScopedAStatus registerGainCallback(
		const std::shared_ptr<IAudioGainCallback>& in_callback) override;

		binder_status_t dump(int fd, const char** args, uint32_t numArgs) override;

		private:
		@@ -44,9 +61,22 @@ class AudioControl : public BnAudioControl {
		// listener, then it should also include mutexes or make the listener atomic.
		std::shared_ptr<IFocusListener> mFocusListener;

		/**
		* @brief mAudioGainCallback will be used by this HAL instance to communicate e.g. with a single
		* instance of CarAudioService to report unexpected gain changed.
		*/
		std::shared_ptr<IAudioGainCallback> mAudioGainCallback = nullptr;

		binder_status_t cmdHelp(int fd) const;
		binder_status_t cmdRequestFocus(int fd, const char** args, uint32_t numArgs);
		binder_status_t cmdAbandonFocus(int fd, const char** args, uint32_t numArgs);
		binder_status_t cmdRequestFocusWithMetaData(int fd, const char** args, uint32_t numArgs);
		binder_status_t cmdAbandonFocusWithMetaData(int fd, const char** args, uint32_t numArgs);
		binder_status_t cmdOnAudioDeviceGainsChanged(int fd, const char** args, uint32_t numArgs);

		binder_status_t parseMetaData(int fd, const std::string& metadataLiteral,
		audiohalcommon::PlaybackTrackMetadata& trackMetadata);

		binder_status_t dumpsys(int fd);
		};

automotive/audiocontrol/aidl/default/audiocontrol-default.xml

+1 −1

Original line number	Diff line number	Diff line
		<manifest version="1.0" type="device">
		<manifest version="2.0" type="device">
		<hal format="aidl">
		<name>android.hardware.automotive.audiocontrol</name>
		<fqname>IAudioControl/default</fqname>

automotive/audiocontrol/aidl/vts/Android.bp

+6 −1

Original line number	Diff line number	Diff line
		@@ -37,11 +37,16 @@ cc_test {
		"libxml2",
		],
		static_libs: [
		"android.hardware.automotive.audiocontrol-V1-cpp",
		"android.hardware.automotive.audiocontrol-V2-cpp",
		"android.hardware.audio.common-V1-cpp",
		"android.media.audio.common.types-V1-cpp",
		"libgmock",
		],
		test_suites: [
		"general-tests",
		"vts",
		],
		cflags: [
		"-Wno-deprecated-declarations",
		],
		}