blob: 71fbd98cba5b2a7ce757f6495d4d04c52edd9719 [file] [log] [blame]
Mikhail Naganovf558e022016-11-14 17:45:17 -08001/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <stdio.h>
18
19#define LOG_TAG "DeviceHalHidl"
20//#define LOG_NDEBUG 0
21
22#include <android/hardware/audio/2.0/IPrimaryDevice.h>
23#include <cutils/native_handle.h>
Mikhail Naganov23feba22017-02-23 11:00:55 -080024#include <hwbinder/IPCThreadState.h>
Mikhail Naganovf558e022016-11-14 17:45:17 -080025#include <utils/Log.h>
26
27#include "DeviceHalHidl.h"
28#include "HidlUtils.h"
29#include "StreamHalHidl.h"
30
31using ::android::hardware::audio::common::V2_0::AudioConfig;
32using ::android::hardware::audio::common::V2_0::AudioDevice;
33using ::android::hardware::audio::common::V2_0::AudioInputFlag;
34using ::android::hardware::audio::common::V2_0::AudioOutputFlag;
35using ::android::hardware::audio::common::V2_0::AudioPatchHandle;
36using ::android::hardware::audio::common::V2_0::AudioPort;
37using ::android::hardware::audio::common::V2_0::AudioPortConfig;
38using ::android::hardware::audio::common::V2_0::AudioMode;
39using ::android::hardware::audio::common::V2_0::AudioSource;
40using ::android::hardware::audio::V2_0::DeviceAddress;
41using ::android::hardware::audio::V2_0::IPrimaryDevice;
42using ::android::hardware::audio::V2_0::ParameterValue;
43using ::android::hardware::audio::V2_0::Result;
44using ::android::hardware::hidl_string;
45using ::android::hardware::hidl_vec;
46
47namespace android {
48
49namespace {
50
51status_t deviceAddressFromHal(
52 audio_devices_t device, const char* halAddress, DeviceAddress* address) {
53 address->device = AudioDevice(device);
Eric Laurent2c37fd32017-01-27 14:35:02 -080054
55 if (address == nullptr || strnlen(halAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0) {
56 return OK;
57 }
Mikhail Naganovf558e022016-11-14 17:45:17 -080058 const bool isInput = (device & AUDIO_DEVICE_BIT_IN) != 0;
59 if (isInput) device &= ~AUDIO_DEVICE_BIT_IN;
60 if ((!isInput && (device & AUDIO_DEVICE_OUT_ALL_A2DP) != 0)
61 || (isInput && (device & AUDIO_DEVICE_IN_BLUETOOTH_A2DP) != 0)) {
62 int status = sscanf(halAddress,
63 "%hhX:%hhX:%hhX:%hhX:%hhX:%hhX",
64 &address->address.mac[0], &address->address.mac[1], &address->address.mac[2],
65 &address->address.mac[3], &address->address.mac[4], &address->address.mac[5]);
66 return status == 6 ? OK : BAD_VALUE;
67 } else if ((!isInput && (device & AUDIO_DEVICE_OUT_IP) != 0)
68 || (isInput && (device & AUDIO_DEVICE_IN_IP) != 0)) {
69 int status = sscanf(halAddress,
70 "%hhu.%hhu.%hhu.%hhu",
71 &address->address.ipv4[0], &address->address.ipv4[1],
72 &address->address.ipv4[2], &address->address.ipv4[3]);
73 return status == 4 ? OK : BAD_VALUE;
74 } else if ((!isInput && (device & AUDIO_DEVICE_OUT_ALL_USB)) != 0
75 || (isInput && (device & AUDIO_DEVICE_IN_ALL_USB)) != 0) {
76 int status = sscanf(halAddress,
77 "card=%d;device=%d",
78 &address->address.alsa.card, &address->address.alsa.device);
79 return status == 2 ? OK : BAD_VALUE;
80 } else if ((!isInput && (device & AUDIO_DEVICE_OUT_BUS) != 0)
81 || (isInput && (device & AUDIO_DEVICE_IN_BUS) != 0)) {
82 if (halAddress != NULL) {
83 address->busAddress = halAddress;
84 return OK;
85 }
86 return BAD_VALUE;
87 } else if ((!isInput && (device & AUDIO_DEVICE_OUT_REMOTE_SUBMIX)) != 0
88 || (isInput && (device & AUDIO_DEVICE_IN_REMOTE_SUBMIX) != 0)) {
89 if (halAddress != NULL) {
90 address->rSubmixAddress = halAddress;
91 return OK;
92 }
93 return BAD_VALUE;
94 }
95 return OK;
96}
97
98} // namespace
99
100DeviceHalHidl::DeviceHalHidl(const sp<IDevice>& device)
101 : ConversionHelperHidl("Device"), mDevice(device) {
102}
103
104DeviceHalHidl::~DeviceHalHidl() {
Mikhail Naganov23feba22017-02-23 11:00:55 -0800105 if (mDevice != 0) {
106 mDevice.clear();
107 hardware::IPCThreadState::self()->flushCommands();
108 }
Mikhail Naganovf558e022016-11-14 17:45:17 -0800109}
110
111status_t DeviceHalHidl::getSupportedDevices(uint32_t*) {
112 // Obsolete.
113 return INVALID_OPERATION;
114}
115
116status_t DeviceHalHidl::initCheck() {
117 if (mDevice == 0) return NO_INIT;
118 return processReturn("initCheck", mDevice->initCheck());
119}
120
121status_t DeviceHalHidl::setVoiceVolume(float volume) {
122 if (mDevice == 0) return NO_INIT;
123 sp<IPrimaryDevice> primaryDev = IPrimaryDevice::castFrom(mDevice);
124 if (primaryDev == 0) return INVALID_OPERATION;
125 return processReturn("setVoiceVolume", primaryDev->setVoiceVolume(volume));
126}
127
128status_t DeviceHalHidl::setMasterVolume(float volume) {
129 if (mDevice == 0) return NO_INIT;
130 sp<IPrimaryDevice> primaryDev = IPrimaryDevice::castFrom(mDevice);
131 if (primaryDev == 0) return INVALID_OPERATION;
132 return processReturn("setMasterVolume", primaryDev->setMasterVolume(volume));
133}
134
135status_t DeviceHalHidl::getMasterVolume(float *volume) {
136 if (mDevice == 0) return NO_INIT;
137 sp<IPrimaryDevice> primaryDev = IPrimaryDevice::castFrom(mDevice);
138 if (primaryDev == 0) return INVALID_OPERATION;
139 Result retval;
140 Return<void> ret = primaryDev->getMasterVolume(
141 [&](Result r, float v) {
142 retval = r;
143 if (retval == Result::OK) {
144 *volume = v;
145 }
146 });
147 return processReturn("getMasterVolume", ret, retval);
148}
149
150status_t DeviceHalHidl::setMode(audio_mode_t mode) {
151 if (mDevice == 0) return NO_INIT;
152 sp<IPrimaryDevice> primaryDev = IPrimaryDevice::castFrom(mDevice);
153 if (primaryDev == 0) return INVALID_OPERATION;
154 return processReturn("setMode", primaryDev->setMode(AudioMode(mode)));
155}
156
157status_t DeviceHalHidl::setMicMute(bool state) {
158 if (mDevice == 0) return NO_INIT;
159 return processReturn("setMicMute", mDevice->setMicMute(state));
160}
161
162status_t DeviceHalHidl::getMicMute(bool *state) {
163 if (mDevice == 0) return NO_INIT;
164 Result retval;
165 Return<void> ret = mDevice->getMicMute(
166 [&](Result r, bool mute) {
167 retval = r;
168 if (retval == Result::OK) {
169 *state = mute;
170 }
171 });
172 return processReturn("getMicMute", ret, retval);
173}
174
175status_t DeviceHalHidl::setMasterMute(bool state) {
176 if (mDevice == 0) return NO_INIT;
177 return processReturn("setMasterMute", mDevice->setMasterMute(state));
178}
179
180status_t DeviceHalHidl::getMasterMute(bool *state) {
181 if (mDevice == 0) return NO_INIT;
182 Result retval;
183 Return<void> ret = mDevice->getMasterMute(
184 [&](Result r, bool mute) {
185 retval = r;
186 if (retval == Result::OK) {
187 *state = mute;
188 }
189 });
190 return processReturn("getMasterMute", ret, retval);
191}
192
193status_t DeviceHalHidl::setParameters(const String8& kvPairs) {
194 if (mDevice == 0) return NO_INIT;
195 hidl_vec<ParameterValue> hidlParams;
196 status_t status = parametersFromHal(kvPairs, &hidlParams);
197 if (status != OK) return status;
198 return processReturn("setParameters", mDevice->setParameters(hidlParams));
199}
200
201status_t DeviceHalHidl::getParameters(const String8& keys, String8 *values) {
202 values->clear();
203 if (mDevice == 0) return NO_INIT;
204 hidl_vec<hidl_string> hidlKeys;
205 status_t status = keysFromHal(keys, &hidlKeys);
206 if (status != OK) return status;
207 Result retval;
208 Return<void> ret = mDevice->getParameters(
209 hidlKeys,
210 [&](Result r, const hidl_vec<ParameterValue>& parameters) {
211 retval = r;
212 if (retval == Result::OK) {
213 parametersToHal(parameters, values);
214 }
215 });
216 return processReturn("getParameters", ret, retval);
217}
218
219status_t DeviceHalHidl::getInputBufferSize(
220 const struct audio_config *config, size_t *size) {
221 if (mDevice == 0) return NO_INIT;
222 AudioConfig hidlConfig;
223 HidlUtils::audioConfigFromHal(*config, &hidlConfig);
224 Result retval;
225 Return<void> ret = mDevice->getInputBufferSize(
226 hidlConfig,
227 [&](Result r, uint64_t bufferSize) {
228 retval = r;
229 if (retval == Result::OK) {
230 *size = static_cast<size_t>(bufferSize);
231 }
232 });
233 return processReturn("getInputBufferSize", ret, retval);
234}
235
236status_t DeviceHalHidl::openOutputStream(
237 audio_io_handle_t handle,
238 audio_devices_t devices,
239 audio_output_flags_t flags,
240 struct audio_config *config,
241 const char *address,
242 sp<StreamOutHalInterface> *outStream) {
243 if (mDevice == 0) return NO_INIT;
244 DeviceAddress hidlDevice;
245 status_t status = deviceAddressFromHal(devices, address, &hidlDevice);
246 if (status != OK) return status;
247 AudioConfig hidlConfig;
248 HidlUtils::audioConfigFromHal(*config, &hidlConfig);
249 Result retval = Result::NOT_INITIALIZED;
250 Return<void> ret = mDevice->openOutputStream(
251 handle,
252 hidlDevice,
253 hidlConfig,
254 AudioOutputFlag(flags),
255 [&](Result r, const sp<IStreamOut>& result, const AudioConfig& suggestedConfig) {
256 retval = r;
257 if (retval == Result::OK) {
258 *outStream = new StreamOutHalHidl(result);
259 }
260 HidlUtils::audioConfigToHal(suggestedConfig, config);
261 });
262 return processReturn("openOutputStream", ret, retval);
263}
264
265status_t DeviceHalHidl::openInputStream(
266 audio_io_handle_t handle,
267 audio_devices_t devices,
268 struct audio_config *config,
269 audio_input_flags_t flags,
270 const char *address,
271 audio_source_t source,
272 sp<StreamInHalInterface> *inStream) {
273 if (mDevice == 0) return NO_INIT;
274 DeviceAddress hidlDevice;
275 status_t status = deviceAddressFromHal(devices, address, &hidlDevice);
276 if (status != OK) return status;
277 AudioConfig hidlConfig;
278 HidlUtils::audioConfigFromHal(*config, &hidlConfig);
279 Result retval = Result::NOT_INITIALIZED;
280 Return<void> ret = mDevice->openInputStream(
281 handle,
282 hidlDevice,
283 hidlConfig,
284 AudioInputFlag(flags),
285 AudioSource(source),
286 [&](Result r, const sp<IStreamIn>& result, const AudioConfig& suggestedConfig) {
287 retval = r;
288 if (retval == Result::OK) {
289 *inStream = new StreamInHalHidl(result);
290 }
291 HidlUtils::audioConfigToHal(suggestedConfig, config);
292 });
293 return processReturn("openInputStream", ret, retval);
294}
295
296status_t DeviceHalHidl::supportsAudioPatches(bool *supportsPatches) {
297 if (mDevice == 0) return NO_INIT;
298 return processReturn("supportsAudioPatches", mDevice->supportsAudioPatches(), supportsPatches);
299}
300
301status_t DeviceHalHidl::createAudioPatch(
302 unsigned int num_sources,
303 const struct audio_port_config *sources,
304 unsigned int num_sinks,
305 const struct audio_port_config *sinks,
306 audio_patch_handle_t *patch) {
307 if (mDevice == 0) return NO_INIT;
308 hidl_vec<AudioPortConfig> hidlSources, hidlSinks;
309 HidlUtils::audioPortConfigsFromHal(num_sources, sources, &hidlSources);
310 HidlUtils::audioPortConfigsFromHal(num_sinks, sinks, &hidlSinks);
311 Result retval;
312 Return<void> ret = mDevice->createAudioPatch(
313 hidlSources, hidlSinks,
314 [&](Result r, AudioPatchHandle hidlPatch) {
315 retval = r;
316 if (retval == Result::OK) {
317 *patch = static_cast<audio_patch_handle_t>(hidlPatch);
318 }
319 });
320 return processReturn("createAudioPatch", ret, retval);
321}
322
323status_t DeviceHalHidl::releaseAudioPatch(audio_patch_handle_t patch) {
324 if (mDevice == 0) return NO_INIT;
325 return processReturn("releaseAudioPatch", mDevice->releaseAudioPatch(patch));
326}
327
328status_t DeviceHalHidl::getAudioPort(struct audio_port *port) {
329 if (mDevice == 0) return NO_INIT;
330 AudioPort hidlPort;
331 HidlUtils::audioPortFromHal(*port, &hidlPort);
332 Result retval;
333 Return<void> ret = mDevice->getAudioPort(
334 hidlPort,
335 [&](Result r, const AudioPort& p) {
336 retval = r;
337 if (retval == Result::OK) {
338 HidlUtils::audioPortToHal(p, port);
339 }
340 });
341 return processReturn("getAudioPort", ret, retval);
342}
343
344status_t DeviceHalHidl::setAudioPortConfig(const struct audio_port_config *config) {
345 if (mDevice == 0) return NO_INIT;
346 AudioPortConfig hidlConfig;
347 HidlUtils::audioPortConfigFromHal(*config, &hidlConfig);
348 return processReturn("setAudioPortConfig", mDevice->setAudioPortConfig(hidlConfig));
349}
350
351status_t DeviceHalHidl::dump(int fd) {
352 if (mDevice == 0) return NO_INIT;
353 native_handle_t* hidlHandle = native_handle_create(1, 0);
354 hidlHandle->data[0] = fd;
355 Return<void> ret = mDevice->debugDump(hidlHandle);
356 native_handle_delete(hidlHandle);
357 return processReturn("dump", ret);
358}
359
360} // namespace android