release-request-323db86e-b638-4d24-8eb1-d2e3bf4a9d1a-for-git_oc-mr1-release-40... (d186cc87) · Commits · e / os / android_hardware_interfaces

.clang-format

+1 −5

Original line number	Diff line number	Diff line
		@@ -14,15 +14,11 @@
		# limitations under the License.
		#

		#
		# Below are some minor deviations from the default Google style to
		# accommodate for handling of the large legacy code base.
		#

		BasedOnStyle: Google
		CommentPragmas: NOLINT:.*
		DerivePointerAlignment: false
		AllowShortFunctionsOnASingleLine: Inline
		ColumnLimit: 100
		TabWidth: 4
		UseTab: Never
		IndentWidth: 4

CleanSpec.mk

+3 −0

Original line number	Diff line number	Diff line
		@@ -52,3 +52,6 @@ $(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/bin/hw/android.hardware.blue
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/hw/android.hardware.bluetooth*)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib64/hw/android.hardware.bluetooth*)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/etc/init/android.hardware.bluetooth*)
		$(call add-clean-step, rm -rf $(OUT)/soong/.intermediates/)
		$(call add-clean-step, rm -rf $(OUT_DIR)/soong/.intermediates/hardware/interfaces/)
		$(call add-clean-step, rm -rf $(OUT_DIR)/soong/.intermediates/hardware/interfaces/)

audio/2.0/Android.bp

+2 −4

