1 /*
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>
24 #include <hwbinder/IPCThreadState.h>
25 #include <utils/Log.h>
26
27 #include "DeviceHalHidl.h"
28 #include "HidlUtils.h"
29 #include "StreamHalHidl.h"
30
31 using ::android::hardware::audio::common::V2_0::AudioConfig;
32 using ::android::hardware::audio::common::V2_0::AudioDevice;
33 using ::android::hardware::audio::common::V2_0::AudioInputFlag;
34 using ::android::hardware::audio::common::V2_0::AudioOutputFlag;
35 using ::android::hardware::audio::common::V2_0::AudioPatchHandle;
36 using ::android::hardware::audio::common::V2_0::AudioPort;
37 using ::android::hardware::audio::common::V2_0::AudioPortConfig;
38 using ::android::hardware::audio::common::V2_0::AudioMode;
39 using ::android::hardware::audio::common::V2_0::AudioSource;
40 using ::android::hardware::audio::V2_0::DeviceAddress;
41 using ::android::hardware::audio::V2_0::IPrimaryDevice;
42 using ::android::hardware::audio::V2_0::ParameterValue;
43 using ::android::hardware::audio::V2_0::Result;
44 using ::android::hardware::hidl_string;
45 using ::android::hardware::hidl_vec;
46
47 namespace android {
48
49 namespace {
50
deviceAddressFromHal(audio_devices_t device,const char * halAddress,DeviceAddress * address)51 status_t deviceAddressFromHal(
52 audio_devices_t device, const char* halAddress, DeviceAddress* address) {
53 address->device = AudioDevice(device);
54
55 if (address == nullptr || strnlen(halAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0) {
56 return OK;
57 }
58 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
DeviceHalHidl(const sp<IDevice> & device)100 DeviceHalHidl::DeviceHalHidl(const sp<IDevice>& device)
101 : ConversionHelperHidl("Device"), mDevice(device) {
102 }
103
~DeviceHalHidl()104 DeviceHalHidl::~DeviceHalHidl() {
105 if (mDevice != 0) {
106 mDevice.clear();
107 hardware::IPCThreadState::self()->flushCommands();
108 }
109 }
110
getSupportedDevices(uint32_t *)111 status_t DeviceHalHidl::getSupportedDevices(uint32_t*) {
112 // Obsolete.
113 return INVALID_OPERATION;
114 }
115
initCheck()116 status_t DeviceHalHidl::initCheck() {
117 if (mDevice == 0) return NO_INIT;
118 return processReturn("initCheck", mDevice->initCheck());
119 }
120
setVoiceVolume(float volume)121 status_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
setMasterVolume(float volume)128 status_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
getMasterVolume(float * volume)135 status_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
setMode(audio_mode_t mode)150 status_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
setMicMute(bool state)157 status_t DeviceHalHidl::setMicMute(bool state) {
158 if (mDevice == 0) return NO_INIT;
159 return processReturn("setMicMute", mDevice->setMicMute(state));
160 }
161
getMicMute(bool * state)162 status_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
setMasterMute(bool state)175 status_t DeviceHalHidl::setMasterMute(bool state) {
176 if (mDevice == 0) return NO_INIT;
177 return processReturn("setMasterMute", mDevice->setMasterMute(state));
178 }
179
getMasterMute(bool * state)180 status_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
setParameters(const String8 & kvPairs)193 status_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
getParameters(const String8 & keys,String8 * values)201 status_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
getInputBufferSize(const struct audio_config * config,size_t * size)219 status_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
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)236 status_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
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)265 status_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
supportsAudioPatches(bool * supportsPatches)296 status_t DeviceHalHidl::supportsAudioPatches(bool *supportsPatches) {
297 if (mDevice == 0) return NO_INIT;
298 return processReturn("supportsAudioPatches", mDevice->supportsAudioPatches(), supportsPatches);
299 }
300
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)301 status_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
releaseAudioPatch(audio_patch_handle_t patch)323 status_t DeviceHalHidl::releaseAudioPatch(audio_patch_handle_t patch) {
324 if (mDevice == 0) return NO_INIT;
325 return processReturn("releaseAudioPatch", mDevice->releaseAudioPatch(patch));
326 }
327
getAudioPort(struct audio_port * port)328 status_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
setAudioPortConfig(const struct audio_port_config * config)344 status_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
dump(int fd)351 status_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
361