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 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 100 DeviceHalHidl::DeviceHalHidl(const sp<IDevice>& device) 101 : ConversionHelperHidl("Device"), mDevice(device) { 102 } 103 104 DeviceHalHidl::~DeviceHalHidl() { 105 if (mDevice != 0) { 106 mDevice.clear(); 107 hardware::IPCThreadState::self()->flushCommands(); 108 } 109 } 110 111 status_t DeviceHalHidl::getSupportedDevices(uint32_t*) { 112 // Obsolete. 113 return INVALID_OPERATION; 114 } 115 116 status_t DeviceHalHidl::initCheck() { 117 if (mDevice == 0) return NO_INIT; 118 return processReturn("initCheck", mDevice->initCheck()); 119 } 120 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 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 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 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 157 status_t DeviceHalHidl::setMicMute(bool state) { 158 if (mDevice == 0) return NO_INIT; 159 return processReturn("setMicMute", mDevice->setMicMute(state)); 160 } 161 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 175 status_t DeviceHalHidl::setMasterMute(bool state) { 176 if (mDevice == 0) return NO_INIT; 177 return processReturn("setMasterMute", mDevice->setMasterMute(state)); 178 } 179 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 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 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 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 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 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 296 status_t DeviceHalHidl::supportsAudioPatches(bool *supportsPatches) { 297 if (mDevice == 0) return NO_INIT; 298 return processReturn("supportsAudioPatches", mDevice->supportsAudioPatches(), supportsPatches); 299 } 300 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 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 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 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 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
