audio: Implement VTS tests for V7.0 am: d72a7c27ab am: c70238a35b (443308e8) · Commits · e / os / android_hardware_interfaces

audio/common/7.0/Android.bp

+4 −1

Original line number	Diff line number	Diff line
		@@ -16,9 +16,12 @@ hidl_interface {
		cc_library {
		name: "android.hardware.audio.common@7.0-enums",
		vendor_available: true,
		generated_sources: ["audio_policy_configuration_V7_0"],
		generated_headers: ["audio_policy_configuration_V7_0"],
		generated_sources: ["audio_policy_configuration_V7_0"],
		header_libs: ["libxsdc-utils"],
		export_generated_headers: ["audio_policy_configuration_V7_0"],
		export_header_lib_headers: ["libxsdc-utils"],
		export_include_dirs: ["enums/include"],
		shared_libs: [
		"libbase",
		"liblog",

audio/common/7.0/enums/include/audio_policy_configuration_V7_0-enums.h

0 → 100644

+207 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef AUDIO_POLICY_CONFIGURATION_V7_0_ENUMS_H
		#define AUDIO_POLICY_CONFIGURATION_V7_0_ENUMS_H

		#include <sys/types.h>

		#include <audio_policy_configuration_V7_0.h>

		namespace audio::policy::configuration::V7_0 {

		static inline size_t getChannelCount(AudioChannelMask mask) {
		switch (mask) {
		case AudioChannelMask::AUDIO_CHANNEL_OUT_MONO:
		case AudioChannelMask::AUDIO_CHANNEL_IN_MONO:
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_1:
		return 1;
		case AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_MONO_HAPTIC_A:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_HAPTIC_AB:
		case AudioChannelMask::AUDIO_CHANNEL_IN_STEREO:
		case AudioChannelMask::AUDIO_CHANNEL_IN_FRONT_BACK:
		case AudioChannelMask::AUDIO_CHANNEL_IN_VOICE_UPLINK_MONO:
		case AudioChannelMask::AUDIO_CHANNEL_IN_VOICE_DNLINK_MONO:
		case AudioChannelMask::AUDIO_CHANNEL_IN_VOICE_CALL_MONO:
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_2:
		return 2;
		case AudioChannelMask::AUDIO_CHANNEL_OUT_2POINT1:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO_HAPTIC_A:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_MONO_HAPTIC_AB:
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_3:
		return 3;
		case AudioChannelMask::AUDIO_CHANNEL_OUT_2POINT0POINT2:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_QUAD:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_QUAD_BACK:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_QUAD_SIDE:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_SURROUND:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_STEREO_HAPTIC_AB:
		case AudioChannelMask::AUDIO_CHANNEL_IN_2POINT0POINT2:
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_4:
		return 4;
		case AudioChannelMask::AUDIO_CHANNEL_OUT_2POINT1POINT2:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_3POINT0POINT2:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_PENTA:
		case AudioChannelMask::AUDIO_CHANNEL_IN_2POINT1POINT2:
		case AudioChannelMask::AUDIO_CHANNEL_IN_3POINT0POINT2:
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_5:
		return 5;
		case AudioChannelMask::AUDIO_CHANNEL_OUT_3POINT1POINT2:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_5POINT1:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_5POINT1_BACK:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_5POINT1_SIDE:
		case AudioChannelMask::AUDIO_CHANNEL_IN_6:
		case AudioChannelMask::AUDIO_CHANNEL_IN_3POINT1POINT2:
		case AudioChannelMask::AUDIO_CHANNEL_IN_5POINT1:
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_6:
		return 6;
		case AudioChannelMask::AUDIO_CHANNEL_OUT_6POINT1:
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_7:
		return 7;
		case AudioChannelMask::AUDIO_CHANNEL_OUT_5POINT1POINT2:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_7POINT1:
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_8:
		return 8;
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_9:
		return 9;
		case AudioChannelMask::AUDIO_CHANNEL_OUT_5POINT1POINT4:
		case AudioChannelMask::AUDIO_CHANNEL_OUT_7POINT1POINT2:
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_10:
		return 10;
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_11:
		return 11;
		case AudioChannelMask::AUDIO_CHANNEL_OUT_7POINT1POINT4:
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_12:
		return 12;
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_13:
		return 13;
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_14:
		return 14;
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_15:
		return 15;
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_16:
		return 16;
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_17:
		return 17;
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_18:
		return 18;
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_19:
		return 19;
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_20:
		return 20;
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_21:
		return 21;
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_22:
		return 22;
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_23:
		return 23;
		case AudioChannelMask::AUDIO_CHANNEL_INDEX_MASK_24:
		return 24;
		case AudioChannelMask::UNKNOWN:
		return 0;
		// No default to make sure all cases are covered.
		}
		// This is to avoid undefined behavior if 'mask' isn't a valid enum value.
		return 0;
		}

		static inline ssize_t getChannelCount(const std::string& mask) {
		return getChannelCount(stringToAudioChannelMask(mask));
		}

		static inline bool isOutputDevice(AudioDevice device) {
		switch (device) {
		case AudioDevice::UNKNOWN:
		case AudioDevice::AUDIO_DEVICE_NONE:
		return false;
		case AudioDevice::AUDIO_DEVICE_OUT_EARPIECE:
		case AudioDevice::AUDIO_DEVICE_OUT_SPEAKER:
		case AudioDevice::AUDIO_DEVICE_OUT_WIRED_HEADSET:
		case AudioDevice::AUDIO_DEVICE_OUT_WIRED_HEADPHONE:
		case AudioDevice::AUDIO_DEVICE_OUT_BLUETOOTH_SCO:
		case AudioDevice::AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET:
		case AudioDevice::AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT:
		case AudioDevice::AUDIO_DEVICE_OUT_BLUETOOTH_A2DP:
		case AudioDevice::AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES:
		case AudioDevice::AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER:
		case AudioDevice::AUDIO_DEVICE_OUT_AUX_DIGITAL:
		case AudioDevice::AUDIO_DEVICE_OUT_HDMI:
		case AudioDevice::AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET:
		case AudioDevice::AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET:
		case AudioDevice::AUDIO_DEVICE_OUT_USB_ACCESSORY:
		case AudioDevice::AUDIO_DEVICE_OUT_USB_DEVICE:
		case AudioDevice::AUDIO_DEVICE_OUT_REMOTE_SUBMIX:
		case AudioDevice::AUDIO_DEVICE_OUT_TELEPHONY_TX:
		case AudioDevice::AUDIO_DEVICE_OUT_LINE:
		case AudioDevice::AUDIO_DEVICE_OUT_HDMI_ARC:
		case AudioDevice::AUDIO_DEVICE_OUT_SPDIF:
		case AudioDevice::AUDIO_DEVICE_OUT_FM:
		case AudioDevice::AUDIO_DEVICE_OUT_AUX_LINE:
		case AudioDevice::AUDIO_DEVICE_OUT_SPEAKER_SAFE:
		case AudioDevice::AUDIO_DEVICE_OUT_IP:
		case AudioDevice::AUDIO_DEVICE_OUT_BUS:
		case AudioDevice::AUDIO_DEVICE_OUT_PROXY:
		case AudioDevice::AUDIO_DEVICE_OUT_USB_HEADSET:
		case AudioDevice::AUDIO_DEVICE_OUT_HEARING_AID:
		case AudioDevice::AUDIO_DEVICE_OUT_ECHO_CANCELLER:
		case AudioDevice::AUDIO_DEVICE_OUT_DEFAULT:
		case AudioDevice::AUDIO_DEVICE_OUT_STUB:
		return true;
		case AudioDevice::AUDIO_DEVICE_IN_COMMUNICATION:
		case AudioDevice::AUDIO_DEVICE_IN_AMBIENT:
		case AudioDevice::AUDIO_DEVICE_IN_BUILTIN_MIC:
		case AudioDevice::AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET:
		case AudioDevice::AUDIO_DEVICE_IN_WIRED_HEADSET:
		case AudioDevice::AUDIO_DEVICE_IN_AUX_DIGITAL:
		case AudioDevice::AUDIO_DEVICE_IN_HDMI:
		case AudioDevice::AUDIO_DEVICE_IN_VOICE_CALL:
		case AudioDevice::AUDIO_DEVICE_IN_TELEPHONY_RX:
		case AudioDevice::AUDIO_DEVICE_IN_BACK_MIC:
		case AudioDevice::AUDIO_DEVICE_IN_REMOTE_SUBMIX:
		case AudioDevice::AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET:
		case AudioDevice::AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET:
		case AudioDevice::AUDIO_DEVICE_IN_USB_ACCESSORY:
		case AudioDevice::AUDIO_DEVICE_IN_USB_DEVICE:
		case AudioDevice::AUDIO_DEVICE_IN_FM_TUNER:
		case AudioDevice::AUDIO_DEVICE_IN_TV_TUNER:
		case AudioDevice::AUDIO_DEVICE_IN_LINE:
		case AudioDevice::AUDIO_DEVICE_IN_SPDIF:
		case AudioDevice::AUDIO_DEVICE_IN_BLUETOOTH_A2DP:
		case AudioDevice::AUDIO_DEVICE_IN_LOOPBACK:
		case AudioDevice::AUDIO_DEVICE_IN_IP:
		case AudioDevice::AUDIO_DEVICE_IN_BUS:
		case AudioDevice::AUDIO_DEVICE_IN_PROXY:
		case AudioDevice::AUDIO_DEVICE_IN_USB_HEADSET:
		case AudioDevice::AUDIO_DEVICE_IN_BLUETOOTH_BLE:
		case AudioDevice::AUDIO_DEVICE_IN_HDMI_ARC:
		case AudioDevice::AUDIO_DEVICE_IN_ECHO_REFERENCE:
		case AudioDevice::AUDIO_DEVICE_IN_DEFAULT:
		case AudioDevice::AUDIO_DEVICE_IN_STUB:
		return false;
		// No default to make sure all cases are covered.
		}
		// This is to avoid undefined behavior if 'device' isn't a valid enum value.
		return false;
		}

		static inline bool isOutputDevice(const std::string& device) {
		return isOutputDevice(stringToAudioDevice(device));
		}

		} // namespace audio::policy::configuration::V7_0

		#endif // AUDIO_POLICY_CONFIGURATION_V7_0_ENUMS_H

audio/core/all-versions/vts/functional/4.0/AudioPrimaryHidlHalTest.cpp

+89 −11

Original line number	Diff line number	Diff line
		@@ -16,6 +16,13 @@

		#include "AudioPrimaryHidlHalTest.h"

		#if MAJOR_VERSION >= 7
		#include <audio_policy_configuration_V7_0.h>
		#include <xsdc/XsdcSupport.h>

		using android::xsdc_enum_range;
		#endif

		TEST_P(AudioHidlTest, OpenPrimaryDeviceUsingGetDevice) {
		doc::test("Calling openDevice(\"primary\") should return the primary device.");
		if (getDeviceName() != DeviceManager::kPrimaryDevice) {
		@@ -53,14 +60,29 @@ TEST_P(AudioHidlDeviceTest, GetMicrophonesTest) {
		"Make sure getMicrophones always succeeds"
		"and getActiveMicrophones always succeeds when recording from these microphones.");
		AudioConfig config{};
		#if MAJOR_VERSION <= 6
		config.channelMask = mkEnumBitfield(AudioChannelMask::IN_MONO);
		config.sampleRateHz = 8000;
		config.format = AudioFormat::PCM_16_BIT;
		auto flags = hidl_bitfield<AudioInputFlag>(AudioInputFlag::NONE);
		const SinkMetadata initMetadata = {{{.source = AudioSource::MIC, .gain = 1}}};
		#elif MAJOR_VERSION >= 7
		config.base.channelMask.resize(1);
		config.base.channelMask[0] = toString(xsd::AudioChannelMask::AUDIO_CHANNEL_IN_MONO);
		config.base.sampleRateHz = 8000;
		config.base.format = toString(xsd::AudioFormat::AUDIO_FORMAT_PCM_16_BIT);
		hidl_vec<hidl_string> flags;
		const SinkMetadata initMetadata = {
		{{.source = toString(xsd::AudioSource::AUDIO_SOURCE_MIC), .gain = 1}}};
		#endif
		EventFlag* efGroup;
		for (auto microphone : microphones) {
		#if MAJOR_VERSION <= 6
		if (microphone.deviceAddress.device != AudioDevice::IN_BUILTIN_MIC) {
		#elif MAJOR_VERSION >= 7
		if (xsd::stringToAudioDevice(microphone.deviceAddress.deviceType) !=
		xsd::AudioDevice::AUDIO_DEVICE_IN_BUILTIN_MIC) {
		#endif
		continue;
		}
		sp<IStreamIn> stream;
		@@ -81,7 +103,7 @@ TEST_P(AudioHidlDeviceTest, GetMicrophonesTest) {
		size_t frameSize = stream->getFrameSize();
		size_t frameCount = stream->getBufferSize() / frameSize;
		ASSERT_OK(stream->prepareForReading(
		frameSize, frameCount, [&](auto r, auto& c, auto& d, auto&, auto&) {
		frameSize, frameCount, [&](auto r, auto& c, auto& d, auto&, auto) {
		readRes = r;
		if (readRes == Result::OK) {
		commandMQ.reset(new CommandMQ(c));
		@@ -116,13 +138,24 @@ TEST_P(AudioHidlDeviceTest, GetMicrophonesTest) {

		TEST_P(AudioHidlDeviceTest, SetConnectedState) {
		doc::test("Check that the HAL can be notified of device connection and deconnection");
		#if MAJOR_VERSION <= 6
		using AD = AudioDevice;
		for (auto deviceType : {AD::OUT_HDMI, AD::OUT_WIRED_HEADPHONE, AD::IN_USB_HEADSET}) {
		#elif MAJOR_VERSION >= 7
		using AD = xsd::AudioDevice;
		for (auto deviceType :
		{toString(AD::AUDIO_DEVICE_OUT_HDMI), toString(AD::AUDIO_DEVICE_OUT_WIRED_HEADPHONE),
		toString(AD::AUDIO_DEVICE_IN_USB_HEADSET)}) {
		#endif
		SCOPED_TRACE("device=" + ::testing::PrintToString(deviceType));
		for (bool state : {true, false}) {
		SCOPED_TRACE("state=" + ::testing::PrintToString(state));
		DeviceAddress address = {};
		#if MAJOR_VERSION <= 6
		address.device = deviceType;
		#elif MAJOR_VERSION >= 7
		address.deviceType = deviceType;
		#endif
		auto ret = getDevice()->setConnectedState(address, state);
		ASSERT_TRUE(ret.isOk());
		if (ret == Result::NOT_SUPPORTED) {
		@@ -148,7 +181,11 @@ static void testGetDevices(IStream* stream, AudioDevice expectedDevice) {
		}
		// The stream was constructed with one device, thus getDevices must only return one
		ASSERT_EQ(1U, devices.size());
		#if MAJOR_VERSION <= 6
		AudioDevice device = devices[0].device;
		#elif MAJOR_VERSION >= 7
		auto device = devices[0].deviceType;
		#endif
		ASSERT_TRUE(device == expectedDevice)
		<< "Expected: " << ::testing::PrintToString(expectedDevice)
		<< "\n Actual: " << ::testing::PrintToString(device);
		@@ -156,12 +193,22 @@ static void testGetDevices(IStream* stream, AudioDevice expectedDevice) {

		TEST_IO_STREAM(GetDevices, "Check that the stream device == the one it was opened with",
		areAudioPatchesSupported() ? doc::partialTest("Audio patches are supported")
		#if MAJOR_VERSION <= 6
		: testGetDevices(stream.get(), address.device))
		#elif MAJOR_VERSION >= 7
		: testGetDevices(stream.get(), address.deviceType))
		#endif

		static void testSetDevices(IStream* stream, const DeviceAddress& address) {
		DeviceAddress otherAddress = address;
		#if MAJOR_VERSION <= 6
		otherAddress.device = (address.device & AudioDevice::BIT_IN) == 0 ? AudioDevice::OUT_SPEAKER
		: AudioDevice::IN_BUILTIN_MIC;
		#elif MAJOR_VERSION >= 7
		otherAddress.deviceType = xsd::isOutputDevice(address.deviceType)
		? toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_SPEAKER)
		: toString(xsd::AudioDevice::AUDIO_DEVICE_IN_BUILTIN_MIC);
		#endif
		EXPECT_RESULT(okOrNotSupported, stream->setDevices({otherAddress}));

		ASSERT_RESULT(okOrNotSupported,
		@@ -186,11 +233,19 @@ TEST_IO_STREAM(GetHwAvSync, "Get hardware sync can not fail", checkGetHwAVSync(g
		TEST_P(InputStreamTest, updateSinkMetadata) {
		doc::test("The HAL should not crash on metadata change");

		#if MAJOR_VERSION <= 6
		hidl_enum_range<AudioSource> range;
		#elif MAJOR_VERSION >= 7
		xsdc_enum_range<audio::policy::configuration::V7_0::AudioSource> range;
		#endif
		// Test all possible track configuration
		for (AudioSource source : range) {
		for (auto source : range) {
		for (float volume : {0.0, 0.5, 1.0}) {
		#if MAJOR_VERSION <= 6
		const SinkMetadata metadata = {{{.source = source, .gain = volume}}};
		#elif MAJOR_VERSION >= 7
		const SinkMetadata metadata = {{{.source = toString(source), .gain = volume}}};
		#endif
		ASSERT_OK(stream->updateSinkMetadata(metadata))
		<< "source=" << toString(source) << ", volume=" << volume;
		}
		@@ -213,13 +268,22 @@ TEST_P(OutputStreamTest, SelectPresentation) {
		TEST_P(OutputStreamTest, updateSourceMetadata) {
		doc::test("The HAL should not crash on metadata change");

		#if MAJOR_VERSION <= 6
		hidl_enum_range<AudioUsage> usageRange;
		hidl_enum_range<AudioContentType> contentRange;
		#elif MAJOR_VERSION >= 7
		xsdc_enum_range<audio::policy::configuration::V7_0::AudioUsage> usageRange;
		xsdc_enum_range<audio::policy::configuration::V7_0::AudioContentType> contentRange;
		#endif
		// Test all possible track configuration
		for (auto usage : usageRange) {
		for (auto content : contentRange) {
		for (float volume : {0.0, 0.5, 1.0}) {
		#if MAJOR_VERSION <= 6
		const SourceMetadata metadata = {{{usage, content, volume}}};
		#elif MAJOR_VERSION >= 7
		const SourceMetadata metadata = {{{toString(usage), toString(content), volume}}};
		#endif
		ASSERT_OK(stream->updateSourceMetadata(metadata))
		<< "usage=" << toString(usage) << ", content=" << toString(content)
		<< ", volume=" << volume;
		@@ -227,12 +291,26 @@ TEST_P(OutputStreamTest, updateSourceMetadata) {
		}
		}

		// clang-format off
		// Set many track of different configuration
		ASSERT_OK(stream->updateSourceMetadata(
		#if MAJOR_VERSION <= 6
		{{{AudioUsage::MEDIA, AudioContentType::MUSIC, 0.1},
		{AudioUsage::VOICE_COMMUNICATION, AudioContentType::SPEECH, 1.0},
		{AudioUsage::ALARM, AudioContentType::SONIFICATION, 0.0},
		{AudioUsage::ASSISTANT, AudioContentType::UNKNOWN, 0.3}}}));
		{AudioUsage::ASSISTANT, AudioContentType::UNKNOWN, 0.3}}}
		#elif MAJOR_VERSION >= 7
		{{{toString(xsd::AudioUsage::AUDIO_USAGE_MEDIA),
		toString(xsd::AudioContentType::AUDIO_CONTENT_TYPE_MUSIC), 0.1},
		{toString(xsd::AudioUsage::AUDIO_USAGE_VOICE_COMMUNICATION),
		toString(xsd::AudioContentType::AUDIO_CONTENT_TYPE_SPEECH), 1.0},
		{toString(xsd::AudioUsage::AUDIO_USAGE_ALARM),
		toString(xsd::AudioContentType::AUDIO_CONTENT_TYPE_SONIFICATION), 0.0},
		{toString(xsd::AudioUsage::AUDIO_USAGE_ASSISTANT),
		toString(xsd::AudioContentType::AUDIO_CONTENT_TYPE_UNKNOWN), 0.3}}}
		#endif
		));
		// clang-format on

		// Set no metadata as if all stream track had stopped
		ASSERT_OK(stream->updateSourceMetadata({}));

audio/core/all-versions/vts/functional/4.0/AudioPrimaryHidlHalUtils.h

+3 −1

Original line number	Diff line number	Diff line
		@@ -56,6 +56,7 @@ struct Parameters {
		}
		};

		#if MAJOR_VERSION <= 6
		struct GetSupported {
		static auto getFormat(IStream* stream) {
		auto ret = stream->getFormat();
		@@ -80,7 +81,7 @@ struct GetSupported {
		EXPECT_OK(stream->getSupportedFormats(returnIn(capabilities)));
		return Result::OK;
		}
		#elif MAJOR_VERSION >= 6
		#else // MAJOR_VERSION == 6
		static Result formats(IStream* stream, hidl_vec<AudioFormat>& capabilities) {
		Result res;
		EXPECT_OK(stream->getSupportedFormats(returnIn(res, capabilities)));
		@@ -88,6 +89,7 @@ struct GetSupported {
		}
		#endif
		};
		#endif // MAJOR_VERSION <= 6

		template <class T>
		auto dump(T t, hidl_handle handle) {

audio/core/all-versions/vts/functional/6.0/AudioPrimaryHidlHalTest.cpp

+30 −15

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@
		// pull in all the <= 5.0 tests
		#include "5.0/AudioPrimaryHidlHalTest.cpp"

		#if MAJOR_VERSION <= 6
		const std::vector<DeviceConfigParameter>& getOutputDeviceConfigParameters() {
		static std::vector<DeviceConfigParameter> parameters = [] {
		std::vector<DeviceConfigParameter> result;
		@@ -28,8 +29,8 @@ const std::vector<DeviceConfigParameter>& getOutputDeviceConfigParameters() {
		const auto& channels = profile->getChannels();
		const auto& sampleRates = profile->getSampleRates();
		auto configs = ConfigHelper::combineAudioConfig(
		vector<audio_channel_mask_t>(channels.begin(), channels.end()),
		vector<uint32_t>(sampleRates.begin(), sampleRates.end()),
		std::vector<audio_channel_mask_t>(channels.begin(), channels.end()),
		std::vector<uint32_t>(sampleRates.begin(), sampleRates.end()),
		profile->getFormat());
		auto flags = ioProfile->getFlags();
		for (auto& config : configs) {
		@@ -46,8 +47,8 @@ const std::vector<DeviceConfigParameter>& getOutputDeviceConfigParameters() {
		config.offloadInfo.bufferSize = 256; // arbitrary value
		config.offloadInfo.usage = AudioUsage::MEDIA;
		result.emplace_back(device, config,
		AudioOutputFlag(AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD \|
		AUDIO_OUTPUT_FLAG_DIRECT));
		AudioOutputFlag(AudioOutputFlag::COMPRESS_OFFLOAD \|
		AudioOutputFlag::DIRECT));
		} else {
		if (flags & AUDIO_OUTPUT_FLAG_PRIMARY) { // ignore the flag
		flags &= ~AUDIO_OUTPUT_FLAG_PRIMARY;
		@@ -74,8 +75,8 @@ const std::vector<DeviceConfigParameter>& getInputDeviceConfigParameters() {
		const auto& channels = profile->getChannels();
		const auto& sampleRates = profile->getSampleRates();
		auto configs = ConfigHelper::combineAudioConfig(
		vector<audio_channel_mask_t>(channels.begin(), channels.end()),
		vector<uint32_t>(sampleRates.begin(), sampleRates.end()),
		std::vector<audio_channel_mask_t>(channels.begin(), channels.end()),
		std::vector<uint32_t>(sampleRates.begin(), sampleRates.end()),
		profile->getFormat());
		for (const auto& config : configs) {
		result.emplace_back(device, config, AudioInputFlag(ioProfile->getFlags()));
		@@ -87,13 +88,22 @@ const std::vector<DeviceConfigParameter>& getInputDeviceConfigParameters() {
		}();
		return parameters;
		}
		#endif // MAJOR_VERSION <= 6

		TEST_P(AudioHidlDeviceTest, CloseDeviceWithOpenedOutputStreams) {
		doc::test("Verify that a device can't be closed if there are streams opened");
		#if MAJOR_VERSION <= 6
		DeviceAddress address{.device = AudioDevice::OUT_DEFAULT};
		AudioConfig config{};
		auto flags = hidl_bitfield<AudioOutputFlag>(AudioOutputFlag::NONE);
		SourceMetadata initMetadata = {{{AudioUsage::MEDIA, AudioContentType::MUSIC, 1 /* gain */}}};
		auto flags = hidl_bitfield<AudioOutputFlag>(AudioOutputFlag::NONE);
		#elif MAJOR_VERSION >= 7
		DeviceAddress address{.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_OUT_DEFAULT)};
		SourceMetadata initMetadata = {
		{{toString(xsd::AudioUsage::AUDIO_USAGE_MEDIA),
		toString(xsd::AudioContentType::AUDIO_CONTENT_TYPE_MUSIC), 1 /* gain */}}};
		hidl_vec<AudioInOutFlag> flags;
		#endif
		AudioConfig config{};
		sp<IStreamOut> stream;
		StreamHelper<IStreamOut> helper(stream);
		AudioConfig suggestedConfig{};
		@@ -111,14 +121,20 @@ TEST_P(AudioHidlDeviceTest, CloseDeviceWithOpenedOutputStreams) {

		TEST_P(AudioHidlDeviceTest, CloseDeviceWithOpenedInputStreams) {
		doc::test("Verify that a device can't be closed if there are streams opened");
		auto module = getCachedPolicyConfig().getModuleFromName(getDeviceName());
		if (module->getInputProfiles().empty()) {
		if (!getCachedPolicyConfig().haveInputProfilesInModule(getDeviceName())) {
		GTEST_SKIP() << "Device doesn't have input profiles";
		}
		#if MAJOR_VERSION <= 6
		DeviceAddress address{.device = AudioDevice::IN_DEFAULT};
		AudioConfig config{};
		auto flags = hidl_bitfield<AudioInputFlag>(AudioInputFlag::NONE);
		SinkMetadata initMetadata = {{{.source = AudioSource::MIC, .gain = 1}}};
		auto flags = hidl_bitfield<AudioInputFlag>(AudioInputFlag::NONE);
		#elif MAJOR_VERSION >= 7
		DeviceAddress address{.deviceType = toString(xsd::AudioDevice::AUDIO_DEVICE_IN_DEFAULT)};
		SinkMetadata initMetadata = {
		{{.source = toString(xsd::AudioSource::AUDIO_SOURCE_MIC), .gain = 1}}};
		hidl_vec<AudioInOutFlag> flags;
		#endif
		AudioConfig config{};
		sp<IStreamIn> stream;
		StreamHelper<IStreamIn> helper(stream);
		AudioConfig suggestedConfig{};
		@@ -137,9 +153,8 @@ TEST_P(AudioHidlDeviceTest, CloseDeviceWithOpenedInputStreams) {
		TEST_P(AudioPatchHidlTest, UpdatePatchInvalidHandle) {
		doc::test("Verify that passing an invalid handle to updateAudioPatch is checked");
		AudioPatchHandle ignored;
		ASSERT_OK(getDevice()->updateAudioPatch(
		static_cast<int32_t>(AudioHandleConsts::AUDIO_PATCH_HANDLE_NONE),
		hidl_vec<AudioPortConfig>(), hidl_vec<AudioPortConfig>(), returnIn(res, ignored)));
		ASSERT_OK(getDevice()->updateAudioPatch(AudioPatchHandle{}, hidl_vec<AudioPortConfig>(),
		hidl_vec<AudioPortConfig>(), returnIn(res, ignored)));
		ASSERT_RESULT(Result::INVALID_ARGUMENTS, res);
		}