Snap for 10068852 from 98d6368ebb04edd80adef35937a195aa7a2e008b to udc-release (9e24edf4) · Commits · e / os / android_hardware_interfaces

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

+2 −0

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

		#include <android-base/macros.h>

		#include <IOProfile.h>

		#include "6.0/Generators.h"
		#include "ConfigHelper.h"
		#include "PolicyConfig.h"

audio/core/all-versions/vts/functional/AudioPrimaryHidlHalTest.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -195,7 +195,7 @@ static constexpr char kConfigFileName[] = "audio_policy_configuration.xml";
		// Cached policy config after parsing for faster test startup
		const PolicyConfig& getCachedPolicyConfig() {
		static std::unique_ptr<PolicyConfig> policyConfig = [] {
		auto config = std::make_unique<PolicyConfig>(kConfigFileName);
		auto config = std::make_unique<PolicyConfig>("", kConfigFileName);
		return config;
		}();
		return *policyConfig;

audio/core/all-versions/vts/functional/PolicyConfig.h

+41 −56

Original line number	Diff line number	Diff line
		@@ -19,9 +19,9 @@
		#include <set>
		#include <string>

		#include <AudioPolicyConfig.h>
		#include <DeviceDescriptor.h>
		#include <HwModule.h>
		#include <Serializer.h>
		#include <gtest/gtest.h>
		#include <system/audio_config.h>

		@@ -30,47 +30,35 @@
		using ::android::sp;
		using ::android::status_t;

		struct PolicyConfigData {
		android::HwModuleCollection hwModules;
		android::DeviceVector availableOutputDevices;
		android::DeviceVector availableInputDevices;
		sp<android::DeviceDescriptor> defaultOutputDevice;
		};

		class PolicyConfig : private PolicyConfigData, public android::AudioPolicyConfig {
		class PolicyConfig {
		public:
		explicit PolicyConfig(const std::string& configFileName)
		: android::AudioPolicyConfig(hwModules, availableOutputDevices, availableInputDevices,
		defaultOutputDevice),
		mConfigFileName{configFileName} {
		for (const auto& location : android::audio_get_configuration_paths()) {
		std::string path = location + '/' + mConfigFileName;
		if (access(path.c_str(), F_OK) == 0) {
		mFilePath = path;
		break;
		}
		}
		init();
		}
		PolicyConfig(const std::string& configPath, const std::string& configFileName)
		: android::AudioPolicyConfig(hwModules, availableOutputDevices, availableInputDevices,
		defaultOutputDevice),
		mConfigFileName{configFileName},
		mFilePath{configPath + "/" + mConfigFileName} {
		: mInitialFilePath(configPath.empty() ? configFileName
		: configPath + "/" + configFileName) {
		auto result = android::AudioPolicyConfig::loadFromCustomXmlConfigForVtsTests(
		configPath, configFileName);
		if (result.ok()) {
		mStatus = ::android::OK;
		mConfig = result.value();
		init();
		} else {
		mStatus = result.error();
		}
		}
		status_t getStatus() const { return mStatus; }
		std::string getError() const {
		if (mFilePath.empty()) {
		return std::string{"Could not find "} + mConfigFileName +
		if (mConfig == nullptr) {
		return std::string{"Could not find "} + mInitialFilePath +
		" file in: " + testing::PrintToString(android::audio_get_configuration_paths());
		} else {
		return "Invalid config file: " + mFilePath;
		return "Invalid config file: " + mConfig->getSource();
		}
		}
		const std::string& getFilePath() const { return mFilePath; }
		const std::string& getFilePath() const {
		return mConfig != nullptr ? mConfig->getSource() : mInitialFilePath;
		}
		sp<const android::HwModule> getModuleFromName(const std::string& name) const {
		return getHwModules().getModuleFromName(name.c_str());
		return mConfig->getHwModules().getModuleFromName(name.c_str());
		}
		sp<const android::HwModule> getPrimaryModule() const { return mPrimaryModule; }
		const std::set<std::string>& getModulesWithDevicesNames() const {
		@@ -86,6 +74,8 @@ class PolicyConfig : private PolicyConfigData, public android::AudioPolicyConfig
		return findAttachedDevice(getAttachedDevices(moduleName),
		getSourceDevicesForMixPort(moduleName, mixPortName));
		}
		const android::DeviceVector& getInputDevices() const { return mConfig->getInputDevices(); }
		const android::DeviceVector& getOutputDevices() const { return mConfig->getOutputDevices(); }
		bool haveInputProfilesInModule(const std::string& name) const {
		auto module = getModuleFromName(name);
		return module && !module->getInputProfiles().empty();
		@@ -93,33 +83,28 @@ class PolicyConfig : private PolicyConfigData, public android::AudioPolicyConfig

		private:
		void init() {
		mStatus = android::deserializeAudioPolicyFileForVts(mFilePath.c_str(), this);
		if (mStatus == android::OK) {
		mPrimaryModule = getModuleFromName(DeviceManager::kPrimaryDevice);
		// Available devices are not 'attached' to modules at this moment.
		// Need to go over available devices and find their module.
		for (const auto& device : availableOutputDevices) {
		for (const auto& module : hwModules) {
		for (const auto& device : mConfig->getOutputDevices()) {
		for (const auto& module : mConfig->getHwModules()) {
		if (module->getDeclaredDevices().indexOf(device) >= 0) {
		mModulesWithDevicesNames.insert(module->getName());
		mAttachedDevicesPerModule[module->getName()].push_back(
		device->getTagName());
		mAttachedDevicesPerModule[module->getName()].push_back(device->getTagName());
		break;
		}
		}
		}
		for (const auto& device : availableInputDevices) {
		for (const auto& module : hwModules) {
		for (const auto& device : mConfig->getInputDevices()) {
		for (const auto& module : mConfig->getHwModules()) {
		if (module->getDeclaredDevices().indexOf(device) >= 0) {
		mModulesWithDevicesNames.insert(module->getName());
		mAttachedDevicesPerModule[module->getName()].push_back(
		device->getTagName());
		mAttachedDevicesPerModule[module->getName()].push_back(device->getTagName());
		break;
		}
		}
		}
		}
		}
		std::string findAttachedDevice(const std::vector<std::string>& attachedDevices,
		const std::set<std::string>& possibleDevices) const {
		for (const auto& device : attachedDevices) {
		@@ -166,10 +151,10 @@ class PolicyConfig : private PolicyConfigData, public android::AudioPolicyConfig
		return result;
		}

		const std::string mConfigFileName;
		const std::string mInitialFilePath;
		status_t mStatus = android::NO_INIT;
		std::string mFilePath;
		sp<const android::HwModule> mPrimaryModule = nullptr;
		sp<android::AudioPolicyConfig> mConfig;
		sp<const android::HwModule> mPrimaryModule;
		std::set<std::string> mModulesWithDevicesNames;
		std::map<std::string, std::vector<std::string>> mAttachedDevicesPerModule;
		};

automotive/remoteaccess/bind_to_device_socket_mutator/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -40,4 +40,5 @@ cc_library {
		srcs: ["src/BindToDeviceSocketMutator.cpp"],
		export_include_dirs: ["include"],
		defaults: ["BindToDeviceSocketMutatorDefaults"],
		header_libs: ["libgrpc++_internal_headers"],
		}

bluetooth/audio/utils/aidl_session/BluetoothAudioSession.cpp

+2 −64

Original line number	Diff line number	Diff line
		@@ -60,14 +60,12 @@ void BluetoothAudioSession::OnSessionStarted(
		LOG(ERROR) << __func__ << " - SessionType=" << toString(session_type_)
		<< " MqDescriptor Invalid";
		audio_config_ = nullptr;
		leaudio_connection_map_ = nullptr;
		} else {
		stack_iface_ = stack_iface;
		latency_modes_ = latency_modes;
		LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_)
		<< ", AudioConfiguration=" << audio_config.toString();
		ReportSessionStatus();
		is_streaming_ = false;
		}
		}

		@@ -76,13 +74,11 @@ void BluetoothAudioSession::OnSessionEnded() {
		bool toggled = IsSessionReady();
		LOG(INFO) << __func__ << " - SessionType=" << toString(session_type_);
		audio_config_ = nullptr;
		leaudio_connection_map_ = nullptr;
		stack_iface_ = nullptr;
		UpdateDataPath(nullptr);
		if (toggled) {
		ReportSessionStatus();
		}
		is_streaming_ = false;
		}

		/***
		@@ -110,14 +106,6 @@ const AudioConfiguration BluetoothAudioSession::GetAudioConfig() {
		return *audio_config_;
		}

		const AudioConfiguration BluetoothAudioSession::GetLeAudioConnectionMap() {
		std::lock_guard<std::recursive_mutex> guard(mutex_);
		if (!IsSessionReady()) {
		return AudioConfiguration(LeAudioConfiguration{});
		}
		return *leaudio_connection_map_;
		}

		void BluetoothAudioSession::ReportAudioConfigChanged(
		const AudioConfiguration& audio_config) {
		if (session_type_ !=
		@@ -134,47 +122,7 @@ void BluetoothAudioSession::ReportAudioConfigChanged(
		return;
		}

		if (is_streaming_) {
		if (audio_config_ == nullptr) {
		LOG(ERROR) << __func__ << " for SessionType=" << toString(session_type_)
		<< " audio_config_ is nullptr during streaming. It shouldn't "
		"be happened";
		return;
		}

		auto new_leaudio_config =
		audio_config.get<AudioConfiguration::leAudioConfig>();
		auto current_leaudio_config =
		(*audio_config_).get<AudioConfiguration::leAudioConfig>();
		if (new_leaudio_config.codecType != current_leaudio_config.codecType) {
		LOG(ERROR)
		<< __func__ << " for SessionType=" << toString(session_type_)
		<< " codec type changed during streaming. It shouldn't be happened ";
		}
		auto new_lc3_config = new_leaudio_config.leAudioCodecConfig
		.get<LeAudioCodecConfiguration::lc3Config>();
		auto current_lc3_config = current_leaudio_config.leAudioCodecConfig
		.get<LeAudioCodecConfiguration::lc3Config>();
		if ((new_lc3_config.pcmBitDepth != current_lc3_config.pcmBitDepth) \|\|
		(new_lc3_config.samplingFrequencyHz !=
		current_lc3_config.samplingFrequencyHz) \|\|
		(new_lc3_config.frameDurationUs !=
		current_lc3_config.frameDurationUs) \|\|
		(new_lc3_config.octetsPerFrame != current_lc3_config.octetsPerFrame) \|\|
		(new_lc3_config.blocksPerSdu != current_lc3_config.blocksPerSdu)) {
		LOG(ERROR)
		<< __func__ << " for SessionType=" << toString(session_type_)
		<< " lc3 config changed during streaming. It shouldn't be happened";
		return;
		}

		leaudio_connection_map_ =
		std::make_unique<AudioConfiguration>(audio_config);
		} else {
		audio_config_ = std::make_unique<AudioConfiguration>(audio_config);
		leaudio_connection_map_ =
		std::make_unique<AudioConfiguration>(audio_config);
		}

		if (observers_.empty()) {
		LOG(WARNING) << __func__ << " - SessionType=" << toString(session_type_)
		@@ -187,11 +135,7 @@ void BluetoothAudioSession::ReportAudioConfigChanged(
		LOG(INFO) << __func__ << " for SessionType=" << toString(session_type_)
		<< ", bluetooth_audio=0x"
		<< ::android::base::StringPrintf("%04x", cookie);
		if (is_streaming_) {
		if (cb->soft_audio_configuration_changed_cb_ != nullptr) {
		cb->soft_audio_configuration_changed_cb_(cookie);
		}
		} else if (cb->audio_configuration_changed_cb_ != nullptr) {
		if (cb->audio_configuration_changed_cb_ != nullptr) {
		cb->audio_configuration_changed_cb_(cookie);
		}
		}
		@@ -481,12 +425,6 @@ void BluetoothAudioSession::ReportControlStatus(bool start_resp,
		<< " has NO port state observer";
		return;
		}
		if (start_resp && status == BluetoothAudioStatus::SUCCESS) {
		is_streaming_ = true;
		} else if (!start_resp && (status == BluetoothAudioStatus::SUCCESS \|\|
		status == BluetoothAudioStatus::RECONFIGURATION)) {
		is_streaming_ = false;
		}
		for (auto& observer : observers_) {
		uint16_t cookie = observer.first;
		std::shared_ptr<PortStatusCallbacks> callback = observer.second;