Original line number	Diff line number	Diff line
		@@ -17,7 +17,7 @@ filegroup {
		genrule {
		name: "android.hardware.audio@2.0_genc++",
		tools: ["hidl-gen"],
		cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio@2.0",
		cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio@2.0",
		srcs: [
		":android.hardware.audio@2.0_hal",
		],
		@@ -36,7 +36,7 @@ genrule {
		genrule {
		name: "android.hardware.audio@2.0_genc++_headers",
		tools: ["hidl-gen"],
		cmd: "$(location hidl-gen) -o $(genDir) -Lc++ -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio@2.0",
		cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.audio@2.0",
		srcs: [
		":android.hardware.audio@2.0_hal",
		],
		@@ -95,7 +95,6 @@ cc_library_shared {
		"libutils",
		"libcutils",
		"android.hardware.audio.common@2.0",
		"android.hidl.base@1.0",
		],
		export_shared_lib_headers: [
		"libhidlbase",
		@@ -103,6 +102,5 @@ cc_library_shared {
		"libhwbinder",
		"libutils",
		"android.hardware.audio.common@2.0",
		"android.hidl.base@1.0",
		],
		}

audio/2.0/default/Device.cpp

+177 −110

Original line number	Diff line number	Diff line
		@@ -17,9 +17,11 @@
		#define LOG_TAG "DeviceHAL"
		//#define LOG_NDEBUG 0

		#include <algorithm>
		#include <memory.h>
		#include <string.h>
		#include <algorithm>
		#include <mutex>
		#include <vector>

		#include <android/log.h>

		@@ -28,6 +30,7 @@
		#include "HidlUtils.h"
		#include "StreamIn.h"
		#include "StreamOut.h"
		#include "Util.h"

		namespace android {
		namespace hardware {
		@@ -35,13 +38,63 @@ namespace audio {
		namespace V2_0 {
		namespace implementation {

		Device::Device(audio_hw_device_t* device)
		: mDevice(device) {
		namespace {

		class Diagnostics {
		public:
		static Diagnostics& getInstance() {
		std::lock_guard<std::mutex> _(mLock);
		if (mInstance == nullptr) {
		mInstance = new Diagnostics;
		}
		return *mInstance;
		}

		void registerDevice(Device* dev) {
		std::lock_guard<std::mutex> _(mLock);
		mDevices.push_back(wp<Device>(dev));
		}

		void checkForErasedHalCblk(const Device* dev) {
		if (dev->version() != 0) return; // all OK

		std::ostringstream ss;
		ss << "Zero HAL CB for " << dev->type() << ":" << std::hex
		<< dev->device() << "; Others: ";
		{
		std::lock_guard<std::mutex> _(mLock);
		for (auto wp : mDevices) {
		sp<Device> other{wp.promote()};
		if (other.get() == nullptr \|\| other.get() == dev) continue;
		ss << other->type() << ":" << other->version() << ":"
		<< std::hex << other->device() << "; ";
		}
		}
		ALOGE("%s", ss.str().c_str());
		}

		private:
		Diagnostics() {}

		static std::mutex mLock;
		static Diagnostics* mInstance;
		std::vector<wp<Device>> mDevices;
		};

		std::mutex Diagnostics::mLock;
		Diagnostics* Diagnostics::mInstance{nullptr};

		} // namespace

		Device::Device(audio_hw_device_t* device, const char* type)
		: mDevice{device}, mType{type} {
		Diagnostics::getInstance().registerDevice(this);
		}

		Device::~Device() {
		int status = audio_hw_device_close(mDevice);
		ALOGW_IF(status, "Error closing audio hw device %p: %s", mDevice, strerror(-status));
		ALOGW_IF(status, "Error closing audio hw device %p: %s", mDevice,
		strerror(-status));
		mDevice = nullptr;
		}

		@@ -50,12 +103,18 @@ Result Device::analyzeStatus(const char* funcName, int status) {
		ALOGW("Device %p %s: %s", mDevice, funcName, strerror(-status));
		}
		switch (status) {
		case 0: return Result::OK;
		case -EINVAL: return Result::INVALID_ARGUMENTS;
		case -ENODATA: return Result::INVALID_STATE;
		case -ENODEV: return Result::NOT_INITIALIZED;
		case -ENOSYS: return Result::NOT_SUPPORTED;
		default: return Result::INVALID_STATE;
		case 0:
		return Result::OK;
		case -EINVAL:
		return Result::INVALID_ARGUMENTS;
		case -ENODATA:
		return Result::INVALID_STATE;
		case -ENODEV:
		return Result::NOT_INITIALIZED;
		case -ENOSYS:
		return Result::NOT_SUPPORTED;
		default:
		return Result::INVALID_STATE;
		}
		}

		@@ -68,10 +127,12 @@ void Device::closeOutputStream(audio_stream_out_t* stream) {
		}

		char* Device::halGetParameters(const char* keys) {
		Diagnostics::getInstance().checkForErasedHalCblk(this);
		return mDevice->get_parameters(mDevice, keys);
		}

		int Device::halSetParameters(const char* keysAndValues) {
		Diagnostics::getInstance().checkForErasedHalCblk(this);
		return mDevice->set_parameters(mDevice, keysAndValues);
		}

		@@ -81,18 +142,23 @@ Return<Result> Device::initCheck() {
		}

		Return<Result> Device::setMasterVolume(float volume) {
		Result retval(Result::NOT_SUPPORTED);
		if (mDevice->set_master_volume != NULL) {
		retval = analyzeStatus("set_master_volume", mDevice->set_master_volume(mDevice, volume));
		if (mDevice->set_master_volume == NULL) {
		return Result::NOT_SUPPORTED;
		}
		return retval;
		if (!isGainNormalized(volume)) {
		ALOGW("Can not set a master volume (%f) outside [0,1]", volume);
		return Result::INVALID_ARGUMENTS;
		}
		return analyzeStatus("set_master_volume",
		mDevice->set_master_volume(mDevice, volume));
		}

		Return<void> Device::getMasterVolume(getMasterVolume_cb _hidl_cb) {
		Result retval(Result::NOT_SUPPORTED);
		float volume = 0;
		if (mDevice->get_master_volume != NULL) {
		retval = analyzeStatus("get_master_volume", mDevice->get_master_volume(mDevice, &volume));
		retval = analyzeStatus("get_master_volume",
		mDevice->get_master_volume(mDevice, &volume));
		}
		_hidl_cb(retval, volume);
		return Void();
		@@ -104,7 +170,8 @@ Return<Result> Device::setMicMute(bool mute) {

		Return<void> Device::getMicMute(getMicMute_cb _hidl_cb) {
		bool mute = false;
		Result retval = analyzeStatus("get_mic_mute", mDevice->get_mic_mute(mDevice, &mute));
		Result retval =
		analyzeStatus("get_mic_mute", mDevice->get_mic_mute(mDevice, &mute));
		_hidl_cb(retval, mute);
		return Void();
		}
		@@ -112,7 +179,8 @@ Return<void> Device::getMicMute(getMicMute_cb _hidl_cb) {
		Return<Result> Device::setMasterMute(bool mute) {
		Result retval(Result::NOT_SUPPORTED);
		if (mDevice->set_master_mute != NULL) {
		retval = analyzeStatus("set_master_mute", mDevice->set_master_mute(mDevice, mute));
		retval = analyzeStatus("set_master_mute",
		mDevice->set_master_mute(mDevice, mute));
		}
		return retval;
		}
		@@ -121,14 +189,15 @@ Return<void> Device::getMasterMute(getMasterMute_cb _hidl_cb) {
		Result retval(Result::NOT_SUPPORTED);
		bool mute = false;
		if (mDevice->get_master_mute != NULL) {
		retval = analyzeStatus("get_master_mute", mDevice->get_master_mute(mDevice, &mute));
		retval = analyzeStatus("get_master_mute",
		mDevice->get_master_mute(mDevice, &mute));
		}
		_hidl_cb(retval, mute);
		return Void();
		}

		Return<void> Device::getInputBufferSize(
		const AudioConfig& config, getInputBufferSize_cb _hidl_cb) {
		Return<void> Device::getInputBufferSize(const AudioConfig& config,
		getInputBufferSize_cb _hidl_cb) {
		audio_config_t halConfig;
		HidlUtils::audioConfigToHal(config, &halConfig);
		size_t halBufferSize = mDevice->get_input_buffer_size(mDevice, &halConfig);
		@@ -142,8 +211,7 @@ Return<void> Device::getInputBufferSize(
		return Void();
		}

		Return<void> Device::openOutputStream(
		int32_t ioHandle,
		Return<void> Device::openOutputStream(int32_t ioHandle,
		const DeviceAddress& device,
		const AudioConfig& config,
		AudioOutputFlag flags,
		@@ -151,19 +219,16 @@ Return<void> Device::openOutputStream(
		audio_config_t halConfig;
		HidlUtils::audioConfigToHal(config, &halConfig);
		audio_stream_out_t* halStream;
		ALOGV("open_output_stream handle: %d devices: %x flags: %#x "
		ALOGV(
		"open_output_stream handle: %d devices: %x flags: %#x "
		"srate: %d format %#x channels %x address %s",
		ioHandle,
		static_cast<audio_devices_t>(device.device), static_cast<audio_output_flags_t>(flags),
		halConfig.sample_rate, halConfig.format, halConfig.channel_mask,
		ioHandle, static_cast<audio_devices_t>(device.device),
		static_cast<audio_output_flags_t>(flags), halConfig.sample_rate,
		halConfig.format, halConfig.channel_mask,
		deviceAddressToHal(device).c_str());
		int status = mDevice->open_output_stream(
		mDevice,
		ioHandle,
		static_cast<audio_devices_t>(device.device),
		static_cast<audio_output_flags_t>(flags),
		&halConfig,
		&halStream,
		mDevice, ioHandle, static_cast<audio_devices_t>(device.device),
		static_cast<audio_output_flags_t>(flags), &halConfig, &halStream,
		deviceAddressToHal(device).c_str());
		ALOGV("open_output_stream status %d stream %p", status, halStream);
		sp<IStreamOut> streamOut;
		@@ -172,33 +237,30 @@ Return<void> Device::openOutputStream(
		}
		AudioConfig suggestedConfig;
		HidlUtils::audioConfigFromHal(halConfig, &suggestedConfig);
		_hidl_cb(analyzeStatus("open_output_stream", status), streamOut, suggestedConfig);
		_hidl_cb(analyzeStatus("open_output_stream", status), streamOut,
		suggestedConfig);
		return Void();
		}

		Return<void> Device::openInputStream(
		int32_t ioHandle,
		Return<void> Device::openInputStream(int32_t ioHandle,
		const DeviceAddress& device,
		const AudioConfig& config,
		AudioInputFlag flags,
		AudioSource source,
		AudioInputFlag flags, AudioSource source,
		openInputStream_cb _hidl_cb) {
		audio_config_t halConfig;
		HidlUtils::audioConfigToHal(config, &halConfig);
		audio_stream_in_t* halStream;
		ALOGV("open_input_stream handle: %d devices: %x flags: %#x "
		ALOGV(
		"open_input_stream handle: %d devices: %x flags: %#x "
		"srate: %d format %#x channels %x address %s source %d",
		ioHandle,
		static_cast<audio_devices_t>(device.device), static_cast<audio_input_flags_t>(flags),
		halConfig.sample_rate, halConfig.format, halConfig.channel_mask,
		deviceAddressToHal(device).c_str(), static_cast<audio_source_t>(source));
		ioHandle, static_cast<audio_devices_t>(device.device),
		static_cast<audio_input_flags_t>(flags), halConfig.sample_rate,
		halConfig.format, halConfig.channel_mask,
		deviceAddressToHal(device).c_str(),
		static_cast<audio_source_t>(source));
		int status = mDevice->open_input_stream(
		mDevice,
		ioHandle,
		static_cast<audio_devices_t>(device.device),
		&halConfig,
		&halStream,
		static_cast<audio_input_flags_t>(flags),
		mDevice, ioHandle, static_cast<audio_devices_t>(device.device),
		&halConfig, &halStream, static_cast<audio_input_flags_t>(flags),
		deviceAddressToHal(device).c_str(),
		static_cast<audio_source_t>(source));
		ALOGV("open_input_stream status %d stream %p", status, halStream);
		@@ -208,7 +270,8 @@ Return<void> Device::openInputStream(
		}
		AudioConfig suggestedConfig;
		HidlUtils::audioConfigFromHal(halConfig, &suggestedConfig);
		_hidl_cb(analyzeStatus("open_input_stream", status), streamIn, suggestedConfig);
		_hidl_cb(analyzeStatus("open_input_stream", status), streamIn,
		suggestedConfig);
		return Void();
		}

		@@ -216,23 +279,21 @@ Return<bool> Device::supportsAudioPatches() {
		return version() >= AUDIO_DEVICE_API_VERSION_3_0;
		}

		Return<void> Device::createAudioPatch(
		const hidl_vec<AudioPortConfig>& sources,
		Return<void> Device::createAudioPatch(const hidl_vec<AudioPortConfig>& sources,
		const hidl_vec<AudioPortConfig>& sinks,
		createAudioPatch_cb _hidl_cb) {
		Result retval(Result::NOT_SUPPORTED);
		AudioPatchHandle patch = 0;
		if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {
		std::unique_ptr<audio_port_config[]> halSources(HidlUtils::audioPortConfigsToHal(sources));
		std::unique_ptr<audio_port_config[]> halSinks(HidlUtils::audioPortConfigsToHal(sinks));
		std::unique_ptr<audio_port_config[]> halSources(
		HidlUtils::audioPortConfigsToHal(sources));
		std::unique_ptr<audio_port_config[]> halSinks(
		HidlUtils::audioPortConfigsToHal(sinks));
		audio_patch_handle_t halPatch = AUDIO_PATCH_HANDLE_NONE;
		retval = analyzeStatus(
		"create_audio_patch",
		mDevice->create_audio_patch(
		mDevice,
		sources.size(), &halSources[0],
		sinks.size(), &halSinks[0],
		&halPatch));
		mDevice->create_audio_patch(mDevice, sources.size(), &halSources[0],
		sinks.size(), &halSinks[0], &halPatch));
		if (retval == Result::OK) {
		patch = static_cast<AudioPatchHandle>(halPatch);
		}
		@@ -245,15 +306,18 @@ Return<Result> Device::releaseAudioPatch(int32_t patch) {
		if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {
		return analyzeStatus(
		"release_audio_patch",
		mDevice->release_audio_patch(mDevice, static_cast<audio_patch_handle_t>(patch)));
		mDevice->release_audio_patch(
		mDevice, static_cast<audio_patch_handle_t>(patch)));
		}
		return Result::NOT_SUPPORTED;
		}

		Return<void> Device::getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb) {
		Return<void> Device::getAudioPort(const AudioPort& port,
		getAudioPort_cb _hidl_cb) {
		audio_port halPort;
		HidlUtils::audioPortToHal(port, &halPort);
		Result retval = analyzeStatus("get_audio_port", mDevice->get_audio_port(mDevice, &halPort));
		Result retval = analyzeStatus("get_audio_port",
		mDevice->get_audio_port(mDevice, &halPort));
		AudioPort resultPort = port;
		if (retval == Result::OK) {
		HidlUtils::audioPortFromHal(halPort, &resultPort);
		@@ -267,7 +331,8 @@ Return<Result> Device::setAudioPortConfig(const AudioPortConfig& config) {
		struct audio_port_config halPortConfig;
		HidlUtils::audioPortConfigToHal(config, &halPortConfig);
		return analyzeStatus(
		"set_audio_port_config", mDevice->set_audio_port_config(mDevice, &halPortConfig));
		"set_audio_port_config",
		mDevice->set_audio_port_config(mDevice, &halPortConfig));
		}
		return Result::NOT_SUPPORTED;
		}
		@@ -282,12 +347,14 @@ Return<Result> Device::setScreenState(bool turnedOn) {
		return setParam(AudioParameter::keyScreenState, turnedOn);
		}

		Return<void> Device::getParameters(const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb) {
		Return<void> Device::getParameters(const hidl_vec<hidl_string>& keys,
		getParameters_cb _hidl_cb) {
		getParametersImpl(keys, _hidl_cb);
		return Void();
		}

		Return<Result> Device::setParameters(const hidl_vec<ParameterValue>& parameters) {
		Return<Result> Device::setParameters(
		const hidl_vec<ParameterValue>& parameters) {
		return setParametersImpl(parameters);
		}

audio/2.0/default/Device.h

+5 −4

Original line number	Diff line number	Diff line
		@@ -56,7 +56,7 @@ using ::android::hardware::hidl_string;
		using ::android::sp;

		struct Device : public IDevice, public ParametersUtil {
		explicit Device(audio_hw_device_t* device);
		Device(audio_hw_device_t* device, const char* type);

		// Methods from ::android::hardware::audio::V2_0::IDevice follow.
		Return<Result> initCheck() override;
		@@ -101,17 +101,18 @@ struct Device : public IDevice, public ParametersUtil {
		void closeInputStream(audio_stream_in_t* stream);
		void closeOutputStream(audio_stream_out_t* stream);
		audio_hw_device_t* device() const { return mDevice; }
		const char* type() const { return mType; }
		uint32_t version() const { return mDevice->common.version; }

		private:
		audio_hw_device_t *mDevice;
		const char* mType;

		virtual ~Device();

		// Methods from ParametersUtil.
		char* halGetParameters(const char* keys) override;
		int halSetParameters(const char* keysAndValues) override;

		uint32_t version() const { return mDevice->common.version; }
		};

		} // namespace implementation