Audio V4: Copy 2.0 audiohal to 4.0 (d4de2889) · Commits · e / os / android_frameworks_av

media/libaudiohal/4.0/ConversionHelperHidl.cpp

0 → 100644

+103 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2016 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.
			*/

			#include <string.h>

			#define LOG_TAG "HalHidl"
			#include <media/AudioParameter.h>
			#include <utils/Log.h>

			#include "ConversionHelperHidl.h"

			using ::android::hardware::audio::V2_0::Result;

			namespace android {

			// static
			status_t ConversionHelperHidl::keysFromHal(const String8& keys, hidl_vec<hidl_string> *hidlKeys) {
			AudioParameter halKeys(keys);
			if (halKeys.size() == 0) return BAD_VALUE;
			hidlKeys->resize(halKeys.size());
			//FIXME: keyStreamSupportedChannels and keyStreamSupportedSamplingRates come with a
			// "keyFormat=<value>" pair. We need to transform it into a single key string so that it is
			// carried over to the legacy HAL via HIDL.
			String8 value;
			bool keepFormatValue = halKeys.size() == 2 &&
			(halKeys.get(String8(AudioParameter::keyStreamSupportedChannels), value) == NO_ERROR \|\|
			halKeys.get(String8(AudioParameter::keyStreamSupportedSamplingRates), value) == NO_ERROR);

			for (size_t i = 0; i < halKeys.size(); ++i) {
			String8 key;
			status_t status = halKeys.getAt(i, key);
			if (status != OK) return status;
			if (keepFormatValue && key == AudioParameter::keyFormat) {
			AudioParameter formatParam;
			halKeys.getAt(i, key, value);
			formatParam.add(key, value);
			key = formatParam.toString();
			}
			(*hidlKeys)[i] = key.string();
			}
			return OK;
			}

			// static
			status_t ConversionHelperHidl::parametersFromHal(
			const String8& kvPairs, hidl_vec<ParameterValue> *hidlParams) {
			AudioParameter params(kvPairs);
			if (params.size() == 0) return BAD_VALUE;
			hidlParams->resize(params.size());
			for (size_t i = 0; i < params.size(); ++i) {
			String8 key, value;
			status_t status = params.getAt(i, key, value);
			if (status != OK) return status;
			(*hidlParams)[i].key = key.string();
			(*hidlParams)[i].value = value.string();
			}
			return OK;
			}

			// static
			void ConversionHelperHidl::parametersToHal(
			const hidl_vec<ParameterValue>& parameters, String8 *values) {
			AudioParameter params;
			for (size_t i = 0; i < parameters.size(); ++i) {
			params.add(String8(parameters[i].key.c_str()), String8(parameters[i].value.c_str()));
			}
			values->setTo(params.toString());
			}

			ConversionHelperHidl::ConversionHelperHidl(const char* className)
			: mClassName(className) {
			}

			// static
			status_t ConversionHelperHidl::analyzeResult(const Result& result) {
			switch (result) {
			case Result::OK: return OK;
			case Result::INVALID_ARGUMENTS: return BAD_VALUE;
			case Result::INVALID_STATE: return NOT_ENOUGH_DATA;
			case Result::NOT_INITIALIZED: return NO_INIT;
			case Result::NOT_SUPPORTED: return INVALID_OPERATION;
			default: return NO_INIT;
			}
			}

			void ConversionHelperHidl::emitError(const char* funcName, const char* description) {
			ALOGE("%s %p %s: %s (from rpc)", mClassName, this, funcName, description);
			}

			} // namespace android

media/libaudiohal/4.0/ConversionHelperHidl.h

0 → 100644

