1 /* 2 ** 3 ** Copyright 2009, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 #define LOG_TAG "IAudioPolicyService" 19 #include <utils/Log.h> 20 21 #include <stdint.h> 22 #include <math.h> 23 #include <sys/types.h> 24 25 #include <binder/IPCThreadState.h> 26 #include <binder/Parcel.h> 27 #include <media/AudioEffect.h> 28 #include <media/IAudioPolicyService.h> 29 #include <media/TimeCheck.h> 30 #include <mediautils/ServiceUtilities.h> 31 #include <system/audio.h> 32 33 namespace android { 34 35 enum { 36 SET_DEVICE_CONNECTION_STATE = IBinder::FIRST_CALL_TRANSACTION, 37 GET_DEVICE_CONNECTION_STATE, 38 HANDLE_DEVICE_CONFIG_CHANGE, 39 SET_PHONE_STATE, 40 SET_RINGER_MODE, // reserved, no longer used 41 SET_FORCE_USE, 42 GET_FORCE_USE, 43 GET_OUTPUT, 44 START_OUTPUT, 45 STOP_OUTPUT, 46 RELEASE_OUTPUT, 47 GET_INPUT_FOR_ATTR, 48 START_INPUT, 49 STOP_INPUT, 50 RELEASE_INPUT, 51 INIT_STREAM_VOLUME, 52 SET_STREAM_VOLUME, 53 GET_STREAM_VOLUME, 54 SET_VOLUME_ATTRIBUTES, 55 GET_VOLUME_ATTRIBUTES, 56 GET_MIN_VOLUME_FOR_ATTRIBUTES, 57 GET_MAX_VOLUME_FOR_ATTRIBUTES, 58 GET_STRATEGY_FOR_STREAM, 59 GET_OUTPUT_FOR_EFFECT, 60 REGISTER_EFFECT, 61 UNREGISTER_EFFECT, 62 IS_STREAM_ACTIVE, 63 IS_SOURCE_ACTIVE, 64 GET_DEVICES_FOR_STREAM, 65 QUERY_DEFAULT_PRE_PROCESSING, 66 SET_EFFECT_ENABLED, 67 IS_STREAM_ACTIVE_REMOTELY, 68 IS_OFFLOAD_SUPPORTED, 69 IS_DIRECT_OUTPUT_SUPPORTED, 70 LIST_AUDIO_PORTS, 71 GET_AUDIO_PORT, 72 CREATE_AUDIO_PATCH, 73 RELEASE_AUDIO_PATCH, 74 LIST_AUDIO_PATCHES, 75 SET_AUDIO_PORT_CONFIG, 76 REGISTER_CLIENT, 77 GET_OUTPUT_FOR_ATTR, 78 ACQUIRE_SOUNDTRIGGER_SESSION, 79 RELEASE_SOUNDTRIGGER_SESSION, 80 GET_PHONE_STATE, 81 REGISTER_POLICY_MIXES, 82 START_AUDIO_SOURCE, 83 STOP_AUDIO_SOURCE, 84 SET_AUDIO_PORT_CALLBACK_ENABLED, 85 SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED, 86 SET_MASTER_MONO, 87 GET_MASTER_MONO, 88 GET_STREAM_VOLUME_DB, 89 GET_SURROUND_FORMATS, 90 SET_SURROUND_FORMAT_ENABLED, 91 ADD_STREAM_DEFAULT_EFFECT, 92 REMOVE_STREAM_DEFAULT_EFFECT, 93 ADD_SOURCE_DEFAULT_EFFECT, 94 REMOVE_SOURCE_DEFAULT_EFFECT, 95 SET_ASSISTANT_UID, 96 SET_A11Y_SERVICES_UIDS, 97 IS_HAPTIC_PLAYBACK_SUPPORTED, 98 SET_UID_DEVICE_AFFINITY, 99 REMOVE_UID_DEVICE_AFFINITY, 100 GET_OFFLOAD_FORMATS_A2DP, 101 LIST_AUDIO_PRODUCT_STRATEGIES, 102 GET_STRATEGY_FOR_ATTRIBUTES, 103 LIST_AUDIO_VOLUME_GROUPS, 104 GET_VOLUME_GROUP_FOR_ATTRIBUTES, 105 SET_ALLOWED_CAPTURE_POLICY, 106 MOVE_EFFECTS_TO_IO, 107 SET_RTT_ENABLED 108 }; 109 110 #define MAX_ITEMS_PER_LIST 1024 111 112 class BpAudioPolicyService : public BpInterface<IAudioPolicyService> 113 { 114 public: 115 explicit BpAudioPolicyService(const sp<IBinder>& impl) 116 : BpInterface<IAudioPolicyService>(impl) 117 { 118 } 119 120 virtual status_t setDeviceConnectionState( 121 audio_devices_t device, 122 audio_policy_dev_state_t state, 123 const char *device_address, 124 const char *device_name, 125 audio_format_t encodedFormat) 126 { 127 Parcel data, reply; 128 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 129 data.writeInt32(static_cast <uint32_t>(device)); 130 data.writeInt32(static_cast <uint32_t>(state)); 131 data.writeCString(device_address); 132 data.writeCString(device_name); 133 data.writeInt32(static_cast <uint32_t>(encodedFormat)); 134 remote()->transact(SET_DEVICE_CONNECTION_STATE, data, &reply); 135 return static_cast <status_t> (reply.readInt32()); 136 } 137 138 virtual audio_policy_dev_state_t getDeviceConnectionState( 139 audio_devices_t device, 140 const char *device_address) 141 { 142 Parcel data, reply; 143 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 144 data.writeInt32(static_cast <uint32_t>(device)); 145 data.writeCString(device_address); 146 remote()->transact(GET_DEVICE_CONNECTION_STATE, data, &reply); 147 return static_cast <audio_policy_dev_state_t>(reply.readInt32()); 148 } 149 150 virtual status_t handleDeviceConfigChange(audio_devices_t device, 151 const char *device_address, 152 const char *device_name, 153 audio_format_t encodedFormat) 154 { 155 Parcel data, reply; 156 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 157 data.writeInt32(static_cast <uint32_t>(device)); 158 data.writeCString(device_address); 159 data.writeCString(device_name); 160 data.writeInt32(static_cast <uint32_t>(encodedFormat)); 161 remote()->transact(HANDLE_DEVICE_CONFIG_CHANGE, data, &reply); 162 return static_cast <status_t> (reply.readInt32()); 163 } 164 165 virtual status_t setPhoneState(audio_mode_t state) 166 { 167 Parcel data, reply; 168 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 169 data.writeInt32(state); 170 remote()->transact(SET_PHONE_STATE, data, &reply); 171 return static_cast <status_t> (reply.readInt32()); 172 } 173 174 virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) 175 { 176 Parcel data, reply; 177 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 178 data.writeInt32(static_cast <uint32_t>(usage)); 179 data.writeInt32(static_cast <uint32_t>(config)); 180 remote()->transact(SET_FORCE_USE, data, &reply); 181 return static_cast <status_t> (reply.readInt32()); 182 } 183 184 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) 185 { 186 Parcel data, reply; 187 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 188 data.writeInt32(static_cast <uint32_t>(usage)); 189 remote()->transact(GET_FORCE_USE, data, &reply); 190 return static_cast <audio_policy_forced_cfg_t> (reply.readInt32()); 191 } 192 193 virtual audio_io_handle_t getOutput(audio_stream_type_t stream) 194 { 195 Parcel data, reply; 196 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 197 data.writeInt32(static_cast <uint32_t>(stream)); 198 remote()->transact(GET_OUTPUT, data, &reply); 199 return static_cast <audio_io_handle_t> (reply.readInt32()); 200 } 201 202 status_t getOutputForAttr(audio_attributes_t *attr, 203 audio_io_handle_t *output, 204 audio_session_t session, 205 audio_stream_type_t *stream, 206 pid_t pid, 207 uid_t uid, 208 const audio_config_t *config, 209 audio_output_flags_t flags, 210 audio_port_handle_t *selectedDeviceId, 211 audio_port_handle_t *portId, 212 std::vector<audio_io_handle_t> *secondaryOutputs) override 213 { 214 Parcel data, reply; 215 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 216 if (attr == nullptr) { 217 ALOGE("%s NULL audio attributes", __func__); 218 return BAD_VALUE; 219 } 220 if (output == nullptr) { 221 ALOGE("%s NULL output - shouldn't happen", __func__); 222 return BAD_VALUE; 223 } 224 if (selectedDeviceId == nullptr) { 225 ALOGE("%s NULL selectedDeviceId - shouldn't happen", __func__); 226 return BAD_VALUE; 227 } 228 if (portId == nullptr) { 229 ALOGE("%s NULL portId - shouldn't happen", __func__); 230 return BAD_VALUE; 231 } 232 if (secondaryOutputs == nullptr) { 233 ALOGE("%s NULL secondaryOutputs - shouldn't happen", __func__); 234 return BAD_VALUE; 235 } 236 data.write(attr, sizeof(audio_attributes_t)); 237 data.writeInt32(session); 238 if (stream == NULL) { 239 data.writeInt32(0); 240 } else { 241 data.writeInt32(1); 242 data.writeInt32(*stream); 243 } 244 data.writeInt32(pid); 245 data.writeInt32(uid); 246 data.write(config, sizeof(audio_config_t)); 247 data.writeInt32(static_cast <uint32_t>(flags)); 248 data.writeInt32(*selectedDeviceId); 249 data.writeInt32(*portId); 250 status_t status = remote()->transact(GET_OUTPUT_FOR_ATTR, data, &reply); 251 if (status != NO_ERROR) { 252 return status; 253 } 254 status = (status_t)reply.readInt32(); 255 if (status != NO_ERROR) { 256 return status; 257 } 258 status = (status_t)reply.read(&attr, sizeof(audio_attributes_t)); 259 if (status != NO_ERROR) { 260 return status; 261 } 262 *output = (audio_io_handle_t)reply.readInt32(); 263 audio_stream_type_t lStream = (audio_stream_type_t)reply.readInt32(); 264 if (stream != NULL) { 265 *stream = lStream; 266 } 267 *selectedDeviceId = (audio_port_handle_t)reply.readInt32(); 268 *portId = (audio_port_handle_t)reply.readInt32(); 269 secondaryOutputs->resize(reply.readInt32()); 270 return reply.read(secondaryOutputs->data(), 271 secondaryOutputs->size() * sizeof(audio_io_handle_t)); 272 } 273 274 virtual status_t startOutput(audio_port_handle_t portId) 275 { 276 Parcel data, reply; 277 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 278 data.writeInt32((int32_t)portId); 279 remote()->transact(START_OUTPUT, data, &reply); 280 return static_cast <status_t> (reply.readInt32()); 281 } 282 283 virtual status_t stopOutput(audio_port_handle_t portId) 284 { 285 Parcel data, reply; 286 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 287 data.writeInt32((int32_t)portId); 288 remote()->transact(STOP_OUTPUT, data, &reply); 289 return static_cast <status_t> (reply.readInt32()); 290 } 291 292 virtual void releaseOutput(audio_port_handle_t portId) 293 { 294 Parcel data, reply; 295 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 296 data.writeInt32((int32_t)portId); 297 remote()->transact(RELEASE_OUTPUT, data, &reply); 298 } 299 300 virtual status_t getInputForAttr(const audio_attributes_t *attr, 301 audio_io_handle_t *input, 302 audio_unique_id_t riid, 303 audio_session_t session, 304 pid_t pid, 305 uid_t uid, 306 const String16& opPackageName, 307 const audio_config_base_t *config, 308 audio_input_flags_t flags, 309 audio_port_handle_t *selectedDeviceId, 310 audio_port_handle_t *portId) 311 { 312 Parcel data, reply; 313 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 314 if (attr == NULL) { 315 ALOGE("getInputForAttr NULL attr - shouldn't happen"); 316 return BAD_VALUE; 317 } 318 if (input == NULL) { 319 ALOGE("getInputForAttr NULL input - shouldn't happen"); 320 return BAD_VALUE; 321 } 322 if (selectedDeviceId == NULL) { 323 ALOGE("getInputForAttr NULL selectedDeviceId - shouldn't happen"); 324 return BAD_VALUE; 325 } 326 if (portId == NULL) { 327 ALOGE("getInputForAttr NULL portId - shouldn't happen"); 328 return BAD_VALUE; 329 } 330 data.write(attr, sizeof(audio_attributes_t)); 331 data.writeInt32(*input); 332 data.writeInt32(riid); 333 data.writeInt32(session); 334 data.writeInt32(pid); 335 data.writeInt32(uid); 336 data.writeString16(opPackageName); 337 data.write(config, sizeof(audio_config_base_t)); 338 data.writeInt32(flags); 339 data.writeInt32(*selectedDeviceId); 340 data.writeInt32(*portId); 341 status_t status = remote()->transact(GET_INPUT_FOR_ATTR, data, &reply); 342 if (status != NO_ERROR) { 343 return status; 344 } 345 status = reply.readInt32(); 346 if (status != NO_ERROR) { 347 return status; 348 } 349 *input = (audio_io_handle_t)reply.readInt32(); 350 *selectedDeviceId = (audio_port_handle_t)reply.readInt32(); 351 *portId = (audio_port_handle_t)reply.readInt32(); 352 return NO_ERROR; 353 } 354 355 virtual status_t startInput(audio_port_handle_t portId) 356 { 357 Parcel data, reply; 358 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 359 data.writeInt32(portId); 360 remote()->transact(START_INPUT, data, &reply); 361 status_t status = static_cast <status_t> (reply.readInt32()); 362 return status; 363 } 364 365 virtual status_t stopInput(audio_port_handle_t portId) 366 { 367 Parcel data, reply; 368 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 369 data.writeInt32(portId); 370 remote()->transact(STOP_INPUT, data, &reply); 371 return static_cast <status_t> (reply.readInt32()); 372 } 373 374 virtual void releaseInput(audio_port_handle_t portId) 375 { 376 Parcel data, reply; 377 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 378 data.writeInt32(portId); 379 remote()->transact(RELEASE_INPUT, data, &reply); 380 } 381 382 virtual status_t initStreamVolume(audio_stream_type_t stream, 383 int indexMin, 384 int indexMax) 385 { 386 Parcel data, reply; 387 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 388 data.writeInt32(static_cast <uint32_t>(stream)); 389 data.writeInt32(indexMin); 390 data.writeInt32(indexMax); 391 remote()->transact(INIT_STREAM_VOLUME, data, &reply); 392 return static_cast <status_t> (reply.readInt32()); 393 } 394 395 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, 396 int index, 397 audio_devices_t device) 398 { 399 Parcel data, reply; 400 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 401 data.writeInt32(static_cast <uint32_t>(stream)); 402 data.writeInt32(index); 403 data.writeInt32(static_cast <uint32_t>(device)); 404 remote()->transact(SET_STREAM_VOLUME, data, &reply); 405 return static_cast <status_t> (reply.readInt32()); 406 } 407 408 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, 409 int *index, 410 audio_devices_t device) 411 { 412 Parcel data, reply; 413 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 414 data.writeInt32(static_cast <uint32_t>(stream)); 415 data.writeInt32(static_cast <uint32_t>(device)); 416 417 remote()->transact(GET_STREAM_VOLUME, data, &reply); 418 int lIndex = reply.readInt32(); 419 if (index) *index = lIndex; 420 return static_cast <status_t> (reply.readInt32()); 421 } 422 423 virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr, int index, 424 audio_devices_t device) 425 { 426 Parcel data, reply; 427 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 428 data.write(&attr, sizeof(audio_attributes_t)); 429 data.writeInt32(index); 430 data.writeInt32(static_cast <uint32_t>(device)); 431 status_t status = remote()->transact(SET_VOLUME_ATTRIBUTES, data, &reply); 432 if (status != NO_ERROR) { 433 return status; 434 } 435 return static_cast <status_t> (reply.readInt32()); 436 } 437 virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr, int &index, 438 audio_devices_t device) 439 { 440 Parcel data, reply; 441 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 442 data.write(&attr, sizeof(audio_attributes_t)); 443 data.writeInt32(static_cast <uint32_t>(device)); 444 status_t status = remote()->transact(GET_VOLUME_ATTRIBUTES, data, &reply); 445 if (status != NO_ERROR) { 446 return status; 447 } 448 status = static_cast <status_t> (reply.readInt32()); 449 if (status != NO_ERROR) { 450 return status; 451 } 452 index = reply.readInt32(); 453 return NO_ERROR; 454 } 455 virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index) 456 { 457 Parcel data, reply; 458 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 459 data.write(&attr, sizeof(audio_attributes_t)); 460 status_t status = remote()->transact(GET_MIN_VOLUME_FOR_ATTRIBUTES, data, &reply); 461 if (status != NO_ERROR) { 462 return status; 463 } 464 status = static_cast <status_t> (reply.readInt32()); 465 if (status != NO_ERROR) { 466 return status; 467 } 468 index = reply.readInt32(); 469 return NO_ERROR; 470 } 471 virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index) 472 { 473 Parcel data, reply; 474 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 475 data.write(&attr, sizeof(audio_attributes_t)); 476 status_t status = remote()->transact(GET_MAX_VOLUME_FOR_ATTRIBUTES, data, &reply); 477 if (status != NO_ERROR) { 478 return status; 479 } 480 status = static_cast <status_t> (reply.readInt32()); 481 if (status != NO_ERROR) { 482 return status; 483 } 484 index = reply.readInt32(); 485 return NO_ERROR; 486 } 487 virtual uint32_t getStrategyForStream(audio_stream_type_t stream) 488 { 489 Parcel data, reply; 490 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 491 data.writeInt32(static_cast <uint32_t>(stream)); 492 remote()->transact(GET_STRATEGY_FOR_STREAM, data, &reply); 493 return reply.readUint32(); 494 } 495 496 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) 497 { 498 Parcel data, reply; 499 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 500 data.writeInt32(static_cast <uint32_t>(stream)); 501 remote()->transact(GET_DEVICES_FOR_STREAM, data, &reply); 502 return (audio_devices_t) reply.readInt32(); 503 } 504 505 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) 506 { 507 Parcel data, reply; 508 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 509 data.write(desc, sizeof(effect_descriptor_t)); 510 remote()->transact(GET_OUTPUT_FOR_EFFECT, data, &reply); 511 return static_cast <audio_io_handle_t> (reply.readInt32()); 512 } 513 514 virtual status_t registerEffect(const effect_descriptor_t *desc, 515 audio_io_handle_t io, 516 uint32_t strategy, 517 audio_session_t session, 518 int id) 519 { 520 Parcel data, reply; 521 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 522 data.write(desc, sizeof(effect_descriptor_t)); 523 data.writeInt32(io); 524 data.writeInt32(strategy); 525 data.writeInt32(session); 526 data.writeInt32(id); 527 remote()->transact(REGISTER_EFFECT, data, &reply); 528 return static_cast <status_t> (reply.readInt32()); 529 } 530 531 virtual status_t unregisterEffect(int id) 532 { 533 Parcel data, reply; 534 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 535 data.writeInt32(id); 536 remote()->transact(UNREGISTER_EFFECT, data, &reply); 537 return static_cast <status_t> (reply.readInt32()); 538 } 539 540 virtual status_t setEffectEnabled(int id, bool enabled) 541 { 542 Parcel data, reply; 543 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 544 data.writeInt32(id); 545 data.writeInt32(enabled); 546 remote()->transact(SET_EFFECT_ENABLED, data, &reply); 547 return static_cast <status_t> (reply.readInt32()); 548 } 549 550 status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) override 551 { 552 Parcel data, reply; 553 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 554 data.writeInt32(ids.size()); 555 for (auto id : ids) { 556 data.writeInt32(id); 557 } 558 data.writeInt32(io); 559 status_t status = remote()->transact(MOVE_EFFECTS_TO_IO, data, &reply); 560 if (status != NO_ERROR) { 561 return status; 562 } 563 return static_cast <status_t> (reply.readInt32()); 564 } 565 566 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const 567 { 568 Parcel data, reply; 569 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 570 data.writeInt32((int32_t) stream); 571 data.writeInt32(inPastMs); 572 remote()->transact(IS_STREAM_ACTIVE, data, &reply); 573 return reply.readInt32(); 574 } 575 576 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const 577 { 578 Parcel data, reply; 579 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 580 data.writeInt32((int32_t) stream); 581 data.writeInt32(inPastMs); 582 remote()->transact(IS_STREAM_ACTIVE_REMOTELY, data, &reply); 583 return reply.readInt32(); 584 } 585 586 virtual bool isSourceActive(audio_source_t source) const 587 { 588 Parcel data, reply; 589 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 590 data.writeInt32((int32_t) source); 591 remote()->transact(IS_SOURCE_ACTIVE, data, &reply); 592 return reply.readInt32(); 593 } 594 595 virtual status_t queryDefaultPreProcessing(audio_session_t audioSession, 596 effect_descriptor_t *descriptors, 597 uint32_t *count) 598 { 599 if (descriptors == NULL || count == NULL) { 600 return BAD_VALUE; 601 } 602 Parcel data, reply; 603 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 604 data.writeInt32(audioSession); 605 data.writeInt32(*count); 606 status_t status = remote()->transact(QUERY_DEFAULT_PRE_PROCESSING, data, &reply); 607 if (status != NO_ERROR) { 608 return status; 609 } 610 status = static_cast <status_t> (reply.readInt32()); 611 uint32_t retCount = reply.readInt32(); 612 if (retCount != 0) { 613 uint32_t numDesc = (retCount < *count) ? retCount : *count; 614 reply.read(descriptors, sizeof(effect_descriptor_t) * numDesc); 615 } 616 *count = retCount; 617 return status; 618 } 619 620 status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t flags) override { 621 Parcel data, reply; 622 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 623 data.writeInt32(uid); 624 data.writeInt32(flags); 625 remote()->transact(SET_ALLOWED_CAPTURE_POLICY, data, &reply); 626 return reply.readInt32(); 627 } 628 629 virtual bool isOffloadSupported(const audio_offload_info_t& info) 630 { 631 Parcel data, reply; 632 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 633 data.write(&info, sizeof(audio_offload_info_t)); 634 remote()->transact(IS_OFFLOAD_SUPPORTED, data, &reply); 635 return reply.readInt32(); 636 } 637 638 virtual bool isDirectOutputSupported(const audio_config_base_t& config, 639 const audio_attributes_t& attributes) { 640 Parcel data, reply; 641 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 642 data.write(&config, sizeof(audio_config_base_t)); 643 data.write(&attributes, sizeof(audio_attributes_t)); 644 status_t status = remote()->transact(IS_DIRECT_OUTPUT_SUPPORTED, data, &reply); 645 return status == NO_ERROR ? static_cast<bool>(reply.readInt32()) : false; 646 } 647 648 virtual status_t listAudioPorts(audio_port_role_t role, 649 audio_port_type_t type, 650 unsigned int *num_ports, 651 struct audio_port *ports, 652 unsigned int *generation) 653 { 654 if (num_ports == NULL || (*num_ports != 0 && ports == NULL) || 655 generation == NULL) { 656 return BAD_VALUE; 657 } 658 Parcel data, reply; 659 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 660 unsigned int numPortsReq = (ports == NULL) ? 0 : *num_ports; 661 data.writeInt32(role); 662 data.writeInt32(type); 663 data.writeInt32(numPortsReq); 664 status_t status = remote()->transact(LIST_AUDIO_PORTS, data, &reply); 665 if (status == NO_ERROR) { 666 status = (status_t)reply.readInt32(); 667 *num_ports = (unsigned int)reply.readInt32(); 668 } 669 if (status == NO_ERROR) { 670 if (numPortsReq > *num_ports) { 671 numPortsReq = *num_ports; 672 } 673 if (numPortsReq > 0) { 674 reply.read(ports, numPortsReq * sizeof(struct audio_port)); 675 } 676 *generation = reply.readInt32(); 677 } 678 return status; 679 } 680 681 virtual status_t getAudioPort(struct audio_port *port) 682 { 683 if (port == NULL) { 684 return BAD_VALUE; 685 } 686 Parcel data, reply; 687 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 688 data.write(port, sizeof(struct audio_port)); 689 status_t status = remote()->transact(GET_AUDIO_PORT, data, &reply); 690 if (status != NO_ERROR || 691 (status = (status_t)reply.readInt32()) != NO_ERROR) { 692 return status; 693 } 694 reply.read(port, sizeof(struct audio_port)); 695 return status; 696 } 697 698 virtual status_t createAudioPatch(const struct audio_patch *patch, 699 audio_patch_handle_t *handle) 700 { 701 if (patch == NULL || handle == NULL) { 702 return BAD_VALUE; 703 } 704 Parcel data, reply; 705 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 706 data.write(patch, sizeof(struct audio_patch)); 707 data.write(handle, sizeof(audio_patch_handle_t)); 708 status_t status = remote()->transact(CREATE_AUDIO_PATCH, data, &reply); 709 if (status != NO_ERROR || 710 (status = (status_t)reply.readInt32()) != NO_ERROR) { 711 return status; 712 } 713 reply.read(handle, sizeof(audio_patch_handle_t)); 714 return status; 715 } 716 717 virtual status_t releaseAudioPatch(audio_patch_handle_t handle) 718 { 719 Parcel data, reply; 720 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 721 data.write(&handle, sizeof(audio_patch_handle_t)); 722 status_t status = remote()->transact(RELEASE_AUDIO_PATCH, data, &reply); 723 if (status != NO_ERROR) { 724 status = (status_t)reply.readInt32(); 725 } 726 return status; 727 } 728 729 virtual status_t listAudioPatches(unsigned int *num_patches, 730 struct audio_patch *patches, 731 unsigned int *generation) 732 { 733 if (num_patches == NULL || (*num_patches != 0 && patches == NULL) || 734 generation == NULL) { 735 return BAD_VALUE; 736 } 737 Parcel data, reply; 738 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 739 unsigned int numPatchesReq = (patches == NULL) ? 0 : *num_patches; 740 data.writeInt32(numPatchesReq); 741 status_t status = remote()->transact(LIST_AUDIO_PATCHES, data, &reply); 742 if (status == NO_ERROR) { 743 status = (status_t)reply.readInt32(); 744 *num_patches = (unsigned int)reply.readInt32(); 745 } 746 if (status == NO_ERROR) { 747 if (numPatchesReq > *num_patches) { 748 numPatchesReq = *num_patches; 749 } 750 if (numPatchesReq > 0) { 751 reply.read(patches, numPatchesReq * sizeof(struct audio_patch)); 752 } 753 *generation = reply.readInt32(); 754 } 755 return status; 756 } 757 758 virtual status_t setAudioPortConfig(const struct audio_port_config *config) 759 { 760 if (config == NULL) { 761 return BAD_VALUE; 762 } 763 Parcel data, reply; 764 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 765 data.write(config, sizeof(struct audio_port_config)); 766 status_t status = remote()->transact(SET_AUDIO_PORT_CONFIG, data, &reply); 767 if (status != NO_ERROR) { 768 status = (status_t)reply.readInt32(); 769 } 770 return status; 771 } 772 773 virtual void registerClient(const sp<IAudioPolicyServiceClient>& client) 774 { 775 Parcel data, reply; 776 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 777 data.writeStrongBinder(IInterface::asBinder(client)); 778 remote()->transact(REGISTER_CLIENT, data, &reply); 779 } 780 781 virtual void setAudioPortCallbacksEnabled(bool enabled) 782 { 783 Parcel data, reply; 784 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 785 data.writeInt32(enabled ? 1 : 0); 786 remote()->transact(SET_AUDIO_PORT_CALLBACK_ENABLED, data, &reply); 787 } 788 789 virtual void setAudioVolumeGroupCallbacksEnabled(bool enabled) 790 { 791 Parcel data, reply; 792 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 793 data.writeInt32(enabled ? 1 : 0); 794 remote()->transact(SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED, data, &reply); 795 } 796 797 virtual status_t acquireSoundTriggerSession(audio_session_t *session, 798 audio_io_handle_t *ioHandle, 799 audio_devices_t *device) 800 { 801 if (session == NULL || ioHandle == NULL || device == NULL) { 802 return BAD_VALUE; 803 } 804 Parcel data, reply; 805 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 806 status_t status = remote()->transact(ACQUIRE_SOUNDTRIGGER_SESSION, data, &reply); 807 if (status != NO_ERROR) { 808 return status; 809 } 810 status = (status_t)reply.readInt32(); 811 if (status == NO_ERROR) { 812 *session = (audio_session_t)reply.readInt32(); 813 *ioHandle = (audio_io_handle_t)reply.readInt32(); 814 *device = (audio_devices_t)reply.readInt32(); 815 } 816 return status; 817 } 818 819 virtual status_t releaseSoundTriggerSession(audio_session_t session) 820 { 821 Parcel data, reply; 822 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 823 data.writeInt32(session); 824 status_t status = remote()->transact(RELEASE_SOUNDTRIGGER_SESSION, data, &reply); 825 if (status != NO_ERROR) { 826 return status; 827 } 828 return (status_t)reply.readInt32(); 829 } 830 831 virtual audio_mode_t getPhoneState() 832 { 833 Parcel data, reply; 834 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 835 status_t status = remote()->transact(GET_PHONE_STATE, data, &reply); 836 if (status != NO_ERROR) { 837 return AUDIO_MODE_INVALID; 838 } 839 return (audio_mode_t)reply.readInt32(); 840 } 841 842 virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration) 843 { 844 Parcel data, reply; 845 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 846 data.writeInt32(registration ? 1 : 0); 847 size_t size = mixes.size(); 848 if (size > MAX_MIXES_PER_POLICY) { 849 size = MAX_MIXES_PER_POLICY; 850 } 851 size_t sizePosition = data.dataPosition(); 852 data.writeInt32(size); 853 size_t finalSize = size; 854 for (size_t i = 0; i < size; i++) { 855 size_t position = data.dataPosition(); 856 if (mixes[i].writeToParcel(&data) != NO_ERROR) { 857 data.setDataPosition(position); 858 finalSize--; 859 } 860 } 861 if (size != finalSize) { 862 size_t position = data.dataPosition(); 863 data.setDataPosition(sizePosition); 864 data.writeInt32(finalSize); 865 data.setDataPosition(position); 866 } 867 status_t status = remote()->transact(REGISTER_POLICY_MIXES, data, &reply); 868 if (status == NO_ERROR) { 869 status = (status_t)reply.readInt32(); 870 } 871 return status; 872 } 873 874 virtual status_t startAudioSource(const struct audio_port_config *source, 875 const audio_attributes_t *attributes, 876 audio_port_handle_t *portId) 877 { 878 Parcel data, reply; 879 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 880 if (source == NULL || attributes == NULL || portId == NULL) { 881 return BAD_VALUE; 882 } 883 data.write(source, sizeof(struct audio_port_config)); 884 data.write(attributes, sizeof(audio_attributes_t)); 885 status_t status = remote()->transact(START_AUDIO_SOURCE, data, &reply); 886 if (status != NO_ERROR) { 887 return status; 888 } 889 status = (status_t)reply.readInt32(); 890 if (status != NO_ERROR) { 891 return status; 892 } 893 *portId = (audio_port_handle_t)reply.readInt32(); 894 return status; 895 } 896 897 virtual status_t stopAudioSource(audio_port_handle_t portId) 898 { 899 Parcel data, reply; 900 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 901 data.writeInt32(portId); 902 status_t status = remote()->transact(STOP_AUDIO_SOURCE, data, &reply); 903 if (status != NO_ERROR) { 904 return status; 905 } 906 status = (status_t)reply.readInt32(); 907 return status; 908 } 909 910 virtual status_t setMasterMono(bool mono) 911 { 912 Parcel data, reply; 913 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 914 data.writeInt32(static_cast<int32_t>(mono)); 915 status_t status = remote()->transact(SET_MASTER_MONO, data, &reply); 916 if (status != NO_ERROR) { 917 return status; 918 } 919 return static_cast<status_t>(reply.readInt32()); 920 } 921 922 virtual status_t getMasterMono(bool *mono) 923 { 924 if (mono == nullptr) { 925 return BAD_VALUE; 926 } 927 Parcel data, reply; 928 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 929 930 status_t status = remote()->transact(GET_MASTER_MONO, data, &reply); 931 if (status != NO_ERROR) { 932 return status; 933 } 934 status = static_cast<status_t>(reply.readInt32()); 935 if (status == NO_ERROR) { 936 *mono = static_cast<bool>(reply.readInt32()); 937 } 938 return status; 939 } 940 941 virtual float getStreamVolumeDB(audio_stream_type_t stream, int index, audio_devices_t device) 942 { 943 Parcel data, reply; 944 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 945 data.writeInt32(static_cast <int32_t>(stream)); 946 data.writeInt32(static_cast <int32_t>(index)); 947 data.writeUint32(static_cast <uint32_t>(device)); 948 status_t status = remote()->transact(GET_STREAM_VOLUME_DB, data, &reply); 949 if (status != NO_ERROR) { 950 return NAN; 951 } 952 return reply.readFloat(); 953 } 954 955 virtual status_t getSurroundFormats(unsigned int *numSurroundFormats, 956 audio_format_t *surroundFormats, 957 bool *surroundFormatsEnabled, 958 bool reported) 959 { 960 if (numSurroundFormats == NULL || (*numSurroundFormats != 0 && 961 (surroundFormats == NULL || surroundFormatsEnabled == NULL))) { 962 return BAD_VALUE; 963 } 964 Parcel data, reply; 965 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 966 unsigned int numSurroundFormatsReq = *numSurroundFormats; 967 data.writeUint32(numSurroundFormatsReq); 968 data.writeBool(reported); 969 status_t status = remote()->transact(GET_SURROUND_FORMATS, data, &reply); 970 if (status == NO_ERROR && (status = (status_t)reply.readInt32()) == NO_ERROR) { 971 *numSurroundFormats = reply.readUint32(); 972 } 973 if (status == NO_ERROR) { 974 if (numSurroundFormatsReq > *numSurroundFormats) { 975 numSurroundFormatsReq = *numSurroundFormats; 976 } 977 if (numSurroundFormatsReq > 0) { 978 status = reply.read(surroundFormats, 979 numSurroundFormatsReq * sizeof(audio_format_t)); 980 if (status != NO_ERROR) { 981 return status; 982 } 983 status = reply.read(surroundFormatsEnabled, 984 numSurroundFormatsReq * sizeof(bool)); 985 } 986 } 987 return status; 988 } 989 990 virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled) 991 { 992 Parcel data, reply; 993 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 994 data.writeInt32(audioFormat); 995 data.writeBool(enabled); 996 status_t status = remote()->transact(SET_SURROUND_FORMAT_ENABLED, data, &reply); 997 if (status != NO_ERROR) { 998 return status; 999 } 1000 return reply.readInt32(); 1001 } 1002 1003 virtual status_t getHwOffloadEncodingFormatsSupportedForA2DP( 1004 std::vector<audio_format_t> *formats) 1005 { 1006 if (formats == NULL) { 1007 return BAD_VALUE; 1008 } 1009 1010 Parcel data, reply; 1011 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1012 status_t status = remote()->transact(GET_OFFLOAD_FORMATS_A2DP, data, &reply); 1013 if (status != NO_ERROR || (status = (status_t)reply.readInt32()) != NO_ERROR) { 1014 return status; 1015 } 1016 1017 size_t list_size = reply.readUint32(); 1018 1019 for (size_t i = 0; i < list_size; i++) { 1020 formats->push_back(static_cast<audio_format_t>(reply.readInt32())); 1021 } 1022 return NO_ERROR; 1023 } 1024 1025 1026 virtual status_t addStreamDefaultEffect(const effect_uuid_t *type, 1027 const String16& opPackageName, 1028 const effect_uuid_t *uuid, 1029 int32_t priority, 1030 audio_usage_t usage, 1031 audio_unique_id_t* id) 1032 { 1033 Parcel data, reply; 1034 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1035 data.write(type, sizeof(effect_uuid_t)); 1036 data.writeString16(opPackageName); 1037 data.write(uuid, sizeof(effect_uuid_t)); 1038 data.writeInt32(priority); 1039 data.writeInt32((int32_t) usage); 1040 status_t status = remote()->transact(ADD_STREAM_DEFAULT_EFFECT, data, &reply); 1041 if (status != NO_ERROR) { 1042 return status; 1043 } 1044 status = static_cast <status_t> (reply.readInt32()); 1045 *id = reply.readInt32(); 1046 return status; 1047 } 1048 1049 virtual status_t removeStreamDefaultEffect(audio_unique_id_t id) 1050 { 1051 Parcel data, reply; 1052 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1053 data.writeInt32(id); 1054 status_t status = remote()->transact(REMOVE_STREAM_DEFAULT_EFFECT, data, &reply); 1055 if (status != NO_ERROR) { 1056 return status; 1057 } 1058 return static_cast <status_t> (reply.readInt32()); 1059 } 1060 1061 virtual status_t addSourceDefaultEffect(const effect_uuid_t *type, 1062 const String16& opPackageName, 1063 const effect_uuid_t *uuid, 1064 int32_t priority, 1065 audio_source_t source, 1066 audio_unique_id_t* id) 1067 { 1068 Parcel data, reply; 1069 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1070 data.write(type, sizeof(effect_uuid_t)); 1071 data.writeString16(opPackageName); 1072 data.write(uuid, sizeof(effect_uuid_t)); 1073 data.writeInt32(priority); 1074 data.writeInt32((int32_t) source); 1075 status_t status = remote()->transact(ADD_SOURCE_DEFAULT_EFFECT, data, &reply); 1076 if (status != NO_ERROR) { 1077 return status; 1078 } 1079 status = static_cast <status_t> (reply.readInt32()); 1080 *id = reply.readInt32(); 1081 return status; 1082 } 1083 1084 virtual status_t removeSourceDefaultEffect(audio_unique_id_t id) 1085 { 1086 Parcel data, reply; 1087 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1088 data.writeInt32(id); 1089 status_t status = remote()->transact(REMOVE_SOURCE_DEFAULT_EFFECT, data, &reply); 1090 if (status != NO_ERROR) { 1091 return status; 1092 } 1093 return static_cast <status_t> (reply.readInt32()); 1094 } 1095 1096 virtual status_t setAssistantUid(uid_t uid) 1097 { 1098 Parcel data, reply; 1099 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1100 data.writeInt32(uid); 1101 status_t status = remote()->transact(SET_ASSISTANT_UID, data, &reply); 1102 if (status != NO_ERROR) { 1103 return status; 1104 } 1105 return static_cast <status_t> (reply.readInt32()); 1106 } 1107 1108 virtual status_t setA11yServicesUids(const std::vector<uid_t>& uids) 1109 { 1110 Parcel data, reply; 1111 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1112 data.writeInt32(uids.size()); 1113 for (auto uid : uids) { 1114 data.writeInt32(uid); 1115 } 1116 status_t status = remote()->transact(SET_A11Y_SERVICES_UIDS, data, &reply); 1117 if (status != NO_ERROR) { 1118 return status; 1119 } 1120 return static_cast <status_t> (reply.readInt32()); 1121 } 1122 1123 virtual bool isHapticPlaybackSupported() 1124 { 1125 Parcel data, reply; 1126 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1127 status_t status = remote()->transact(IS_HAPTIC_PLAYBACK_SUPPORTED, data, &reply); 1128 if (status != NO_ERROR) { 1129 return false; 1130 } 1131 return reply.readBool(); 1132 } 1133 1134 virtual status_t setUidDeviceAffinities(uid_t uid, const Vector<AudioDeviceTypeAddr>& devices) 1135 { 1136 Parcel data, reply; 1137 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1138 1139 data.writeInt32((int32_t) uid); 1140 size_t size = devices.size(); 1141 size_t sizePosition = data.dataPosition(); 1142 data.writeInt32((int32_t) size); 1143 size_t finalSize = size; 1144 for (size_t i = 0; i < size; i++) { 1145 size_t position = data.dataPosition(); 1146 if (devices[i].writeToParcel(&data) != NO_ERROR) { 1147 data.setDataPosition(position); 1148 finalSize--; 1149 } 1150 } 1151 if (size != finalSize) { 1152 size_t position = data.dataPosition(); 1153 data.setDataPosition(sizePosition); 1154 data.writeInt32(finalSize); 1155 data.setDataPosition(position); 1156 } 1157 1158 status_t status = remote()->transact(SET_UID_DEVICE_AFFINITY, data, &reply); 1159 if (status == NO_ERROR) { 1160 status = (status_t)reply.readInt32(); 1161 } 1162 return status; 1163 } 1164 1165 virtual status_t removeUidDeviceAffinities(uid_t uid) { 1166 Parcel data, reply; 1167 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1168 1169 data.writeInt32((int32_t) uid); 1170 1171 status_t status = 1172 remote()->transact(REMOVE_UID_DEVICE_AFFINITY, data, &reply); 1173 if (status == NO_ERROR) { 1174 status = (status_t) reply.readInt32(); 1175 } 1176 return status; 1177 } 1178 1179 virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies) 1180 { 1181 Parcel data, reply; 1182 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1183 1184 status_t status = remote()->transact(LIST_AUDIO_PRODUCT_STRATEGIES, data, &reply); 1185 if (status != NO_ERROR) { 1186 ALOGE("%s: permission denied", __func__); 1187 return status; 1188 } 1189 status = static_cast<status_t>(reply.readInt32()); 1190 if (status != NO_ERROR) { 1191 return status; 1192 } 1193 uint32_t numStrategies = static_cast<uint32_t>(reply.readInt32()); 1194 for (size_t i = 0; i < numStrategies; i++) { 1195 AudioProductStrategy strategy; 1196 status = strategy.readFromParcel(&reply); 1197 if (status != NO_ERROR) { 1198 ALOGE("%s: failed to read strategies", __FUNCTION__); 1199 strategies.clear(); 1200 return status; 1201 } 1202 strategies.push_back(strategy); 1203 } 1204 return NO_ERROR; 1205 } 1206 1207 virtual status_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa, 1208 product_strategy_t &productStrategy) 1209 { 1210 Parcel data, reply; 1211 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1212 status_t status = aa.writeToParcel(&data); 1213 if (status != NO_ERROR) { 1214 return status; 1215 } 1216 status = remote()->transact(GET_STRATEGY_FOR_ATTRIBUTES, data, &reply); 1217 if (status != NO_ERROR) { 1218 return status; 1219 } 1220 status = static_cast<status_t>(reply.readInt32()); 1221 if (status != NO_ERROR) { 1222 return status; 1223 } 1224 productStrategy = static_cast<product_strategy_t>(reply.readInt32()); 1225 return NO_ERROR; 1226 } 1227 1228 virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups) 1229 { 1230 Parcel data, reply; 1231 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1232 1233 status_t status = remote()->transact(LIST_AUDIO_VOLUME_GROUPS, data, &reply); 1234 if (status != NO_ERROR) { 1235 return status; 1236 } 1237 status = static_cast<status_t>(reply.readInt32()); 1238 if (status != NO_ERROR) { 1239 return status; 1240 } 1241 uint32_t numGroups = static_cast<uint32_t>(reply.readInt32()); 1242 for (size_t i = 0; i < numGroups; i++) { 1243 AudioVolumeGroup group; 1244 status = group.readFromParcel(&reply); 1245 if (status != NO_ERROR) { 1246 ALOGE("%s: failed to read volume groups", __FUNCTION__); 1247 groups.clear(); 1248 return status; 1249 } 1250 groups.push_back(group); 1251 } 1252 return NO_ERROR; 1253 } 1254 1255 virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa, 1256 volume_group_t &volumeGroup) 1257 { 1258 Parcel data, reply; 1259 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1260 status_t status = aa.writeToParcel(&data); 1261 if (status != NO_ERROR) { 1262 return status; 1263 } 1264 status = remote()->transact(GET_VOLUME_GROUP_FOR_ATTRIBUTES, data, &reply); 1265 if (status != NO_ERROR) { 1266 return status; 1267 } 1268 status = static_cast<status_t>(reply.readInt32()); 1269 if (status != NO_ERROR) { 1270 return status; 1271 } 1272 volumeGroup = static_cast<volume_group_t>(reply.readInt32()); 1273 return NO_ERROR; 1274 } 1275 1276 virtual status_t setRttEnabled(bool enabled) 1277 { 1278 Parcel data, reply; 1279 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1280 data.writeInt32(static_cast<int32_t>(enabled)); 1281 status_t status = remote()->transact(SET_RTT_ENABLED, data, &reply); 1282 if (status != NO_ERROR) { 1283 return status; 1284 } 1285 return static_cast<status_t>(reply.readInt32()); 1286 } 1287 }; 1288 1289 IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService"); 1290 1291 // ---------------------------------------------------------------------- 1292 1293 status_t BnAudioPolicyService::onTransact( 1294 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 1295 { 1296 // make sure transactions reserved to AudioFlinger do not come from other processes 1297 switch (code) { 1298 case START_OUTPUT: 1299 case STOP_OUTPUT: 1300 case RELEASE_OUTPUT: 1301 case GET_INPUT_FOR_ATTR: 1302 case START_INPUT: 1303 case STOP_INPUT: 1304 case RELEASE_INPUT: 1305 case GET_OUTPUT_FOR_EFFECT: 1306 case REGISTER_EFFECT: 1307 case UNREGISTER_EFFECT: 1308 case SET_EFFECT_ENABLED: 1309 case GET_OUTPUT_FOR_ATTR: 1310 case ACQUIRE_SOUNDTRIGGER_SESSION: 1311 case RELEASE_SOUNDTRIGGER_SESSION: 1312 case MOVE_EFFECTS_TO_IO: 1313 ALOGW("%s: transaction %d received from PID %d", 1314 __func__, code, IPCThreadState::self()->getCallingPid()); 1315 // return status only for non void methods 1316 switch (code) { 1317 case RELEASE_OUTPUT: 1318 case RELEASE_INPUT: 1319 break; 1320 default: 1321 reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION)); 1322 break; 1323 } 1324 return OK; 1325 default: 1326 break; 1327 } 1328 1329 // make sure the following transactions come from system components 1330 switch (code) { 1331 case SET_DEVICE_CONNECTION_STATE: 1332 case HANDLE_DEVICE_CONFIG_CHANGE: 1333 case SET_PHONE_STATE: 1334 //FIXME: Allow SET_FORCE_USE calls from system apps until a better use case routing API is available 1335 // case SET_FORCE_USE: 1336 case INIT_STREAM_VOLUME: 1337 case SET_STREAM_VOLUME: 1338 case REGISTER_POLICY_MIXES: 1339 case SET_MASTER_MONO: 1340 case GET_SURROUND_FORMATS: 1341 case SET_SURROUND_FORMAT_ENABLED: 1342 case SET_ASSISTANT_UID: 1343 case SET_A11Y_SERVICES_UIDS: 1344 case SET_UID_DEVICE_AFFINITY: 1345 case REMOVE_UID_DEVICE_AFFINITY: 1346 case GET_OFFLOAD_FORMATS_A2DP: 1347 case LIST_AUDIO_VOLUME_GROUPS: 1348 case GET_VOLUME_GROUP_FOR_ATTRIBUTES: 1349 case SET_RTT_ENABLED: { 1350 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) { 1351 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d", 1352 __func__, code, IPCThreadState::self()->getCallingPid(), 1353 IPCThreadState::self()->getCallingUid()); 1354 reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION)); 1355 return OK; 1356 } 1357 } break; 1358 default: 1359 break; 1360 } 1361 1362 std::string tag("IAudioPolicyService command " + std::to_string(code)); 1363 TimeCheck check(tag.c_str()); 1364 1365 switch (code) { 1366 case SET_DEVICE_CONNECTION_STATE: { 1367 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1368 audio_devices_t device = 1369 static_cast <audio_devices_t>(data.readInt32()); 1370 audio_policy_dev_state_t state = 1371 static_cast <audio_policy_dev_state_t>(data.readInt32()); 1372 const char *device_address = data.readCString(); 1373 const char *device_name = data.readCString(); 1374 audio_format_t codecFormat = static_cast <audio_format_t>(data.readInt32()); 1375 if (device_address == nullptr || device_name == nullptr) { 1376 ALOGE("Bad Binder transaction: SET_DEVICE_CONNECTION_STATE for device %u", device); 1377 reply->writeInt32(static_cast<int32_t> (BAD_VALUE)); 1378 } else { 1379 reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device, 1380 state, 1381 device_address, 1382 device_name, 1383 codecFormat))); 1384 } 1385 return NO_ERROR; 1386 } break; 1387 1388 case GET_DEVICE_CONNECTION_STATE: { 1389 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1390 audio_devices_t device = 1391 static_cast<audio_devices_t> (data.readInt32()); 1392 const char *device_address = data.readCString(); 1393 if (device_address == nullptr) { 1394 ALOGE("Bad Binder transaction: GET_DEVICE_CONNECTION_STATE for device %u", device); 1395 reply->writeInt32(static_cast<int32_t> (AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE)); 1396 } else { 1397 reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device, 1398 device_address))); 1399 } 1400 return NO_ERROR; 1401 } break; 1402 1403 case HANDLE_DEVICE_CONFIG_CHANGE: { 1404 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1405 audio_devices_t device = 1406 static_cast <audio_devices_t>(data.readInt32()); 1407 const char *device_address = data.readCString(); 1408 const char *device_name = data.readCString(); 1409 audio_format_t codecFormat = 1410 static_cast <audio_format_t>(data.readInt32()); 1411 if (device_address == nullptr || device_name == nullptr) { 1412 ALOGE("Bad Binder transaction: HANDLE_DEVICE_CONFIG_CHANGE for device %u", device); 1413 reply->writeInt32(static_cast<int32_t> (BAD_VALUE)); 1414 } else { 1415 reply->writeInt32(static_cast<uint32_t> (handleDeviceConfigChange(device, 1416 device_address, 1417 device_name, 1418 codecFormat))); 1419 } 1420 return NO_ERROR; 1421 } break; 1422 1423 case SET_PHONE_STATE: { 1424 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1425 reply->writeInt32(static_cast <uint32_t>(setPhoneState( 1426 (audio_mode_t) data.readInt32()))); 1427 return NO_ERROR; 1428 } break; 1429 1430 case SET_FORCE_USE: { 1431 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1432 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>( 1433 data.readInt32()); 1434 audio_policy_forced_cfg_t config = 1435 static_cast <audio_policy_forced_cfg_t>(data.readInt32()); 1436 reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config))); 1437 return NO_ERROR; 1438 } break; 1439 1440 case GET_FORCE_USE: { 1441 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1442 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>( 1443 data.readInt32()); 1444 reply->writeInt32(static_cast <uint32_t>(getForceUse(usage))); 1445 return NO_ERROR; 1446 } break; 1447 1448 case GET_OUTPUT: { 1449 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1450 audio_stream_type_t stream = 1451 static_cast <audio_stream_type_t>(data.readInt32()); 1452 audio_io_handle_t output = getOutput(stream); 1453 reply->writeInt32(static_cast <int>(output)); 1454 return NO_ERROR; 1455 } break; 1456 1457 case GET_OUTPUT_FOR_ATTR: { 1458 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1459 audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER; 1460 status_t status = data.read(&attr, sizeof(audio_attributes_t)); 1461 if (status != NO_ERROR) { 1462 return status; 1463 } 1464 sanetizeAudioAttributes(&attr); 1465 audio_session_t session = (audio_session_t)data.readInt32(); 1466 audio_stream_type_t stream = AUDIO_STREAM_DEFAULT; 1467 bool hasStream = data.readInt32() != 0; 1468 if (hasStream) { 1469 stream = (audio_stream_type_t)data.readInt32(); 1470 } 1471 pid_t pid = (pid_t)data.readInt32(); 1472 uid_t uid = (uid_t)data.readInt32(); 1473 audio_config_t config; 1474 memset(&config, 0, sizeof(audio_config_t)); 1475 data.read(&config, sizeof(audio_config_t)); 1476 audio_output_flags_t flags = 1477 static_cast <audio_output_flags_t>(data.readInt32()); 1478 audio_port_handle_t selectedDeviceId = data.readInt32(); 1479 audio_port_handle_t portId = (audio_port_handle_t)data.readInt32(); 1480 audio_io_handle_t output = 0; 1481 std::vector<audio_io_handle_t> secondaryOutputs; 1482 status = getOutputForAttr(&attr, 1483 &output, session, &stream, pid, uid, 1484 &config, 1485 flags, &selectedDeviceId, &portId, &secondaryOutputs); 1486 reply->writeInt32(status); 1487 status = reply->write(&attr, sizeof(audio_attributes_t)); 1488 if (status != NO_ERROR) { 1489 return status; 1490 } 1491 reply->writeInt32(output); 1492 reply->writeInt32(stream); 1493 reply->writeInt32(selectedDeviceId); 1494 reply->writeInt32(portId); 1495 reply->writeInt32(secondaryOutputs.size()); 1496 return reply->write(secondaryOutputs.data(), 1497 secondaryOutputs.size() * sizeof(audio_io_handle_t)); 1498 } break; 1499 1500 case START_OUTPUT: { 1501 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1502 const audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32()); 1503 reply->writeInt32(static_cast <uint32_t>(startOutput(portId))); 1504 return NO_ERROR; 1505 } break; 1506 1507 case STOP_OUTPUT: { 1508 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1509 const audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32()); 1510 reply->writeInt32(static_cast <uint32_t>(stopOutput(portId))); 1511 return NO_ERROR; 1512 } break; 1513 1514 case RELEASE_OUTPUT: { 1515 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1516 const audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32()); 1517 releaseOutput(portId); 1518 return NO_ERROR; 1519 } break; 1520 1521 case GET_INPUT_FOR_ATTR: { 1522 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1523 audio_attributes_t attr = {}; 1524 data.read(&attr, sizeof(audio_attributes_t)); 1525 sanetizeAudioAttributes(&attr); 1526 audio_io_handle_t input = (audio_io_handle_t)data.readInt32(); 1527 audio_unique_id_t riid = (audio_unique_id_t)data.readInt32(); 1528 audio_session_t session = (audio_session_t)data.readInt32(); 1529 pid_t pid = (pid_t)data.readInt32(); 1530 uid_t uid = (uid_t)data.readInt32(); 1531 const String16 opPackageName = data.readString16(); 1532 audio_config_base_t config; 1533 memset(&config, 0, sizeof(audio_config_base_t)); 1534 data.read(&config, sizeof(audio_config_base_t)); 1535 audio_input_flags_t flags = (audio_input_flags_t) data.readInt32(); 1536 audio_port_handle_t selectedDeviceId = (audio_port_handle_t) data.readInt32(); 1537 audio_port_handle_t portId = (audio_port_handle_t)data.readInt32(); 1538 status_t status = getInputForAttr(&attr, &input, riid, session, pid, uid, 1539 opPackageName, &config, 1540 flags, &selectedDeviceId, &portId); 1541 reply->writeInt32(status); 1542 if (status == NO_ERROR) { 1543 reply->writeInt32(input); 1544 reply->writeInt32(selectedDeviceId); 1545 reply->writeInt32(portId); 1546 } 1547 return NO_ERROR; 1548 } break; 1549 1550 case START_INPUT: { 1551 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1552 audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32()); 1553 status_t status = startInput(portId); 1554 reply->writeInt32(static_cast <uint32_t>(status)); 1555 return NO_ERROR; 1556 } break; 1557 1558 case STOP_INPUT: { 1559 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1560 audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32()); 1561 reply->writeInt32(static_cast <uint32_t>(stopInput(portId))); 1562 return NO_ERROR; 1563 } break; 1564 1565 case RELEASE_INPUT: { 1566 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1567 audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32()); 1568 releaseInput(portId); 1569 return NO_ERROR; 1570 } break; 1571 1572 case INIT_STREAM_VOLUME: { 1573 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1574 audio_stream_type_t stream = 1575 static_cast <audio_stream_type_t>(data.readInt32()); 1576 int indexMin = data.readInt32(); 1577 int indexMax = data.readInt32(); 1578 reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax))); 1579 return NO_ERROR; 1580 } break; 1581 1582 case SET_STREAM_VOLUME: { 1583 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1584 audio_stream_type_t stream = 1585 static_cast <audio_stream_type_t>(data.readInt32()); 1586 int index = data.readInt32(); 1587 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 1588 reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream, 1589 index, 1590 device))); 1591 return NO_ERROR; 1592 } break; 1593 1594 case GET_STREAM_VOLUME: { 1595 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1596 audio_stream_type_t stream = 1597 static_cast <audio_stream_type_t>(data.readInt32()); 1598 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 1599 int index = 0; 1600 status_t status = getStreamVolumeIndex(stream, &index, device); 1601 reply->writeInt32(index); 1602 reply->writeInt32(static_cast <uint32_t>(status)); 1603 return NO_ERROR; 1604 } break; 1605 1606 case GET_STRATEGY_FOR_STREAM: { 1607 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1608 audio_stream_type_t stream = 1609 static_cast <audio_stream_type_t>(data.readInt32()); 1610 reply->writeUint32(getStrategyForStream(stream)); 1611 return NO_ERROR; 1612 } break; 1613 1614 case SET_VOLUME_ATTRIBUTES: { 1615 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1616 audio_attributes_t attributes = {}; 1617 status_t status = data.read(&attributes, sizeof(audio_attributes_t)); 1618 if (status != NO_ERROR) { 1619 return status; 1620 } 1621 int index = data.readInt32(); 1622 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 1623 1624 reply->writeInt32(static_cast <uint32_t>(setVolumeIndexForAttributes(attributes, 1625 index, device))); 1626 return NO_ERROR; 1627 } break; 1628 1629 case GET_VOLUME_ATTRIBUTES: { 1630 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1631 audio_attributes_t attributes = {}; 1632 status_t status = data.read(&attributes, sizeof(audio_attributes_t)); 1633 if (status != NO_ERROR) { 1634 return status; 1635 } 1636 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 1637 1638 int index = 0; 1639 status = getVolumeIndexForAttributes(attributes, index, device); 1640 reply->writeInt32(static_cast <uint32_t>(status)); 1641 if (status == NO_ERROR) { 1642 reply->writeInt32(index); 1643 } 1644 return NO_ERROR; 1645 } break; 1646 1647 case GET_MIN_VOLUME_FOR_ATTRIBUTES: { 1648 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1649 audio_attributes_t attributes = {}; 1650 status_t status = data.read(&attributes, sizeof(audio_attributes_t)); 1651 if (status != NO_ERROR) { 1652 return status; 1653 } 1654 1655 int index = 0; 1656 status = getMinVolumeIndexForAttributes(attributes, index); 1657 reply->writeInt32(static_cast <uint32_t>(status)); 1658 if (status == NO_ERROR) { 1659 reply->writeInt32(index); 1660 } 1661 return NO_ERROR; 1662 } break; 1663 1664 case GET_MAX_VOLUME_FOR_ATTRIBUTES: { 1665 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1666 audio_attributes_t attributes = {}; 1667 status_t status = data.read(&attributes, sizeof(audio_attributes_t)); 1668 if (status != NO_ERROR) { 1669 return status; 1670 } 1671 1672 int index = 0; 1673 status = getMaxVolumeIndexForAttributes(attributes, index); 1674 reply->writeInt32(static_cast <uint32_t>(status)); 1675 if (status == NO_ERROR) { 1676 reply->writeInt32(index); 1677 } 1678 return NO_ERROR; 1679 } break; 1680 1681 case GET_DEVICES_FOR_STREAM: { 1682 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1683 audio_stream_type_t stream = 1684 static_cast <audio_stream_type_t>(data.readInt32()); 1685 reply->writeInt32(static_cast <int>(getDevicesForStream(stream))); 1686 return NO_ERROR; 1687 } break; 1688 1689 case GET_OUTPUT_FOR_EFFECT: { 1690 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1691 effect_descriptor_t desc = {}; 1692 if (data.read(&desc, sizeof(desc)) != NO_ERROR) { 1693 android_errorWriteLog(0x534e4554, "73126106"); 1694 } 1695 (void)sanitizeEffectDescriptor(&desc); 1696 audio_io_handle_t output = getOutputForEffect(&desc); 1697 reply->writeInt32(static_cast <int>(output)); 1698 return NO_ERROR; 1699 } break; 1700 1701 case REGISTER_EFFECT: { 1702 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1703 effect_descriptor_t desc = {}; 1704 if (data.read(&desc, sizeof(desc)) != NO_ERROR) { 1705 android_errorWriteLog(0x534e4554, "73126106"); 1706 } 1707 (void)sanitizeEffectDescriptor(&desc); 1708 audio_io_handle_t io = data.readInt32(); 1709 uint32_t strategy = data.readInt32(); 1710 audio_session_t session = (audio_session_t) data.readInt32(); 1711 int id = data.readInt32(); 1712 reply->writeInt32(static_cast <int32_t>(registerEffect(&desc, 1713 io, 1714 strategy, 1715 session, 1716 id))); 1717 return NO_ERROR; 1718 } break; 1719 1720 case UNREGISTER_EFFECT: { 1721 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1722 int id = data.readInt32(); 1723 reply->writeInt32(static_cast <int32_t>(unregisterEffect(id))); 1724 return NO_ERROR; 1725 } break; 1726 1727 case SET_EFFECT_ENABLED: { 1728 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1729 int id = data.readInt32(); 1730 bool enabled = static_cast <bool>(data.readInt32()); 1731 reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled))); 1732 return NO_ERROR; 1733 } break; 1734 1735 case MOVE_EFFECTS_TO_IO: { 1736 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1737 std::vector<int> ids; 1738 int32_t size; 1739 status_t status = data.readInt32(&size); 1740 if (status != NO_ERROR) { 1741 return status; 1742 } 1743 if (size > MAX_ITEMS_PER_LIST) { 1744 return BAD_VALUE; 1745 } 1746 for (int32_t i = 0; i < size; i++) { 1747 int id; 1748 status = data.readInt32(&id); 1749 if (status != NO_ERROR) { 1750 return status; 1751 } 1752 ids.push_back(id); 1753 } 1754 1755 audio_io_handle_t io = data.readInt32(); 1756 reply->writeInt32(static_cast <int32_t>(moveEffectsToIo(ids, io))); 1757 return NO_ERROR; 1758 } break; 1759 1760 case IS_STREAM_ACTIVE: { 1761 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1762 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 1763 uint32_t inPastMs = (uint32_t)data.readInt32(); 1764 reply->writeInt32( isStreamActive(stream, inPastMs) ); 1765 return NO_ERROR; 1766 } break; 1767 1768 case IS_STREAM_ACTIVE_REMOTELY: { 1769 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1770 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 1771 uint32_t inPastMs = (uint32_t)data.readInt32(); 1772 reply->writeInt32( isStreamActiveRemotely(stream, inPastMs) ); 1773 return NO_ERROR; 1774 } break; 1775 1776 case IS_SOURCE_ACTIVE: { 1777 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1778 audio_source_t source = (audio_source_t) data.readInt32(); 1779 reply->writeInt32( isSourceActive(source)); 1780 return NO_ERROR; 1781 } 1782 1783 case QUERY_DEFAULT_PRE_PROCESSING: { 1784 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1785 audio_session_t audioSession = (audio_session_t) data.readInt32(); 1786 uint32_t count = data.readInt32(); 1787 if (count > AudioEffect::kMaxPreProcessing) { 1788 count = AudioEffect::kMaxPreProcessing; 1789 } 1790 uint32_t retCount = count; 1791 effect_descriptor_t *descriptors = new effect_descriptor_t[count]{}; 1792 status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount); 1793 reply->writeInt32(status); 1794 if (status != NO_ERROR && status != NO_MEMORY) { 1795 retCount = 0; 1796 } 1797 reply->writeInt32(retCount); 1798 if (retCount != 0) { 1799 if (retCount < count) { 1800 count = retCount; 1801 } 1802 reply->write(descriptors, sizeof(effect_descriptor_t) * count); 1803 } 1804 delete[] descriptors; 1805 return status; 1806 } 1807 1808 case IS_OFFLOAD_SUPPORTED: { 1809 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1810 audio_offload_info_t info = {}; 1811 data.read(&info, sizeof(audio_offload_info_t)); 1812 bool isSupported = isOffloadSupported(info); 1813 reply->writeInt32(isSupported); 1814 return NO_ERROR; 1815 } 1816 1817 case IS_DIRECT_OUTPUT_SUPPORTED: { 1818 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1819 audio_config_base_t config = {}; 1820 audio_attributes_t attributes = {}; 1821 status_t status = data.read(&config, sizeof(audio_config_base_t)); 1822 if (status != NO_ERROR) return status; 1823 status = data.read(&attributes, sizeof(audio_attributes_t)); 1824 if (status != NO_ERROR) return status; 1825 reply->writeInt32(isDirectOutputSupported(config, attributes)); 1826 return NO_ERROR; 1827 } 1828 1829 case LIST_AUDIO_PORTS: { 1830 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1831 audio_port_role_t role = (audio_port_role_t)data.readInt32(); 1832 audio_port_type_t type = (audio_port_type_t)data.readInt32(); 1833 unsigned int numPortsReq = data.readInt32(); 1834 if (numPortsReq > MAX_ITEMS_PER_LIST) { 1835 numPortsReq = MAX_ITEMS_PER_LIST; 1836 } 1837 unsigned int numPorts = numPortsReq; 1838 struct audio_port *ports = 1839 (struct audio_port *)calloc(numPortsReq, sizeof(struct audio_port)); 1840 if (ports == NULL) { 1841 reply->writeInt32(NO_MEMORY); 1842 reply->writeInt32(0); 1843 return NO_ERROR; 1844 } 1845 unsigned int generation; 1846 status_t status = listAudioPorts(role, type, &numPorts, ports, &generation); 1847 reply->writeInt32(status); 1848 reply->writeInt32(numPorts); 1849 1850 if (status == NO_ERROR) { 1851 if (numPortsReq > numPorts) { 1852 numPortsReq = numPorts; 1853 } 1854 reply->write(ports, numPortsReq * sizeof(struct audio_port)); 1855 reply->writeInt32(generation); 1856 } 1857 free(ports); 1858 return NO_ERROR; 1859 } 1860 1861 case GET_AUDIO_PORT: { 1862 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1863 struct audio_port port = {}; 1864 if (data.read(&port, sizeof(struct audio_port)) != NO_ERROR) { 1865 ALOGE("b/23912202"); 1866 } 1867 status_t status = getAudioPort(&port); 1868 reply->writeInt32(status); 1869 if (status == NO_ERROR) { 1870 reply->write(&port, sizeof(struct audio_port)); 1871 } 1872 return NO_ERROR; 1873 } 1874 1875 case CREATE_AUDIO_PATCH: { 1876 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1877 struct audio_patch patch = {}; 1878 data.read(&patch, sizeof(struct audio_patch)); 1879 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE; 1880 if (data.read(&handle, sizeof(audio_patch_handle_t)) != NO_ERROR) { 1881 ALOGE("b/23912202"); 1882 } 1883 status_t status = createAudioPatch(&patch, &handle); 1884 reply->writeInt32(status); 1885 if (status == NO_ERROR) { 1886 reply->write(&handle, sizeof(audio_patch_handle_t)); 1887 } 1888 return NO_ERROR; 1889 } 1890 1891 case RELEASE_AUDIO_PATCH: { 1892 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1893 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE; 1894 data.read(&handle, sizeof(audio_patch_handle_t)); 1895 status_t status = releaseAudioPatch(handle); 1896 reply->writeInt32(status); 1897 return NO_ERROR; 1898 } 1899 1900 case LIST_AUDIO_PATCHES: { 1901 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1902 unsigned int numPatchesReq = data.readInt32(); 1903 if (numPatchesReq > MAX_ITEMS_PER_LIST) { 1904 numPatchesReq = MAX_ITEMS_PER_LIST; 1905 } 1906 unsigned int numPatches = numPatchesReq; 1907 struct audio_patch *patches = 1908 (struct audio_patch *)calloc(numPatchesReq, 1909 sizeof(struct audio_patch)); 1910 if (patches == NULL) { 1911 reply->writeInt32(NO_MEMORY); 1912 reply->writeInt32(0); 1913 return NO_ERROR; 1914 } 1915 unsigned int generation; 1916 status_t status = listAudioPatches(&numPatches, patches, &generation); 1917 reply->writeInt32(status); 1918 reply->writeInt32(numPatches); 1919 if (status == NO_ERROR) { 1920 if (numPatchesReq > numPatches) { 1921 numPatchesReq = numPatches; 1922 } 1923 reply->write(patches, numPatchesReq * sizeof(struct audio_patch)); 1924 reply->writeInt32(generation); 1925 } 1926 free(patches); 1927 return NO_ERROR; 1928 } 1929 1930 case SET_AUDIO_PORT_CONFIG: { 1931 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1932 struct audio_port_config config = {}; 1933 data.read(&config, sizeof(struct audio_port_config)); 1934 (void)sanitizeAudioPortConfig(&config); 1935 status_t status = setAudioPortConfig(&config); 1936 reply->writeInt32(status); 1937 return NO_ERROR; 1938 } 1939 1940 case REGISTER_CLIENT: { 1941 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1942 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1943 data.readStrongBinder()); 1944 registerClient(client); 1945 return NO_ERROR; 1946 } break; 1947 1948 case SET_AUDIO_PORT_CALLBACK_ENABLED: { 1949 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1950 setAudioPortCallbacksEnabled(data.readInt32() == 1); 1951 return NO_ERROR; 1952 } break; 1953 1954 case SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED: { 1955 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1956 setAudioVolumeGroupCallbacksEnabled(data.readInt32() == 1); 1957 return NO_ERROR; 1958 } break; 1959 1960 case ACQUIRE_SOUNDTRIGGER_SESSION: { 1961 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1962 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1963 data.readStrongBinder()); 1964 audio_session_t session = AUDIO_SESSION_NONE; 1965 audio_io_handle_t ioHandle = AUDIO_IO_HANDLE_NONE; 1966 audio_devices_t device = AUDIO_DEVICE_NONE; 1967 status_t status = acquireSoundTriggerSession(&session, &ioHandle, &device); 1968 reply->writeInt32(status); 1969 if (status == NO_ERROR) { 1970 reply->writeInt32(session); 1971 reply->writeInt32(ioHandle); 1972 reply->writeInt32(device); 1973 } 1974 return NO_ERROR; 1975 } break; 1976 1977 case RELEASE_SOUNDTRIGGER_SESSION: { 1978 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1979 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1980 data.readStrongBinder()); 1981 audio_session_t session = (audio_session_t)data.readInt32(); 1982 status_t status = releaseSoundTriggerSession(session); 1983 reply->writeInt32(status); 1984 return NO_ERROR; 1985 } break; 1986 1987 case GET_PHONE_STATE: { 1988 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1989 reply->writeInt32((int32_t)getPhoneState()); 1990 return NO_ERROR; 1991 } break; 1992 1993 case REGISTER_POLICY_MIXES: { 1994 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1995 bool registration = data.readInt32() == 1; 1996 Vector<AudioMix> mixes; 1997 size_t size = (size_t)data.readInt32(); 1998 if (size > MAX_MIXES_PER_POLICY) { 1999 size = MAX_MIXES_PER_POLICY; 2000 } 2001 for (size_t i = 0; i < size; i++) { 2002 AudioMix mix; 2003 if (mix.readFromParcel((Parcel*)&data) == NO_ERROR) { 2004 mixes.add(mix); 2005 } 2006 } 2007 status_t status = registerPolicyMixes(mixes, registration); 2008 reply->writeInt32(status); 2009 return NO_ERROR; 2010 } break; 2011 2012 case START_AUDIO_SOURCE: { 2013 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2014 struct audio_port_config source = {}; 2015 data.read(&source, sizeof(struct audio_port_config)); 2016 (void)sanitizeAudioPortConfig(&source); 2017 audio_attributes_t attributes = {}; 2018 data.read(&attributes, sizeof(audio_attributes_t)); 2019 sanetizeAudioAttributes(&attributes); 2020 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE; 2021 status_t status = startAudioSource(&source, &attributes, &portId); 2022 reply->writeInt32(status); 2023 reply->writeInt32(portId); 2024 return NO_ERROR; 2025 } break; 2026 2027 case STOP_AUDIO_SOURCE: { 2028 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2029 audio_port_handle_t portId = (audio_port_handle_t) data.readInt32(); 2030 status_t status = stopAudioSource(portId); 2031 reply->writeInt32(status); 2032 return NO_ERROR; 2033 } break; 2034 2035 case SET_MASTER_MONO: { 2036 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2037 bool mono = static_cast<bool>(data.readInt32()); 2038 status_t status = setMasterMono(mono); 2039 reply->writeInt32(status); 2040 return NO_ERROR; 2041 } break; 2042 2043 case GET_MASTER_MONO: { 2044 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2045 bool mono; 2046 status_t status = getMasterMono(&mono); 2047 reply->writeInt32(status); 2048 if (status == NO_ERROR) { 2049 reply->writeInt32(static_cast<int32_t>(mono)); 2050 } 2051 return NO_ERROR; 2052 } break; 2053 2054 case GET_STREAM_VOLUME_DB: { 2055 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2056 audio_stream_type_t stream = 2057 static_cast <audio_stream_type_t>(data.readInt32()); 2058 int index = static_cast <int>(data.readInt32()); 2059 audio_devices_t device = 2060 static_cast <audio_devices_t>(data.readUint32()); 2061 reply->writeFloat(getStreamVolumeDB(stream, index, device)); 2062 return NO_ERROR; 2063 } 2064 2065 case GET_SURROUND_FORMATS: { 2066 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2067 unsigned int numSurroundFormatsReq = data.readUint32(); 2068 if (numSurroundFormatsReq > MAX_ITEMS_PER_LIST) { 2069 numSurroundFormatsReq = MAX_ITEMS_PER_LIST; 2070 } 2071 bool reported = data.readBool(); 2072 unsigned int numSurroundFormats = numSurroundFormatsReq; 2073 audio_format_t *surroundFormats = (audio_format_t *)calloc( 2074 numSurroundFormats, sizeof(audio_format_t)); 2075 bool *surroundFormatsEnabled = (bool *)calloc(numSurroundFormats, sizeof(bool)); 2076 if (numSurroundFormatsReq > 0 && 2077 (surroundFormats == NULL || surroundFormatsEnabled == NULL)) { 2078 free(surroundFormats); 2079 free(surroundFormatsEnabled); 2080 reply->writeInt32(NO_MEMORY); 2081 return NO_ERROR; 2082 } 2083 status_t status = getSurroundFormats( 2084 &numSurroundFormats, surroundFormats, surroundFormatsEnabled, reported); 2085 reply->writeInt32(status); 2086 2087 if (status == NO_ERROR) { 2088 reply->writeUint32(numSurroundFormats); 2089 if (numSurroundFormatsReq > numSurroundFormats) { 2090 numSurroundFormatsReq = numSurroundFormats; 2091 } 2092 reply->write(surroundFormats, numSurroundFormatsReq * sizeof(audio_format_t)); 2093 reply->write(surroundFormatsEnabled, numSurroundFormatsReq * sizeof(bool)); 2094 } 2095 free(surroundFormats); 2096 free(surroundFormatsEnabled); 2097 return NO_ERROR; 2098 } 2099 2100 case SET_SURROUND_FORMAT_ENABLED: { 2101 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2102 audio_format_t audioFormat = (audio_format_t) data.readInt32(); 2103 bool enabled = data.readBool(); 2104 status_t status = setSurroundFormatEnabled(audioFormat, enabled); 2105 reply->writeInt32(status); 2106 return NO_ERROR; 2107 } 2108 2109 case GET_OFFLOAD_FORMATS_A2DP: { 2110 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2111 std::vector<audio_format_t> encodingFormats; 2112 status_t status = getHwOffloadEncodingFormatsSupportedForA2DP(&encodingFormats); 2113 reply->writeInt32(status); 2114 if (status != NO_ERROR) { 2115 return NO_ERROR; 2116 } 2117 reply->writeUint32(static_cast<uint32_t>(encodingFormats.size())); 2118 for (size_t i = 0; i < encodingFormats.size(); i++) 2119 reply->writeInt32(static_cast<int32_t>(encodingFormats[i])); 2120 return NO_ERROR; 2121 } 2122 2123 2124 case ADD_STREAM_DEFAULT_EFFECT: { 2125 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2126 effect_uuid_t type; 2127 status_t status = data.read(&type, sizeof(effect_uuid_t)); 2128 if (status != NO_ERROR) { 2129 return status; 2130 } 2131 String16 opPackageName; 2132 status = data.readString16(&opPackageName); 2133 if (status != NO_ERROR) { 2134 return status; 2135 } 2136 effect_uuid_t uuid; 2137 status = data.read(&uuid, sizeof(effect_uuid_t)); 2138 if (status != NO_ERROR) { 2139 return status; 2140 } 2141 int32_t priority = data.readInt32(); 2142 audio_usage_t usage = (audio_usage_t) data.readInt32(); 2143 audio_unique_id_t id = 0; 2144 reply->writeInt32(static_cast <int32_t>(addStreamDefaultEffect(&type, 2145 opPackageName, 2146 &uuid, 2147 priority, 2148 usage, 2149 &id))); 2150 reply->writeInt32(id); 2151 return NO_ERROR; 2152 } 2153 2154 case REMOVE_STREAM_DEFAULT_EFFECT: { 2155 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2156 audio_unique_id_t id = static_cast<audio_unique_id_t>(data.readInt32()); 2157 reply->writeInt32(static_cast <int32_t>(removeStreamDefaultEffect(id))); 2158 return NO_ERROR; 2159 } 2160 2161 case ADD_SOURCE_DEFAULT_EFFECT: { 2162 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2163 effect_uuid_t type; 2164 status_t status = data.read(&type, sizeof(effect_uuid_t)); 2165 if (status != NO_ERROR) { 2166 return status; 2167 } 2168 String16 opPackageName; 2169 status = data.readString16(&opPackageName); 2170 if (status != NO_ERROR) { 2171 return status; 2172 } 2173 effect_uuid_t uuid; 2174 status = data.read(&uuid, sizeof(effect_uuid_t)); 2175 if (status != NO_ERROR) { 2176 return status; 2177 } 2178 int32_t priority = data.readInt32(); 2179 audio_source_t source = (audio_source_t) data.readInt32(); 2180 audio_unique_id_t id = 0; 2181 reply->writeInt32(static_cast <int32_t>(addSourceDefaultEffect(&type, 2182 opPackageName, 2183 &uuid, 2184 priority, 2185 source, 2186 &id))); 2187 reply->writeInt32(id); 2188 return NO_ERROR; 2189 } 2190 2191 case REMOVE_SOURCE_DEFAULT_EFFECT: { 2192 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2193 audio_unique_id_t id = static_cast<audio_unique_id_t>(data.readInt32()); 2194 reply->writeInt32(static_cast <int32_t>(removeSourceDefaultEffect(id))); 2195 return NO_ERROR; 2196 } 2197 2198 case SET_ASSISTANT_UID: { 2199 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2200 int32_t uid; 2201 status_t status = data.readInt32(&uid); 2202 if (status != NO_ERROR) { 2203 return status; 2204 } 2205 status = setAssistantUid(uid); 2206 reply->writeInt32(static_cast <int32_t>(status)); 2207 return NO_ERROR; 2208 } 2209 2210 case SET_A11Y_SERVICES_UIDS: { 2211 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2212 std::vector<uid_t> uids; 2213 int32_t size; 2214 status_t status = data.readInt32(&size); 2215 if (status != NO_ERROR) { 2216 return status; 2217 } 2218 if (size > MAX_ITEMS_PER_LIST) { 2219 size = MAX_ITEMS_PER_LIST; 2220 } 2221 for (int32_t i = 0; i < size; i++) { 2222 int32_t uid; 2223 status = data.readInt32(&uid); 2224 if (status != NO_ERROR) { 2225 return status; 2226 } 2227 uids.push_back(uid); 2228 } 2229 status = setA11yServicesUids(uids); 2230 reply->writeInt32(static_cast <int32_t>(status)); 2231 return NO_ERROR; 2232 } 2233 2234 case IS_HAPTIC_PLAYBACK_SUPPORTED: { 2235 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2236 bool isSupported = isHapticPlaybackSupported(); 2237 reply->writeBool(isSupported); 2238 return NO_ERROR; 2239 } 2240 2241 case SET_UID_DEVICE_AFFINITY: { 2242 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2243 const uid_t uid = (uid_t) data.readInt32(); 2244 Vector<AudioDeviceTypeAddr> devices; 2245 size_t size = (size_t)data.readInt32(); 2246 for (size_t i = 0; i < size; i++) { 2247 AudioDeviceTypeAddr device; 2248 if (device.readFromParcel((Parcel*)&data) == NO_ERROR) { 2249 devices.add(device); 2250 } 2251 } 2252 status_t status = setUidDeviceAffinities(uid, devices); 2253 reply->writeInt32(status); 2254 return NO_ERROR; 2255 } 2256 2257 case REMOVE_UID_DEVICE_AFFINITY: { 2258 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2259 const uid_t uid = (uid_t) data.readInt32(); 2260 status_t status = removeUidDeviceAffinities(uid); 2261 reply->writeInt32(status); 2262 return NO_ERROR; 2263 } 2264 2265 case LIST_AUDIO_PRODUCT_STRATEGIES: { 2266 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2267 AudioProductStrategyVector strategies; 2268 status_t status = listAudioProductStrategies(strategies); 2269 reply->writeInt32(status); 2270 if (status != NO_ERROR) { 2271 return NO_ERROR; 2272 } 2273 size_t size = strategies.size(); 2274 size_t sizePosition = reply->dataPosition(); 2275 reply->writeInt32(size); 2276 size_t finalSize = size; 2277 for (size_t i = 0; i < size; i++) { 2278 size_t position = reply->dataPosition(); 2279 if (strategies[i].writeToParcel(reply) != NO_ERROR) { 2280 reply->setDataPosition(position); 2281 finalSize--; 2282 } 2283 } 2284 if (size != finalSize) { 2285 size_t position = reply->dataPosition(); 2286 reply->setDataPosition(sizePosition); 2287 reply->writeInt32(finalSize); 2288 reply->setDataPosition(position); 2289 } 2290 return NO_ERROR; 2291 } 2292 2293 case GET_STRATEGY_FOR_ATTRIBUTES: { 2294 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2295 AudioAttributes attributes; 2296 status_t status = attributes.readFromParcel(&data); 2297 if (status != NO_ERROR) { 2298 return status; 2299 } 2300 product_strategy_t strategy; 2301 status = getProductStrategyFromAudioAttributes(attributes, strategy); 2302 reply->writeInt32(status); 2303 if (status != NO_ERROR) { 2304 return NO_ERROR; 2305 } 2306 reply->writeUint32(static_cast<int>(strategy)); 2307 return NO_ERROR; 2308 } 2309 2310 case LIST_AUDIO_VOLUME_GROUPS: { 2311 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2312 AudioVolumeGroupVector groups; 2313 status_t status = listAudioVolumeGroups(groups); 2314 reply->writeInt32(status); 2315 if (status != NO_ERROR) { 2316 return NO_ERROR; 2317 } 2318 size_t size = groups.size(); 2319 size_t sizePosition = reply->dataPosition(); 2320 reply->writeInt32(size); 2321 size_t finalSize = size; 2322 for (size_t i = 0; i < size; i++) { 2323 size_t position = reply->dataPosition(); 2324 if (groups[i].writeToParcel(reply) != NO_ERROR) { 2325 reply->setDataPosition(position); 2326 finalSize--; 2327 } 2328 } 2329 if (size != finalSize) { 2330 size_t position = reply->dataPosition(); 2331 reply->setDataPosition(sizePosition); 2332 reply->writeInt32(finalSize); 2333 reply->setDataPosition(position); 2334 } 2335 return NO_ERROR; 2336 } 2337 2338 case GET_VOLUME_GROUP_FOR_ATTRIBUTES: { 2339 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2340 AudioAttributes attributes; 2341 status_t status = attributes.readFromParcel(&data); 2342 if (status != NO_ERROR) { 2343 return status; 2344 } 2345 volume_group_t group; 2346 status = getVolumeGroupFromAudioAttributes(attributes, group); 2347 reply->writeInt32(status); 2348 if (status != NO_ERROR) { 2349 return NO_ERROR; 2350 } 2351 reply->writeUint32(static_cast<int>(group)); 2352 return NO_ERROR; 2353 } 2354 2355 case SET_ALLOWED_CAPTURE_POLICY: { 2356 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2357 uid_t uid = data.readInt32(); 2358 audio_flags_mask_t flags = data.readInt32(); 2359 status_t status = setAllowedCapturePolicy(uid, flags); 2360 reply->writeInt32(status); 2361 return NO_ERROR; 2362 } 2363 2364 case SET_RTT_ENABLED: { 2365 CHECK_INTERFACE(IAudioPolicyService, data, reply); 2366 bool enabled = static_cast<bool>(data.readInt32()); 2367 status_t status = setRttEnabled(enabled); 2368 reply->writeInt32(status); 2369 return NO_ERROR; 2370 } 2371 2372 default: 2373 return BBinder::onTransact(code, data, reply, flags); 2374 } 2375 } 2376 2377 /** returns true if string overflow was prevented by zero termination */ 2378 template <size_t size> 2379 static bool preventStringOverflow(char (&s)[size]) { 2380 if (strnlen(s, size) < size) return false; 2381 s[size - 1] = '\0'; 2382 return true; 2383 } 2384 2385 void BnAudioPolicyService::sanetizeAudioAttributes(audio_attributes_t* attr) 2386 { 2387 const size_t tagsMaxSize = AUDIO_ATTRIBUTES_TAGS_MAX_SIZE; 2388 if (strnlen(attr->tags, tagsMaxSize) >= tagsMaxSize) { 2389 android_errorWriteLog(0x534e4554, "68953950"); // SafetyNet logging 2390 } 2391 attr->tags[tagsMaxSize - 1] = '\0'; 2392 } 2393 2394 /** returns BAD_VALUE if sanitization was required. */ 2395 status_t BnAudioPolicyService::sanitizeEffectDescriptor(effect_descriptor_t* desc) 2396 { 2397 if (preventStringOverflow(desc->name) 2398 | /* always */ preventStringOverflow(desc->implementor)) { 2399 android_errorWriteLog(0x534e4554, "73126106"); // SafetyNet logging 2400 return BAD_VALUE; 2401 } 2402 return NO_ERROR; 2403 } 2404 2405 /** returns BAD_VALUE if sanitization was required. */ 2406 status_t BnAudioPolicyService::sanitizeAudioPortConfig(struct audio_port_config* config) 2407 { 2408 if (config->type == AUDIO_PORT_TYPE_DEVICE && 2409 preventStringOverflow(config->ext.device.address)) { 2410 return BAD_VALUE; 2411 } 2412 return NO_ERROR; 2413 } 2414 2415 // ---------------------------------------------------------------------------- 2416 2417 } // namespace android 2418