+83 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2016 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 ANDROID_HARDWARE_CONVERSION_HELPER_HIDL_H
			#define ANDROID_HARDWARE_CONVERSION_HELPER_HIDL_H

			#include <android/hardware/audio/2.0/types.h>
			#include <hidl/HidlSupport.h>
			#include <utils/String8.h>

			using ::android::hardware::audio::V2_0::ParameterValue;
			using ::android::hardware::Return;
			using ::android::hardware::hidl_string;
			using ::android::hardware::hidl_vec;

			namespace android {

			class ConversionHelperHidl {
			protected:
			static status_t keysFromHal(const String8& keys, hidl_vec<hidl_string> *hidlKeys);
			static status_t parametersFromHal(const String8& kvPairs, hidl_vec<ParameterValue> *hidlParams);
			static void parametersToHal(const hidl_vec<ParameterValue>& parameters, String8 *values);

			ConversionHelperHidl(const char* className);

			template<typename R, typename T>
			status_t processReturn(const char* funcName, const Return<R>& ret, T *retval) {
			if (ret.isOk()) {
			// This way it also works for enum class to unscoped enum conversion.
			*retval = static_cast<T>(static_cast<R>(ret));
			return OK;
			}
			return processReturn(funcName, ret);
			}

			template<typename T>
			status_t processReturn(const char* funcName, const Return<T>& ret) {
			if (!ret.isOk()) {
			emitError(funcName, ret.description().c_str());
			}
			return ret.isOk() ? OK : FAILED_TRANSACTION;
			}

			status_t processReturn(const char* funcName, const Return<hardware::audio::V2_0::Result>& ret) {
			if (!ret.isOk()) {
			emitError(funcName, ret.description().c_str());
			}
			return ret.isOk() ? analyzeResult(ret) : FAILED_TRANSACTION;
			}

			template<typename T>
			status_t processReturn(
			const char* funcName, const Return<T>& ret, hardware::audio::V2_0::Result retval) {
			if (!ret.isOk()) {
			emitError(funcName, ret.description().c_str());
			}
			return ret.isOk() ? analyzeResult(retval) : FAILED_TRANSACTION;
			}

			private:
			const char* mClassName;

			static status_t analyzeResult(const hardware::audio::V2_0::Result& result);

			void emitError(const char* funcName, const char* description);
			};

			} // namespace android

			#endif // ANDROID_HARDWARE_CONVERSION_HELPER_HIDL_H

media/libaudiohal/4.0/DeviceHalHidl.cpp

0 → 100644

+358 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2016 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.
			*/

			#include <stdio.h>

			#define LOG_TAG "DeviceHalHidl"
			//#define LOG_NDEBUG 0

			#include <android/hardware/audio/2.0/IPrimaryDevice.h>
			#include <cutils/native_handle.h>
			#include <hwbinder/IPCThreadState.h>
			#include <utils/Log.h>

			#include "DeviceHalHidl.h"
			#include "HidlUtils.h"
			#include "StreamHalHidl.h"

			using ::android::hardware::audio::common::V2_0::AudioConfig;
			using ::android::hardware::audio::common::V2_0::AudioDevice;
			using ::android::hardware::audio::common::V2_0::AudioInputFlag;
			using ::android::hardware::audio::common::V2_0::AudioOutputFlag;
			using ::android::hardware::audio::common::V2_0::AudioPatchHandle;
			using ::android::hardware::audio::common::V2_0::AudioPort;
			using ::android::hardware::audio::common::V2_0::AudioPortConfig;
			using ::android::hardware::audio::common::V2_0::AudioMode;
			using ::android::hardware::audio::common::V2_0::AudioSource;
			using ::android::hardware::audio::common::V2_0::HidlUtils;
			using ::android::hardware::audio::V2_0::DeviceAddress;
			using ::android::hardware::audio::V2_0::IPrimaryDevice;
			using ::android::hardware::audio::V2_0::ParameterValue;
			using ::android::hardware::audio::V2_0::Result;
			using ::android::hardware::hidl_string;
			using ::android::hardware::hidl_vec;

			namespace android {

			namespace {

			status_t deviceAddressFromHal(
			audio_devices_t device, const char* halAddress, DeviceAddress* address) {
			address->device = AudioDevice(device);

			if (address == nullptr \|\| strnlen(halAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0) {
			return OK;
			}
			const bool isInput = (device & AUDIO_DEVICE_BIT_IN) != 0;
			if (isInput) device &= ~AUDIO_DEVICE_BIT_IN;
			if ((!isInput && (device & AUDIO_DEVICE_OUT_ALL_A2DP) != 0)
			\|\| (isInput && (device & AUDIO_DEVICE_IN_BLUETOOTH_A2DP) != 0)) {
			int status = sscanf(halAddress,
			"%hhX:%hhX:%hhX:%hhX:%hhX:%hhX",
			&address->address.mac[0], &address->address.mac[1], &address->address.mac[2],
			&address->address.mac[3], &address->address.mac[4], &address->address.mac[5]);
			return status == 6 ? OK : BAD_VALUE;
			} else if ((!isInput && (device & AUDIO_DEVICE_OUT_IP) != 0)
			\|\| (isInput && (device & AUDIO_DEVICE_IN_IP) != 0)) {
			int status = sscanf(halAddress,
			"%hhu.%hhu.%hhu.%hhu",
			&address->address.ipv4[0], &address->address.ipv4[1],
			&address->address.ipv4[2], &address->address.ipv4[3]);
			return status == 4 ? OK : BAD_VALUE;
			} else if ((!isInput && (device & AUDIO_DEVICE_OUT_ALL_USB)) != 0
			\|\| (isInput && (device & AUDIO_DEVICE_IN_ALL_USB)) != 0) {
			int status = sscanf(halAddress,
			"card=%d;device=%d",
			&address->address.alsa.card, &address->address.alsa.device);
			return status == 2 ? OK : BAD_VALUE;
			} else if ((!isInput && (device & AUDIO_DEVICE_OUT_BUS) != 0)
			\|\| (isInput && (device & AUDIO_DEVICE_IN_BUS) != 0)) {
			if (halAddress != NULL) {
			address->busAddress = halAddress;
			return OK;
			}
			return BAD_VALUE;
			} else if ((!isInput && (device & AUDIO_DEVICE_OUT_REMOTE_SUBMIX)) != 0
			\|\| (isInput && (device & AUDIO_DEVICE_IN_REMOTE_SUBMIX) != 0)) {
			if (halAddress != NULL) {
			address->rSubmixAddress = halAddress;
			return OK;
			}
			return BAD_VALUE;
			}
			return OK;
			}

			} // namespace

			DeviceHalHidl::DeviceHalHidl(const sp<IDevice>& device)
			: ConversionHelperHidl("Device"), mDevice(device),
			mPrimaryDevice(IPrimaryDevice::castFrom(device)) {
			}

			DeviceHalHidl::~DeviceHalHidl() {
			if (mDevice != 0) {
			mDevice.clear();
			hardware::IPCThreadState::self()->flushCommands();
			}
			}

			status_t DeviceHalHidl::getSupportedDevices(uint32_t*) {
			// Obsolete.
			return INVALID_OPERATION;
			}

			status_t DeviceHalHidl::initCheck() {
			if (mDevice == 0) return NO_INIT;
			return processReturn("initCheck", mDevice->initCheck());
			}

			status_t DeviceHalHidl::setVoiceVolume(float volume) {
			if (mDevice == 0) return NO_INIT;
			if (mPrimaryDevice == 0) return INVALID_OPERATION;
			return processReturn("setVoiceVolume", mPrimaryDevice->setVoiceVolume(volume));
			}

			status_t DeviceHalHidl::setMasterVolume(float volume) {
			if (mDevice == 0) return NO_INIT;
			if (mPrimaryDevice == 0) return INVALID_OPERATION;
			return processReturn("setMasterVolume", mPrimaryDevice->setMasterVolume(volume));
			}

			status_t DeviceHalHidl::getMasterVolume(float *volume) {
			if (mDevice == 0) return NO_INIT;
			if (mPrimaryDevice == 0) return INVALID_OPERATION;
			Result retval;
			Return<void> ret = mPrimaryDevice->getMasterVolume(
			[&](Result r, float v) {
			retval = r;
			if (retval == Result::OK) {
			*volume = v;
			}
			});
			return processReturn("getMasterVolume", ret, retval);
			}

			status_t DeviceHalHidl::setMode(audio_mode_t mode) {
			if (mDevice == 0) return NO_INIT;
			if (mPrimaryDevice == 0) return INVALID_OPERATION;
			return processReturn("setMode", mPrimaryDevice->setMode(AudioMode(mode)));
			}

			status_t DeviceHalHidl::setMicMute(bool state) {
			if (mDevice == 0) return NO_INIT;
			return processReturn("setMicMute", mDevice->setMicMute(state));
			}

			status_t DeviceHalHidl::getMicMute(bool *state) {
			if (mDevice == 0) return NO_INIT;
			Result retval;
			Return<void> ret = mDevice->getMicMute(
			[&](Result r, bool mute) {
			retval = r;
			if (retval == Result::OK) {
			*state = mute;
			}
			});
			return processReturn("getMicMute", ret, retval);
			}

			status_t DeviceHalHidl::setMasterMute(bool state) {
			if (mDevice == 0) return NO_INIT;
			return processReturn("setMasterMute", mDevice->setMasterMute(state));
			}

			status_t DeviceHalHidl::getMasterMute(bool *state) {
			if (mDevice == 0) return NO_INIT;
			Result retval;
			Return<void> ret = mDevice->getMasterMute(
			[&](Result r, bool mute) {
			retval = r;
			if (retval == Result::OK) {
			*state = mute;
			}
			});
			return processReturn("getMasterMute", ret, retval);
			}

			status_t DeviceHalHidl::setParameters(const String8& kvPairs) {
			if (mDevice == 0) return NO_INIT;
			hidl_vec<ParameterValue> hidlParams;
			status_t status = parametersFromHal(kvPairs, &hidlParams);
			if (status != OK) return status;
			return processReturn("setParameters", mDevice->setParameters(hidlParams));
			}

			status_t DeviceHalHidl::getParameters(const String8& keys, String8 *values) {
			values->clear();
			if (mDevice == 0) return NO_INIT;
			hidl_vec<hidl_string> hidlKeys;
			status_t status = keysFromHal(keys, &hidlKeys);
			if (status != OK) return status;
			Result retval;
			Return<void> ret = mDevice->getParameters(
			hidlKeys,
			[&](Result r, const hidl_vec<ParameterValue>& parameters) {
			retval = r;
			if (retval == Result::OK) {
			parametersToHal(parameters, values);
			}
			});
			return processReturn("getParameters", ret, retval);
			}

			status_t DeviceHalHidl::getInputBufferSize(
			const struct audio_config config, size_t size) {
			if (mDevice == 0) return NO_INIT;
			AudioConfig hidlConfig;
			HidlUtils::audioConfigFromHal(*config, &hidlConfig);
			Result retval;
			Return<void> ret = mDevice->getInputBufferSize(
			hidlConfig,
			[&](Result r, uint64_t bufferSize) {
			retval = r;
			if (retval == Result::OK) {
			*size = static_cast<size_t>(bufferSize);
			}
			});
			return processReturn("getInputBufferSize", ret, retval);
			}

			status_t DeviceHalHidl::openOutputStream(
			audio_io_handle_t handle,
			audio_devices_t devices,
			audio_output_flags_t flags,
			struct audio_config *config,
			const char *address,
			sp<StreamOutHalInterface> *outStream) {
			if (mDevice == 0) return NO_INIT;
			DeviceAddress hidlDevice;
			status_t status = deviceAddressFromHal(devices, address, &hidlDevice);
			if (status != OK) return status;
			AudioConfig hidlConfig;
			HidlUtils::audioConfigFromHal(*config, &hidlConfig);
			Result retval = Result::NOT_INITIALIZED;
			Return<void> ret = mDevice->openOutputStream(
			handle,
			hidlDevice,
			hidlConfig,
			AudioOutputFlag(flags),
			[&](Result r, const sp<IStreamOut>& result, const AudioConfig& suggestedConfig) {
			retval = r;
			if (retval == Result::OK) {
			*outStream = new StreamOutHalHidl(result);
			}
			HidlUtils::audioConfigToHal(suggestedConfig, config);
			});
			return processReturn("openOutputStream", ret, retval);
			}

			status_t DeviceHalHidl::openInputStream(
			audio_io_handle_t handle,
			audio_devices_t devices,
			struct audio_config *config,
			audio_input_flags_t flags,
			const char *address,
			audio_source_t source,
			sp<StreamInHalInterface> *inStream) {
			if (mDevice == 0) return NO_INIT;
			DeviceAddress hidlDevice;
			status_t status = deviceAddressFromHal(devices, address, &hidlDevice);
			if (status != OK) return status;
			AudioConfig hidlConfig;
			HidlUtils::audioConfigFromHal(*config, &hidlConfig);
			Result retval = Result::NOT_INITIALIZED;
			Return<void> ret = mDevice->openInputStream(
			handle,
			hidlDevice,
			hidlConfig,
			AudioInputFlag(flags),
			AudioSource(source),
			[&](Result r, const sp<IStreamIn>& result, const AudioConfig& suggestedConfig) {
			retval = r;
			if (retval == Result::OK) {
			*inStream = new StreamInHalHidl(result);
			}
			HidlUtils::audioConfigToHal(suggestedConfig, config);
			});
			return processReturn("openInputStream", ret, retval);
			}

			status_t DeviceHalHidl::supportsAudioPatches(bool *supportsPatches) {
			if (mDevice == 0) return NO_INIT;
			return processReturn("supportsAudioPatches", mDevice->supportsAudioPatches(), supportsPatches);
			}

			status_t DeviceHalHidl::createAudioPatch(
			unsigned int num_sources,
			const struct audio_port_config *sources,
			unsigned int num_sinks,
			const struct audio_port_config *sinks,
			audio_patch_handle_t *patch) {
			if (mDevice == 0) return NO_INIT;
			hidl_vec<AudioPortConfig> hidlSources, hidlSinks;
			HidlUtils::audioPortConfigsFromHal(num_sources, sources, &hidlSources);
			HidlUtils::audioPortConfigsFromHal(num_sinks, sinks, &hidlSinks);
			Result retval;
			Return<void> ret = mDevice->createAudioPatch(
			hidlSources, hidlSinks,
			[&](Result r, AudioPatchHandle hidlPatch) {
			retval = r;
			if (retval == Result::OK) {
			*patch = static_cast<audio_patch_handle_t>(hidlPatch);
			}
			});
			return processReturn("createAudioPatch", ret, retval);
			}

			status_t DeviceHalHidl::releaseAudioPatch(audio_patch_handle_t patch) {
			if (mDevice == 0) return NO_INIT;
			return processReturn("releaseAudioPatch", mDevice->releaseAudioPatch(patch));
			}

			status_t DeviceHalHidl::getAudioPort(struct audio_port *port) {
			if (mDevice == 0) return NO_INIT;
			AudioPort hidlPort;
			HidlUtils::audioPortFromHal(*port, &hidlPort);
			Result retval;
			Return<void> ret = mDevice->getAudioPort(
			hidlPort,
			[&](Result r, const AudioPort& p) {
			retval = r;
			if (retval == Result::OK) {
			HidlUtils::audioPortToHal(p, port);
			}
			});
			return processReturn("getAudioPort", ret, retval);
			}

			status_t DeviceHalHidl::setAudioPortConfig(const struct audio_port_config *config) {
			if (mDevice == 0) return NO_INIT;
			AudioPortConfig hidlConfig;
			HidlUtils::audioPortConfigFromHal(*config, &hidlConfig);
			return processReturn("setAudioPortConfig", mDevice->setAudioPortConfig(hidlConfig));
			}

			status_t DeviceHalHidl::dump(int fd) {
			if (mDevice == 0) return NO_INIT;
			native_handle_t* hidlHandle = native_handle_create(1, 0);
			hidlHandle->data[0] = fd;
			Return<void> ret = mDevice->debugDump(hidlHandle);
			native_handle_delete(hidlHandle);
			return processReturn("dump", ret);
			}

			} // namespace android

media/libaudiohal/4.0/DeviceHalHidl.h

0 → 100644

+126 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2016 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 ANDROID_HARDWARE_DEVICE_HAL_HIDL_H
			#define ANDROID_HARDWARE_DEVICE_HAL_HIDL_H

			#include <android/hardware/audio/2.0/IDevice.h>
			#include <android/hardware/audio/2.0/IPrimaryDevice.h>
			#include <media/audiohal/DeviceHalInterface.h>

			#include "ConversionHelperHidl.h"

			using ::android::hardware::audio::V2_0::IDevice;
			using ::android::hardware::audio::V2_0::IPrimaryDevice;
			using ::android::hardware::Return;

			namespace android {

			class DeviceHalHidl : public DeviceHalInterface, public ConversionHelperHidl
			{
			public:
			// Sets the value of 'devices' to a bitmask of 1 or more values of audio_devices_t.
			virtual status_t getSupportedDevices(uint32_t *devices);

			// Check to see if the audio hardware interface has been initialized.
			virtual status_t initCheck();

			// Set the audio volume of a voice call. Range is between 0.0 and 1.0.
			virtual status_t setVoiceVolume(float volume);

			// Set the audio volume for all audio activities other than voice call.
			virtual status_t setMasterVolume(float volume);

			// Get the current master volume value for the HAL.
			virtual status_t getMasterVolume(float *volume);

			// Called when the audio mode changes.
			virtual status_t setMode(audio_mode_t mode);

			// Muting control.
			virtual status_t setMicMute(bool state);
			virtual status_t getMicMute(bool *state);
			virtual status_t setMasterMute(bool state);
			virtual status_t getMasterMute(bool *state);

			// Set global audio parameters.
			virtual status_t setParameters(const String8& kvPairs);

			// Get global audio parameters.
			virtual status_t getParameters(const String8& keys, String8 *values);

			// Returns audio input buffer size according to parameters passed.
			virtual status_t getInputBufferSize(const struct audio_config *config,
			size_t *size);

			// Creates and opens the audio hardware output stream. The stream is closed
			// by releasing all references to the returned object.
			virtual status_t openOutputStream(
			audio_io_handle_t handle,
			audio_devices_t devices,
			audio_output_flags_t flags,
			struct audio_config *config,
			const char *address,
			sp<StreamOutHalInterface> *outStream);

			// Creates and opens the audio hardware input stream. The stream is closed
			// by releasing all references to the returned object.
			virtual status_t openInputStream(
			audio_io_handle_t handle,
			audio_devices_t devices,
			struct audio_config *config,
			audio_input_flags_t flags,
			const char *address,
			audio_source_t source,
			sp<StreamInHalInterface> *inStream);

			// Returns whether createAudioPatch and releaseAudioPatch operations are supported.
			virtual status_t supportsAudioPatches(bool *supportsPatches);

			// Creates an audio patch between several source and sink ports.
			virtual status_t createAudioPatch(
			unsigned int num_sources,
			const struct audio_port_config *sources,
			unsigned int num_sinks,
			const struct audio_port_config *sinks,
			audio_patch_handle_t *patch);

			// Releases an audio patch.
			virtual status_t releaseAudioPatch(audio_patch_handle_t patch);

			// Fills the list of supported attributes for a given audio port.
			virtual status_t getAudioPort(struct audio_port *port);

			// Set audio port configuration.
			virtual status_t setAudioPortConfig(const struct audio_port_config *config);

			virtual status_t dump(int fd);

			private:
			friend class DevicesFactoryHalHidl;
			sp<IDevice> mDevice;
			sp<IPrimaryDevice> mPrimaryDevice; // Null if it's not a primary device.

			// Can not be constructed directly by clients.
			explicit DeviceHalHidl(const sp<IDevice>& device);

			// The destructor automatically closes the device.
			virtual ~DeviceHalHidl();
			};

			} // namespace android

			#endif // ANDROID_HARDWARE_DEVICE_HAL_HIDL_H

media/libaudiohal/4.0/DeviceHalLocal.cpp

0 → 100644

+199 −0

File added.

Preview size limit exceeded, changes collapsed.