IAudioPolicyService.cpp revision 817729095966c338615a8a791d2dbf774fc034ef
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 <cutils/multiuser.h> 28#include <media/AudioEffect.h> 29#include <media/IAudioPolicyService.h> 30#include <media/TimeCheck.h> 31#include <private/android_filesystem_config.h> 32#include <system/audio.h> 33 34namespace android { 35 36enum { 37 SET_DEVICE_CONNECTION_STATE = IBinder::FIRST_CALL_TRANSACTION, 38 GET_DEVICE_CONNECTION_STATE, 39 HANDLE_DEVICE_CONFIG_CHANGE, 40 SET_PHONE_STATE, 41 SET_RINGER_MODE, // reserved, no longer used 42 SET_FORCE_USE, 43 GET_FORCE_USE, 44 GET_OUTPUT, 45 START_OUTPUT, 46 STOP_OUTPUT, 47 RELEASE_OUTPUT, 48 GET_INPUT_FOR_ATTR, 49 START_INPUT, 50 STOP_INPUT, 51 RELEASE_INPUT, 52 INIT_STREAM_VOLUME, 53 SET_STREAM_VOLUME, 54 GET_STREAM_VOLUME, 55 GET_STRATEGY_FOR_STREAM, 56 GET_OUTPUT_FOR_EFFECT, 57 REGISTER_EFFECT, 58 UNREGISTER_EFFECT, 59 IS_STREAM_ACTIVE, 60 IS_SOURCE_ACTIVE, 61 GET_DEVICES_FOR_STREAM, 62 QUERY_DEFAULT_PRE_PROCESSING, 63 SET_EFFECT_ENABLED, 64 IS_STREAM_ACTIVE_REMOTELY, 65 IS_OFFLOAD_SUPPORTED, 66 LIST_AUDIO_PORTS, 67 GET_AUDIO_PORT, 68 CREATE_AUDIO_PATCH, 69 RELEASE_AUDIO_PATCH, 70 LIST_AUDIO_PATCHES, 71 SET_AUDIO_PORT_CONFIG, 72 REGISTER_CLIENT, 73 GET_OUTPUT_FOR_ATTR, 74 ACQUIRE_SOUNDTRIGGER_SESSION, 75 RELEASE_SOUNDTRIGGER_SESSION, 76 GET_PHONE_STATE, 77 REGISTER_POLICY_MIXES, 78 START_AUDIO_SOURCE, 79 STOP_AUDIO_SOURCE, 80 SET_AUDIO_PORT_CALLBACK_ENABLED, 81 SET_MASTER_MONO, 82 GET_MASTER_MONO, 83 GET_STREAM_VOLUME_DB, 84 GET_SURROUND_FORMATS, 85 SET_SURROUND_FORMAT_ENABLED 86}; 87 88#define MAX_ITEMS_PER_LIST 1024 89 90class BpAudioPolicyService : public BpInterface<IAudioPolicyService> 91{ 92public: 93 explicit BpAudioPolicyService(const sp<IBinder>& impl) 94 : BpInterface<IAudioPolicyService>(impl) 95 { 96 } 97 98 virtual status_t setDeviceConnectionState( 99 audio_devices_t device, 100 audio_policy_dev_state_t state, 101 const char *device_address, 102 const char *device_name) 103 { 104 Parcel data, reply; 105 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 106 data.writeInt32(static_cast <uint32_t>(device)); 107 data.writeInt32(static_cast <uint32_t>(state)); 108 data.writeCString(device_address); 109 data.writeCString(device_name); 110 remote()->transact(SET_DEVICE_CONNECTION_STATE, data, &reply); 111 return static_cast <status_t> (reply.readInt32()); 112 } 113 114 virtual audio_policy_dev_state_t getDeviceConnectionState( 115 audio_devices_t device, 116 const char *device_address) 117 { 118 Parcel data, reply; 119 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 120 data.writeInt32(static_cast <uint32_t>(device)); 121 data.writeCString(device_address); 122 remote()->transact(GET_DEVICE_CONNECTION_STATE, data, &reply); 123 return static_cast <audio_policy_dev_state_t>(reply.readInt32()); 124 } 125 126 virtual status_t handleDeviceConfigChange(audio_devices_t device, 127 const char *device_address, 128 const char *device_name) 129 { 130 Parcel data, reply; 131 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 132 data.writeInt32(static_cast <uint32_t>(device)); 133 data.writeCString(device_address); 134 data.writeCString(device_name); 135 remote()->transact(HANDLE_DEVICE_CONFIG_CHANGE, data, &reply); 136 return static_cast <status_t> (reply.readInt32()); 137 } 138 139 virtual status_t setPhoneState(audio_mode_t state) 140 { 141 Parcel data, reply; 142 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 143 data.writeInt32(state); 144 remote()->transact(SET_PHONE_STATE, data, &reply); 145 return static_cast <status_t> (reply.readInt32()); 146 } 147 148 virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) 149 { 150 Parcel data, reply; 151 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 152 data.writeInt32(static_cast <uint32_t>(usage)); 153 data.writeInt32(static_cast <uint32_t>(config)); 154 remote()->transact(SET_FORCE_USE, data, &reply); 155 return static_cast <status_t> (reply.readInt32()); 156 } 157 158 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) 159 { 160 Parcel data, reply; 161 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 162 data.writeInt32(static_cast <uint32_t>(usage)); 163 remote()->transact(GET_FORCE_USE, data, &reply); 164 return static_cast <audio_policy_forced_cfg_t> (reply.readInt32()); 165 } 166 167 virtual audio_io_handle_t getOutput(audio_stream_type_t stream) 168 { 169 Parcel data, reply; 170 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 171 data.writeInt32(static_cast <uint32_t>(stream)); 172 remote()->transact(GET_OUTPUT, data, &reply); 173 return static_cast <audio_io_handle_t> (reply.readInt32()); 174 } 175 176 virtual status_t getOutputForAttr(const audio_attributes_t *attr, 177 audio_io_handle_t *output, 178 audio_session_t session, 179 audio_stream_type_t *stream, 180 pid_t pid, 181 uid_t uid, 182 const audio_config_t *config, 183 audio_output_flags_t flags, 184 audio_port_handle_t *selectedDeviceId, 185 audio_port_handle_t *portId) 186 { 187 Parcel data, reply; 188 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 189 if (attr == NULL) { 190 if (stream == NULL) { 191 ALOGE("getOutputForAttr(): NULL audio attributes and stream type"); 192 return BAD_VALUE; 193 } 194 if (*stream == AUDIO_STREAM_DEFAULT) { 195 ALOGE("getOutputForAttr unspecified stream type"); 196 return BAD_VALUE; 197 } 198 } 199 if (output == NULL) { 200 ALOGE("getOutputForAttr NULL output - shouldn't happen"); 201 return BAD_VALUE; 202 } 203 if (selectedDeviceId == NULL) { 204 ALOGE("getOutputForAttr NULL selectedDeviceId - shouldn't happen"); 205 return BAD_VALUE; 206 } 207 if (portId == NULL) { 208 ALOGE("getOutputForAttr NULL portId - shouldn't happen"); 209 return BAD_VALUE; 210 } 211 if (attr == NULL) { 212 data.writeInt32(0); 213 } else { 214 data.writeInt32(1); 215 data.write(attr, sizeof(audio_attributes_t)); 216 } 217 data.writeInt32(session); 218 if (stream == NULL) { 219 data.writeInt32(0); 220 } else { 221 data.writeInt32(1); 222 data.writeInt32(*stream); 223 } 224 data.writeInt32(pid); 225 data.writeInt32(uid); 226 data.write(config, sizeof(audio_config_t)); 227 data.writeInt32(static_cast <uint32_t>(flags)); 228 data.writeInt32(*selectedDeviceId); 229 data.writeInt32(*portId); 230 status_t status = remote()->transact(GET_OUTPUT_FOR_ATTR, data, &reply); 231 if (status != NO_ERROR) { 232 return status; 233 } 234 status = (status_t)reply.readInt32(); 235 if (status != NO_ERROR) { 236 return status; 237 } 238 *output = (audio_io_handle_t)reply.readInt32(); 239 audio_stream_type_t lStream = (audio_stream_type_t)reply.readInt32(); 240 if (stream != NULL) { 241 *stream = lStream; 242 } 243 *selectedDeviceId = (audio_port_handle_t)reply.readInt32(); 244 *portId = (audio_port_handle_t)reply.readInt32(); 245 return status; 246 } 247 248 virtual status_t startOutput(audio_io_handle_t output, 249 audio_stream_type_t stream, 250 audio_session_t session) 251 { 252 Parcel data, reply; 253 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 254 data.writeInt32(output); 255 data.writeInt32((int32_t) stream); 256 data.writeInt32((int32_t) session); 257 remote()->transact(START_OUTPUT, data, &reply); 258 return static_cast <status_t> (reply.readInt32()); 259 } 260 261 virtual status_t stopOutput(audio_io_handle_t output, 262 audio_stream_type_t stream, 263 audio_session_t session) 264 { 265 Parcel data, reply; 266 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 267 data.writeInt32(output); 268 data.writeInt32((int32_t) stream); 269 data.writeInt32((int32_t) session); 270 remote()->transact(STOP_OUTPUT, data, &reply); 271 return static_cast <status_t> (reply.readInt32()); 272 } 273 274 virtual void releaseOutput(audio_io_handle_t output, 275 audio_stream_type_t stream, 276 audio_session_t session) 277 { 278 Parcel data, reply; 279 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 280 data.writeInt32(output); 281 data.writeInt32((int32_t)stream); 282 data.writeInt32((int32_t)session); 283 remote()->transact(RELEASE_OUTPUT, data, &reply); 284 } 285 286 virtual status_t getInputForAttr(const audio_attributes_t *attr, 287 audio_io_handle_t *input, 288 audio_session_t session, 289 pid_t pid, 290 uid_t uid, 291 const String16& opPackageName, 292 const audio_config_base_t *config, 293 audio_input_flags_t flags, 294 audio_port_handle_t *selectedDeviceId, 295 audio_port_handle_t *portId) 296 { 297 Parcel data, reply; 298 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 299 if (attr == NULL) { 300 ALOGE("getInputForAttr NULL attr - shouldn't happen"); 301 return BAD_VALUE; 302 } 303 if (input == NULL) { 304 ALOGE("getInputForAttr NULL input - shouldn't happen"); 305 return BAD_VALUE; 306 } 307 if (selectedDeviceId == NULL) { 308 ALOGE("getInputForAttr NULL selectedDeviceId - shouldn't happen"); 309 return BAD_VALUE; 310 } 311 if (portId == NULL) { 312 ALOGE("getInputForAttr NULL portId - shouldn't happen"); 313 return BAD_VALUE; 314 } 315 data.write(attr, sizeof(audio_attributes_t)); 316 data.writeInt32(*input); 317 data.writeInt32(session); 318 data.writeInt32(pid); 319 data.writeInt32(uid); 320 data.writeString16(opPackageName); 321 data.write(config, sizeof(audio_config_base_t)); 322 data.writeInt32(flags); 323 data.writeInt32(*selectedDeviceId); 324 data.writeInt32(*portId); 325 status_t status = remote()->transact(GET_INPUT_FOR_ATTR, data, &reply); 326 if (status != NO_ERROR) { 327 return status; 328 } 329 status = reply.readInt32(); 330 if (status != NO_ERROR) { 331 return status; 332 } 333 *input = (audio_io_handle_t)reply.readInt32(); 334 *selectedDeviceId = (audio_port_handle_t)reply.readInt32(); 335 *portId = (audio_port_handle_t)reply.readInt32(); 336 return NO_ERROR; 337 } 338 339 virtual status_t startInput(audio_port_handle_t portId, 340 bool *silenced) 341 { 342 Parcel data, reply; 343 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 344 data.writeInt32(portId); 345 data.writeInt32(*silenced ? 1 : 0); 346 remote()->transact(START_INPUT, data, &reply); 347 status_t status = static_cast <status_t> (reply.readInt32()); 348 *silenced = reply.readInt32() == 1; 349 return status; 350 } 351 352 virtual status_t stopInput(audio_port_handle_t portId) 353 { 354 Parcel data, reply; 355 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 356 data.writeInt32(portId); 357 remote()->transact(STOP_INPUT, data, &reply); 358 return static_cast <status_t> (reply.readInt32()); 359 } 360 361 virtual void releaseInput(audio_port_handle_t portId) 362 { 363 Parcel data, reply; 364 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 365 data.writeInt32(portId); 366 remote()->transact(RELEASE_INPUT, data, &reply); 367 } 368 369 virtual status_t initStreamVolume(audio_stream_type_t stream, 370 int indexMin, 371 int indexMax) 372 { 373 Parcel data, reply; 374 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 375 data.writeInt32(static_cast <uint32_t>(stream)); 376 data.writeInt32(indexMin); 377 data.writeInt32(indexMax); 378 remote()->transact(INIT_STREAM_VOLUME, data, &reply); 379 return static_cast <status_t> (reply.readInt32()); 380 } 381 382 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, 383 int index, 384 audio_devices_t device) 385 { 386 Parcel data, reply; 387 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 388 data.writeInt32(static_cast <uint32_t>(stream)); 389 data.writeInt32(index); 390 data.writeInt32(static_cast <uint32_t>(device)); 391 remote()->transact(SET_STREAM_VOLUME, data, &reply); 392 return static_cast <status_t> (reply.readInt32()); 393 } 394 395 virtual status_t getStreamVolumeIndex(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(static_cast <uint32_t>(device)); 403 404 remote()->transact(GET_STREAM_VOLUME, data, &reply); 405 int lIndex = reply.readInt32(); 406 if (index) *index = lIndex; 407 return static_cast <status_t> (reply.readInt32()); 408 } 409 410 virtual uint32_t getStrategyForStream(audio_stream_type_t stream) 411 { 412 Parcel data, reply; 413 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 414 data.writeInt32(static_cast <uint32_t>(stream)); 415 remote()->transact(GET_STRATEGY_FOR_STREAM, data, &reply); 416 return reply.readInt32(); 417 } 418 419 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) 420 { 421 Parcel data, reply; 422 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 423 data.writeInt32(static_cast <uint32_t>(stream)); 424 remote()->transact(GET_DEVICES_FOR_STREAM, data, &reply); 425 return (audio_devices_t) reply.readInt32(); 426 } 427 428 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) 429 { 430 Parcel data, reply; 431 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 432 data.write(desc, sizeof(effect_descriptor_t)); 433 remote()->transact(GET_OUTPUT_FOR_EFFECT, data, &reply); 434 return static_cast <audio_io_handle_t> (reply.readInt32()); 435 } 436 437 virtual status_t registerEffect(const effect_descriptor_t *desc, 438 audio_io_handle_t io, 439 uint32_t strategy, 440 audio_session_t session, 441 int id) 442 { 443 Parcel data, reply; 444 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 445 data.write(desc, sizeof(effect_descriptor_t)); 446 data.writeInt32(io); 447 data.writeInt32(strategy); 448 data.writeInt32(session); 449 data.writeInt32(id); 450 remote()->transact(REGISTER_EFFECT, data, &reply); 451 return static_cast <status_t> (reply.readInt32()); 452 } 453 454 virtual status_t unregisterEffect(int id) 455 { 456 Parcel data, reply; 457 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 458 data.writeInt32(id); 459 remote()->transact(UNREGISTER_EFFECT, data, &reply); 460 return static_cast <status_t> (reply.readInt32()); 461 } 462 463 virtual status_t setEffectEnabled(int id, bool enabled) 464 { 465 Parcel data, reply; 466 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 467 data.writeInt32(id); 468 data.writeInt32(enabled); 469 remote()->transact(SET_EFFECT_ENABLED, data, &reply); 470 return static_cast <status_t> (reply.readInt32()); 471 } 472 473 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const 474 { 475 Parcel data, reply; 476 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 477 data.writeInt32((int32_t) stream); 478 data.writeInt32(inPastMs); 479 remote()->transact(IS_STREAM_ACTIVE, data, &reply); 480 return reply.readInt32(); 481 } 482 483 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const 484 { 485 Parcel data, reply; 486 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 487 data.writeInt32((int32_t) stream); 488 data.writeInt32(inPastMs); 489 remote()->transact(IS_STREAM_ACTIVE_REMOTELY, data, &reply); 490 return reply.readInt32(); 491 } 492 493 virtual bool isSourceActive(audio_source_t source) const 494 { 495 Parcel data, reply; 496 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 497 data.writeInt32((int32_t) source); 498 remote()->transact(IS_SOURCE_ACTIVE, data, &reply); 499 return reply.readInt32(); 500 } 501 502 virtual status_t queryDefaultPreProcessing(audio_session_t audioSession, 503 effect_descriptor_t *descriptors, 504 uint32_t *count) 505 { 506 if (descriptors == NULL || count == NULL) { 507 return BAD_VALUE; 508 } 509 Parcel data, reply; 510 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 511 data.writeInt32(audioSession); 512 data.writeInt32(*count); 513 status_t status = remote()->transact(QUERY_DEFAULT_PRE_PROCESSING, data, &reply); 514 if (status != NO_ERROR) { 515 return status; 516 } 517 status = static_cast <status_t> (reply.readInt32()); 518 uint32_t retCount = reply.readInt32(); 519 if (retCount != 0) { 520 uint32_t numDesc = (retCount < *count) ? retCount : *count; 521 reply.read(descriptors, sizeof(effect_descriptor_t) * numDesc); 522 } 523 *count = retCount; 524 return status; 525 } 526 527 virtual bool isOffloadSupported(const audio_offload_info_t& info) 528 { 529 Parcel data, reply; 530 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 531 data.write(&info, sizeof(audio_offload_info_t)); 532 remote()->transact(IS_OFFLOAD_SUPPORTED, data, &reply); 533 return reply.readInt32(); 534 } 535 536 virtual status_t listAudioPorts(audio_port_role_t role, 537 audio_port_type_t type, 538 unsigned int *num_ports, 539 struct audio_port *ports, 540 unsigned int *generation) 541 { 542 if (num_ports == NULL || (*num_ports != 0 && ports == NULL) || 543 generation == NULL) { 544 return BAD_VALUE; 545 } 546 Parcel data, reply; 547 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 548 unsigned int numPortsReq = (ports == NULL) ? 0 : *num_ports; 549 data.writeInt32(role); 550 data.writeInt32(type); 551 data.writeInt32(numPortsReq); 552 status_t status = remote()->transact(LIST_AUDIO_PORTS, data, &reply); 553 if (status == NO_ERROR) { 554 status = (status_t)reply.readInt32(); 555 *num_ports = (unsigned int)reply.readInt32(); 556 } 557 if (status == NO_ERROR) { 558 if (numPortsReq > *num_ports) { 559 numPortsReq = *num_ports; 560 } 561 if (numPortsReq > 0) { 562 reply.read(ports, numPortsReq * sizeof(struct audio_port)); 563 } 564 *generation = reply.readInt32(); 565 } 566 return status; 567 } 568 569 virtual status_t getAudioPort(struct audio_port *port) 570 { 571 if (port == NULL) { 572 return BAD_VALUE; 573 } 574 Parcel data, reply; 575 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 576 data.write(port, sizeof(struct audio_port)); 577 status_t status = remote()->transact(GET_AUDIO_PORT, data, &reply); 578 if (status != NO_ERROR || 579 (status = (status_t)reply.readInt32()) != NO_ERROR) { 580 return status; 581 } 582 reply.read(port, sizeof(struct audio_port)); 583 return status; 584 } 585 586 virtual status_t createAudioPatch(const struct audio_patch *patch, 587 audio_patch_handle_t *handle) 588 { 589 if (patch == NULL || handle == NULL) { 590 return BAD_VALUE; 591 } 592 Parcel data, reply; 593 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 594 data.write(patch, sizeof(struct audio_patch)); 595 data.write(handle, sizeof(audio_patch_handle_t)); 596 status_t status = remote()->transact(CREATE_AUDIO_PATCH, data, &reply); 597 if (status != NO_ERROR || 598 (status = (status_t)reply.readInt32()) != NO_ERROR) { 599 return status; 600 } 601 reply.read(handle, sizeof(audio_patch_handle_t)); 602 return status; 603 } 604 605 virtual status_t releaseAudioPatch(audio_patch_handle_t handle) 606 { 607 Parcel data, reply; 608 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 609 data.write(&handle, sizeof(audio_patch_handle_t)); 610 status_t status = remote()->transact(RELEASE_AUDIO_PATCH, data, &reply); 611 if (status != NO_ERROR) { 612 status = (status_t)reply.readInt32(); 613 } 614 return status; 615 } 616 617 virtual status_t listAudioPatches(unsigned int *num_patches, 618 struct audio_patch *patches, 619 unsigned int *generation) 620 { 621 if (num_patches == NULL || (*num_patches != 0 && patches == NULL) || 622 generation == NULL) { 623 return BAD_VALUE; 624 } 625 Parcel data, reply; 626 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 627 unsigned int numPatchesReq = (patches == NULL) ? 0 : *num_patches; 628 data.writeInt32(numPatchesReq); 629 status_t status = remote()->transact(LIST_AUDIO_PATCHES, data, &reply); 630 if (status == NO_ERROR) { 631 status = (status_t)reply.readInt32(); 632 *num_patches = (unsigned int)reply.readInt32(); 633 } 634 if (status == NO_ERROR) { 635 if (numPatchesReq > *num_patches) { 636 numPatchesReq = *num_patches; 637 } 638 if (numPatchesReq > 0) { 639 reply.read(patches, numPatchesReq * sizeof(struct audio_patch)); 640 } 641 *generation = reply.readInt32(); 642 } 643 return status; 644 } 645 646 virtual status_t setAudioPortConfig(const struct audio_port_config *config) 647 { 648 if (config == NULL) { 649 return BAD_VALUE; 650 } 651 Parcel data, reply; 652 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 653 data.write(config, sizeof(struct audio_port_config)); 654 status_t status = remote()->transact(SET_AUDIO_PORT_CONFIG, data, &reply); 655 if (status != NO_ERROR) { 656 status = (status_t)reply.readInt32(); 657 } 658 return status; 659 } 660 661 virtual void registerClient(const sp<IAudioPolicyServiceClient>& client) 662 { 663 Parcel data, reply; 664 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 665 data.writeStrongBinder(IInterface::asBinder(client)); 666 remote()->transact(REGISTER_CLIENT, data, &reply); 667 } 668 669 virtual void setAudioPortCallbacksEnabled(bool enabled) 670 { 671 Parcel data, reply; 672 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 673 data.writeInt32(enabled ? 1 : 0); 674 remote()->transact(SET_AUDIO_PORT_CALLBACK_ENABLED, data, &reply); 675 } 676 677 virtual status_t acquireSoundTriggerSession(audio_session_t *session, 678 audio_io_handle_t *ioHandle, 679 audio_devices_t *device) 680 { 681 if (session == NULL || ioHandle == NULL || device == NULL) { 682 return BAD_VALUE; 683 } 684 Parcel data, reply; 685 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 686 status_t status = remote()->transact(ACQUIRE_SOUNDTRIGGER_SESSION, data, &reply); 687 if (status != NO_ERROR) { 688 return status; 689 } 690 status = (status_t)reply.readInt32(); 691 if (status == NO_ERROR) { 692 *session = (audio_session_t)reply.readInt32(); 693 *ioHandle = (audio_io_handle_t)reply.readInt32(); 694 *device = (audio_devices_t)reply.readInt32(); 695 } 696 return status; 697 } 698 699 virtual status_t releaseSoundTriggerSession(audio_session_t session) 700 { 701 Parcel data, reply; 702 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 703 data.writeInt32(session); 704 status_t status = remote()->transact(RELEASE_SOUNDTRIGGER_SESSION, data, &reply); 705 if (status != NO_ERROR) { 706 return status; 707 } 708 return (status_t)reply.readInt32(); 709 } 710 711 virtual audio_mode_t getPhoneState() 712 { 713 Parcel data, reply; 714 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 715 status_t status = remote()->transact(GET_PHONE_STATE, data, &reply); 716 if (status != NO_ERROR) { 717 return AUDIO_MODE_INVALID; 718 } 719 return (audio_mode_t)reply.readInt32(); 720 } 721 722 virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration) 723 { 724 Parcel data, reply; 725 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 726 data.writeInt32(registration ? 1 : 0); 727 size_t size = mixes.size(); 728 if (size > MAX_MIXES_PER_POLICY) { 729 size = MAX_MIXES_PER_POLICY; 730 } 731 size_t sizePosition = data.dataPosition(); 732 data.writeInt32(size); 733 size_t finalSize = size; 734 for (size_t i = 0; i < size; i++) { 735 size_t position = data.dataPosition(); 736 if (mixes[i].writeToParcel(&data) != NO_ERROR) { 737 data.setDataPosition(position); 738 finalSize--; 739 } 740 } 741 if (size != finalSize) { 742 size_t position = data.dataPosition(); 743 data.setDataPosition(sizePosition); 744 data.writeInt32(finalSize); 745 data.setDataPosition(position); 746 } 747 status_t status = remote()->transact(REGISTER_POLICY_MIXES, data, &reply); 748 if (status == NO_ERROR) { 749 status = (status_t)reply.readInt32(); 750 } 751 return status; 752 } 753 754 virtual status_t startAudioSource(const struct audio_port_config *source, 755 const audio_attributes_t *attributes, 756 audio_patch_handle_t *handle) 757 { 758 Parcel data, reply; 759 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 760 if (source == NULL || attributes == NULL || handle == NULL) { 761 return BAD_VALUE; 762 } 763 data.write(source, sizeof(struct audio_port_config)); 764 data.write(attributes, sizeof(audio_attributes_t)); 765 status_t status = remote()->transact(START_AUDIO_SOURCE, data, &reply); 766 if (status != NO_ERROR) { 767 return status; 768 } 769 status = (status_t)reply.readInt32(); 770 if (status != NO_ERROR) { 771 return status; 772 } 773 *handle = (audio_patch_handle_t)reply.readInt32(); 774 return status; 775 } 776 777 virtual status_t stopAudioSource(audio_patch_handle_t handle) 778 { 779 Parcel data, reply; 780 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 781 data.writeInt32(handle); 782 status_t status = remote()->transact(STOP_AUDIO_SOURCE, data, &reply); 783 if (status != NO_ERROR) { 784 return status; 785 } 786 status = (status_t)reply.readInt32(); 787 return status; 788 } 789 790 virtual status_t setMasterMono(bool mono) 791 { 792 Parcel data, reply; 793 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 794 data.writeInt32(static_cast<int32_t>(mono)); 795 status_t status = remote()->transact(SET_MASTER_MONO, data, &reply); 796 if (status != NO_ERROR) { 797 return status; 798 } 799 return static_cast<status_t>(reply.readInt32()); 800 } 801 802 virtual status_t getMasterMono(bool *mono) 803 { 804 if (mono == nullptr) { 805 return BAD_VALUE; 806 } 807 Parcel data, reply; 808 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 809 810 status_t status = remote()->transact(GET_MASTER_MONO, data, &reply); 811 if (status != NO_ERROR) { 812 return status; 813 } 814 status = static_cast<status_t>(reply.readInt32()); 815 if (status == NO_ERROR) { 816 *mono = static_cast<bool>(reply.readInt32()); 817 } 818 return status; 819 } 820 821 virtual float getStreamVolumeDB(audio_stream_type_t stream, int index, audio_devices_t device) 822 { 823 Parcel data, reply; 824 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 825 data.writeInt32(static_cast <int32_t>(stream)); 826 data.writeInt32(static_cast <int32_t>(index)); 827 data.writeUint32(static_cast <uint32_t>(device)); 828 status_t status = remote()->transact(GET_STREAM_VOLUME_DB, data, &reply); 829 if (status != NO_ERROR) { 830 return NAN; 831 } 832 return reply.readFloat(); 833 } 834 835 virtual status_t getSurroundFormats(unsigned int *numSurroundFormats, 836 audio_format_t *surroundFormats, 837 bool *surroundFormatsEnabled, 838 bool reported) 839 { 840 if (numSurroundFormats == NULL || (*numSurroundFormats != 0 && 841 (surroundFormats == NULL || surroundFormatsEnabled == NULL))) { 842 return BAD_VALUE; 843 } 844 Parcel data, reply; 845 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 846 unsigned int numSurroundFormatsReq = *numSurroundFormats; 847 data.writeUint32(numSurroundFormatsReq); 848 data.writeBool(reported); 849 status_t status = remote()->transact(GET_SURROUND_FORMATS, data, &reply); 850 if (status == NO_ERROR && (status = (status_t)reply.readInt32()) == NO_ERROR) { 851 *numSurroundFormats = reply.readUint32(); 852 } 853 if (status == NO_ERROR) { 854 if (numSurroundFormatsReq > *numSurroundFormats) { 855 numSurroundFormatsReq = *numSurroundFormats; 856 } 857 if (numSurroundFormatsReq > 0) { 858 status = reply.read(surroundFormats, 859 numSurroundFormatsReq * sizeof(audio_format_t)); 860 if (status != NO_ERROR) { 861 return status; 862 } 863 status = reply.read(surroundFormatsEnabled, 864 numSurroundFormatsReq * sizeof(bool)); 865 } 866 } 867 return status; 868 } 869 870 virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled) 871 { 872 Parcel data, reply; 873 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 874 data.writeInt32(audioFormat); 875 data.writeBool(enabled); 876 status_t status = remote()->transact(SET_SURROUND_FORMAT_ENABLED, data, &reply); 877 if (status != NO_ERROR) { 878 return status; 879 } 880 return reply.readInt32(); 881 } 882}; 883 884IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService"); 885 886// ---------------------------------------------------------------------- 887 888status_t BnAudioPolicyService::onTransact( 889 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 890{ 891 // make sure transactions reserved to AudioFlinger do not come from other processes 892 switch (code) { 893 case START_OUTPUT: 894 case STOP_OUTPUT: 895 case RELEASE_OUTPUT: 896 case GET_INPUT_FOR_ATTR: 897 case START_INPUT: 898 case STOP_INPUT: 899 case RELEASE_INPUT: 900 case GET_STRATEGY_FOR_STREAM: 901 case GET_OUTPUT_FOR_EFFECT: 902 case REGISTER_EFFECT: 903 case UNREGISTER_EFFECT: 904 case SET_EFFECT_ENABLED: 905 case GET_OUTPUT_FOR_ATTR: 906 case ACQUIRE_SOUNDTRIGGER_SESSION: 907 case RELEASE_SOUNDTRIGGER_SESSION: 908 ALOGW("%s: transaction %d received from PID %d", 909 __func__, code, IPCThreadState::self()->getCallingPid()); 910 // return status only for non void methods 911 switch (code) { 912 case RELEASE_OUTPUT: 913 case RELEASE_INPUT: 914 break; 915 default: 916 reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION)); 917 break; 918 } 919 return OK; 920 default: 921 break; 922 } 923 924 // make sure the following transactions come from system components 925 switch (code) { 926 case SET_DEVICE_CONNECTION_STATE: 927 case HANDLE_DEVICE_CONFIG_CHANGE: 928 case SET_PHONE_STATE: 929 case SET_FORCE_USE: 930 case INIT_STREAM_VOLUME: 931 case SET_STREAM_VOLUME: 932 case REGISTER_POLICY_MIXES: 933 case SET_MASTER_MONO: 934 case START_AUDIO_SOURCE: 935 case STOP_AUDIO_SOURCE: 936 case GET_SURROUND_FORMATS: 937 case SET_SURROUND_FORMAT_ENABLED: { 938 if (multiuser_get_app_id(IPCThreadState::self()->getCallingUid()) >= AID_APP_START) { 939 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d", 940 __func__, code, IPCThreadState::self()->getCallingPid(), 941 IPCThreadState::self()->getCallingUid()); 942 reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION)); 943 return OK; 944 } 945 } break; 946 default: 947 break; 948 } 949 950 TimeCheck check("IAudioPolicyService"); 951 952 switch (code) { 953 case SET_DEVICE_CONNECTION_STATE: { 954 CHECK_INTERFACE(IAudioPolicyService, data, reply); 955 audio_devices_t device = 956 static_cast <audio_devices_t>(data.readInt32()); 957 audio_policy_dev_state_t state = 958 static_cast <audio_policy_dev_state_t>(data.readInt32()); 959 const char *device_address = data.readCString(); 960 const char *device_name = data.readCString(); 961 if (device_address == nullptr || device_name == nullptr) { 962 ALOGE("Bad Binder transaction: SET_DEVICE_CONNECTION_STATE for device %u", device); 963 reply->writeInt32(static_cast<int32_t> (BAD_VALUE)); 964 } else { 965 reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device, 966 state, 967 device_address, 968 device_name))); 969 } 970 return NO_ERROR; 971 } break; 972 973 case GET_DEVICE_CONNECTION_STATE: { 974 CHECK_INTERFACE(IAudioPolicyService, data, reply); 975 audio_devices_t device = 976 static_cast<audio_devices_t> (data.readInt32()); 977 const char *device_address = data.readCString(); 978 if (device_address == nullptr) { 979 ALOGE("Bad Binder transaction: GET_DEVICE_CONNECTION_STATE for device %u", device); 980 reply->writeInt32(static_cast<int32_t> (AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE)); 981 } else { 982 reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device, 983 device_address))); 984 } 985 return NO_ERROR; 986 } break; 987 988 case HANDLE_DEVICE_CONFIG_CHANGE: { 989 CHECK_INTERFACE(IAudioPolicyService, data, reply); 990 audio_devices_t device = 991 static_cast <audio_devices_t>(data.readInt32()); 992 const char *device_address = data.readCString(); 993 const char *device_name = data.readCString(); 994 if (device_address == nullptr || device_name == nullptr) { 995 ALOGE("Bad Binder transaction: HANDLE_DEVICE_CONFIG_CHANGE for device %u", device); 996 reply->writeInt32(static_cast<int32_t> (BAD_VALUE)); 997 } else { 998 reply->writeInt32(static_cast<uint32_t> (handleDeviceConfigChange(device, 999 device_address, 1000 device_name))); 1001 } 1002 return NO_ERROR; 1003 } break; 1004 1005 case SET_PHONE_STATE: { 1006 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1007 reply->writeInt32(static_cast <uint32_t>(setPhoneState( 1008 (audio_mode_t) data.readInt32()))); 1009 return NO_ERROR; 1010 } break; 1011 1012 case SET_FORCE_USE: { 1013 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1014 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>( 1015 data.readInt32()); 1016 audio_policy_forced_cfg_t config = 1017 static_cast <audio_policy_forced_cfg_t>(data.readInt32()); 1018 reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config))); 1019 return NO_ERROR; 1020 } break; 1021 1022 case GET_FORCE_USE: { 1023 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1024 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>( 1025 data.readInt32()); 1026 reply->writeInt32(static_cast <uint32_t>(getForceUse(usage))); 1027 return NO_ERROR; 1028 } break; 1029 1030 case GET_OUTPUT: { 1031 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1032 audio_stream_type_t stream = 1033 static_cast <audio_stream_type_t>(data.readInt32()); 1034 audio_io_handle_t output = getOutput(stream); 1035 reply->writeInt32(static_cast <int>(output)); 1036 return NO_ERROR; 1037 } break; 1038 1039 case GET_OUTPUT_FOR_ATTR: { 1040 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1041 audio_attributes_t attr = {}; 1042 bool hasAttributes = data.readInt32() != 0; 1043 if (hasAttributes) { 1044 data.read(&attr, sizeof(audio_attributes_t)); 1045 sanetizeAudioAttributes(&attr); 1046 } 1047 audio_session_t session = (audio_session_t)data.readInt32(); 1048 audio_stream_type_t stream = AUDIO_STREAM_DEFAULT; 1049 bool hasStream = data.readInt32() != 0; 1050 if (hasStream) { 1051 stream = (audio_stream_type_t)data.readInt32(); 1052 } 1053 pid_t pid = (pid_t)data.readInt32(); 1054 uid_t uid = (uid_t)data.readInt32(); 1055 audio_config_t config; 1056 memset(&config, 0, sizeof(audio_config_t)); 1057 data.read(&config, sizeof(audio_config_t)); 1058 audio_output_flags_t flags = 1059 static_cast <audio_output_flags_t>(data.readInt32()); 1060 audio_port_handle_t selectedDeviceId = data.readInt32(); 1061 audio_port_handle_t portId = (audio_port_handle_t)data.readInt32(); 1062 audio_io_handle_t output = 0; 1063 status_t status = getOutputForAttr(hasAttributes ? &attr : NULL, 1064 &output, session, &stream, pid, uid, 1065 &config, 1066 flags, &selectedDeviceId, &portId); 1067 reply->writeInt32(status); 1068 reply->writeInt32(output); 1069 reply->writeInt32(stream); 1070 reply->writeInt32(selectedDeviceId); 1071 reply->writeInt32(portId); 1072 return NO_ERROR; 1073 } break; 1074 1075 case START_OUTPUT: { 1076 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1077 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 1078 audio_stream_type_t stream = 1079 static_cast <audio_stream_type_t>(data.readInt32()); 1080 audio_session_t session = (audio_session_t)data.readInt32(); 1081 reply->writeInt32(static_cast <uint32_t>(startOutput(output, 1082 stream, 1083 session))); 1084 return NO_ERROR; 1085 } break; 1086 1087 case STOP_OUTPUT: { 1088 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1089 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 1090 audio_stream_type_t stream = 1091 static_cast <audio_stream_type_t>(data.readInt32()); 1092 audio_session_t session = (audio_session_t)data.readInt32(); 1093 reply->writeInt32(static_cast <uint32_t>(stopOutput(output, 1094 stream, 1095 session))); 1096 return NO_ERROR; 1097 } break; 1098 1099 case RELEASE_OUTPUT: { 1100 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1101 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 1102 audio_stream_type_t stream = (audio_stream_type_t)data.readInt32(); 1103 audio_session_t session = (audio_session_t)data.readInt32(); 1104 releaseOutput(output, stream, session); 1105 return NO_ERROR; 1106 } break; 1107 1108 case GET_INPUT_FOR_ATTR: { 1109 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1110 audio_attributes_t attr = {}; 1111 data.read(&attr, sizeof(audio_attributes_t)); 1112 sanetizeAudioAttributes(&attr); 1113 audio_io_handle_t input = (audio_io_handle_t)data.readInt32(); 1114 audio_session_t session = (audio_session_t)data.readInt32(); 1115 pid_t pid = (pid_t)data.readInt32(); 1116 uid_t uid = (uid_t)data.readInt32(); 1117 const String16 opPackageName = data.readString16(); 1118 audio_config_base_t config; 1119 memset(&config, 0, sizeof(audio_config_base_t)); 1120 data.read(&config, sizeof(audio_config_base_t)); 1121 audio_input_flags_t flags = (audio_input_flags_t) data.readInt32(); 1122 audio_port_handle_t selectedDeviceId = (audio_port_handle_t) data.readInt32(); 1123 audio_port_handle_t portId = (audio_port_handle_t)data.readInt32(); 1124 status_t status = getInputForAttr(&attr, &input, session, pid, uid, 1125 opPackageName, &config, 1126 flags, &selectedDeviceId, &portId); 1127 reply->writeInt32(status); 1128 if (status == NO_ERROR) { 1129 reply->writeInt32(input); 1130 reply->writeInt32(selectedDeviceId); 1131 reply->writeInt32(portId); 1132 } 1133 return NO_ERROR; 1134 } break; 1135 1136 case START_INPUT: { 1137 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1138 audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32()); 1139 bool silenced = data.readInt32() == 1; 1140 status_t status = startInput(portId, &silenced); 1141 reply->writeInt32(static_cast <uint32_t>(status)); 1142 reply->writeInt32(silenced ? 1 : 0); 1143 return NO_ERROR; 1144 } break; 1145 1146 case STOP_INPUT: { 1147 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1148 audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32()); 1149 reply->writeInt32(static_cast <uint32_t>(stopInput(portId))); 1150 return NO_ERROR; 1151 } break; 1152 1153 case RELEASE_INPUT: { 1154 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1155 audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32()); 1156 releaseInput(portId); 1157 return NO_ERROR; 1158 } break; 1159 1160 case INIT_STREAM_VOLUME: { 1161 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1162 audio_stream_type_t stream = 1163 static_cast <audio_stream_type_t>(data.readInt32()); 1164 int indexMin = data.readInt32(); 1165 int indexMax = data.readInt32(); 1166 reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax))); 1167 return NO_ERROR; 1168 } break; 1169 1170 case SET_STREAM_VOLUME: { 1171 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1172 audio_stream_type_t stream = 1173 static_cast <audio_stream_type_t>(data.readInt32()); 1174 int index = data.readInt32(); 1175 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 1176 reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream, 1177 index, 1178 device))); 1179 return NO_ERROR; 1180 } break; 1181 1182 case GET_STREAM_VOLUME: { 1183 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1184 audio_stream_type_t stream = 1185 static_cast <audio_stream_type_t>(data.readInt32()); 1186 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 1187 int index = 0; 1188 status_t status = getStreamVolumeIndex(stream, &index, device); 1189 reply->writeInt32(index); 1190 reply->writeInt32(static_cast <uint32_t>(status)); 1191 return NO_ERROR; 1192 } break; 1193 1194 case GET_STRATEGY_FOR_STREAM: { 1195 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1196 audio_stream_type_t stream = 1197 static_cast <audio_stream_type_t>(data.readInt32()); 1198 reply->writeInt32(getStrategyForStream(stream)); 1199 return NO_ERROR; 1200 } break; 1201 1202 case GET_DEVICES_FOR_STREAM: { 1203 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1204 audio_stream_type_t stream = 1205 static_cast <audio_stream_type_t>(data.readInt32()); 1206 reply->writeInt32(static_cast <int>(getDevicesForStream(stream))); 1207 return NO_ERROR; 1208 } break; 1209 1210 case GET_OUTPUT_FOR_EFFECT: { 1211 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1212 effect_descriptor_t desc = {}; 1213 if (data.read(&desc, sizeof(desc)) != NO_ERROR) { 1214 android_errorWriteLog(0x534e4554, "73126106"); 1215 } 1216 (void)sanitizeEffectDescriptor(&desc); 1217 audio_io_handle_t output = getOutputForEffect(&desc); 1218 reply->writeInt32(static_cast <int>(output)); 1219 return NO_ERROR; 1220 } break; 1221 1222 case REGISTER_EFFECT: { 1223 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1224 effect_descriptor_t desc = {}; 1225 if (data.read(&desc, sizeof(desc)) != NO_ERROR) { 1226 android_errorWriteLog(0x534e4554, "73126106"); 1227 } 1228 (void)sanitizeEffectDescriptor(&desc); 1229 audio_io_handle_t io = data.readInt32(); 1230 uint32_t strategy = data.readInt32(); 1231 audio_session_t session = (audio_session_t) data.readInt32(); 1232 int id = data.readInt32(); 1233 reply->writeInt32(static_cast <int32_t>(registerEffect(&desc, 1234 io, 1235 strategy, 1236 session, 1237 id))); 1238 return NO_ERROR; 1239 } break; 1240 1241 case UNREGISTER_EFFECT: { 1242 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1243 int id = data.readInt32(); 1244 reply->writeInt32(static_cast <int32_t>(unregisterEffect(id))); 1245 return NO_ERROR; 1246 } break; 1247 1248 case SET_EFFECT_ENABLED: { 1249 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1250 int id = data.readInt32(); 1251 bool enabled = static_cast <bool>(data.readInt32()); 1252 reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled))); 1253 return NO_ERROR; 1254 } break; 1255 1256 case IS_STREAM_ACTIVE: { 1257 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1258 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 1259 uint32_t inPastMs = (uint32_t)data.readInt32(); 1260 reply->writeInt32( isStreamActive(stream, inPastMs) ); 1261 return NO_ERROR; 1262 } break; 1263 1264 case IS_STREAM_ACTIVE_REMOTELY: { 1265 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1266 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 1267 uint32_t inPastMs = (uint32_t)data.readInt32(); 1268 reply->writeInt32( isStreamActiveRemotely(stream, inPastMs) ); 1269 return NO_ERROR; 1270 } break; 1271 1272 case IS_SOURCE_ACTIVE: { 1273 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1274 audio_source_t source = (audio_source_t) data.readInt32(); 1275 reply->writeInt32( isSourceActive(source)); 1276 return NO_ERROR; 1277 } 1278 1279 case QUERY_DEFAULT_PRE_PROCESSING: { 1280 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1281 audio_session_t audioSession = (audio_session_t) data.readInt32(); 1282 uint32_t count = data.readInt32(); 1283 if (count > AudioEffect::kMaxPreProcessing) { 1284 count = AudioEffect::kMaxPreProcessing; 1285 } 1286 uint32_t retCount = count; 1287 effect_descriptor_t *descriptors = new effect_descriptor_t[count]{}; 1288 status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount); 1289 reply->writeInt32(status); 1290 if (status != NO_ERROR && status != NO_MEMORY) { 1291 retCount = 0; 1292 } 1293 reply->writeInt32(retCount); 1294 if (retCount != 0) { 1295 if (retCount < count) { 1296 count = retCount; 1297 } 1298 reply->write(descriptors, sizeof(effect_descriptor_t) * count); 1299 } 1300 delete[] descriptors; 1301 return status; 1302 } 1303 1304 case IS_OFFLOAD_SUPPORTED: { 1305 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1306 audio_offload_info_t info = {}; 1307 data.read(&info, sizeof(audio_offload_info_t)); 1308 bool isSupported = isOffloadSupported(info); 1309 reply->writeInt32(isSupported); 1310 return NO_ERROR; 1311 } 1312 1313 case LIST_AUDIO_PORTS: { 1314 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1315 audio_port_role_t role = (audio_port_role_t)data.readInt32(); 1316 audio_port_type_t type = (audio_port_type_t)data.readInt32(); 1317 unsigned int numPortsReq = data.readInt32(); 1318 if (numPortsReq > MAX_ITEMS_PER_LIST) { 1319 numPortsReq = MAX_ITEMS_PER_LIST; 1320 } 1321 unsigned int numPorts = numPortsReq; 1322 struct audio_port *ports = 1323 (struct audio_port *)calloc(numPortsReq, sizeof(struct audio_port)); 1324 if (ports == NULL) { 1325 reply->writeInt32(NO_MEMORY); 1326 reply->writeInt32(0); 1327 return NO_ERROR; 1328 } 1329 unsigned int generation; 1330 status_t status = listAudioPorts(role, type, &numPorts, ports, &generation); 1331 reply->writeInt32(status); 1332 reply->writeInt32(numPorts); 1333 1334 if (status == NO_ERROR) { 1335 if (numPortsReq > numPorts) { 1336 numPortsReq = numPorts; 1337 } 1338 reply->write(ports, numPortsReq * sizeof(struct audio_port)); 1339 reply->writeInt32(generation); 1340 } 1341 free(ports); 1342 return NO_ERROR; 1343 } 1344 1345 case GET_AUDIO_PORT: { 1346 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1347 struct audio_port port = {}; 1348 if (data.read(&port, sizeof(struct audio_port)) != NO_ERROR) { 1349 ALOGE("b/23912202"); 1350 } 1351 status_t status = getAudioPort(&port); 1352 reply->writeInt32(status); 1353 if (status == NO_ERROR) { 1354 reply->write(&port, sizeof(struct audio_port)); 1355 } 1356 return NO_ERROR; 1357 } 1358 1359 case CREATE_AUDIO_PATCH: { 1360 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1361 struct audio_patch patch = {}; 1362 data.read(&patch, sizeof(struct audio_patch)); 1363 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE; 1364 if (data.read(&handle, sizeof(audio_patch_handle_t)) != NO_ERROR) { 1365 ALOGE("b/23912202"); 1366 } 1367 status_t status = createAudioPatch(&patch, &handle); 1368 reply->writeInt32(status); 1369 if (status == NO_ERROR) { 1370 reply->write(&handle, sizeof(audio_patch_handle_t)); 1371 } 1372 return NO_ERROR; 1373 } 1374 1375 case RELEASE_AUDIO_PATCH: { 1376 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1377 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE; 1378 data.read(&handle, sizeof(audio_patch_handle_t)); 1379 status_t status = releaseAudioPatch(handle); 1380 reply->writeInt32(status); 1381 return NO_ERROR; 1382 } 1383 1384 case LIST_AUDIO_PATCHES: { 1385 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1386 unsigned int numPatchesReq = data.readInt32(); 1387 if (numPatchesReq > MAX_ITEMS_PER_LIST) { 1388 numPatchesReq = MAX_ITEMS_PER_LIST; 1389 } 1390 unsigned int numPatches = numPatchesReq; 1391 struct audio_patch *patches = 1392 (struct audio_patch *)calloc(numPatchesReq, 1393 sizeof(struct audio_patch)); 1394 if (patches == NULL) { 1395 reply->writeInt32(NO_MEMORY); 1396 reply->writeInt32(0); 1397 return NO_ERROR; 1398 } 1399 unsigned int generation; 1400 status_t status = listAudioPatches(&numPatches, patches, &generation); 1401 reply->writeInt32(status); 1402 reply->writeInt32(numPatches); 1403 if (status == NO_ERROR) { 1404 if (numPatchesReq > numPatches) { 1405 numPatchesReq = numPatches; 1406 } 1407 reply->write(patches, numPatchesReq * sizeof(struct audio_patch)); 1408 reply->writeInt32(generation); 1409 } 1410 free(patches); 1411 return NO_ERROR; 1412 } 1413 1414 case SET_AUDIO_PORT_CONFIG: { 1415 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1416 struct audio_port_config config = {}; 1417 data.read(&config, sizeof(struct audio_port_config)); 1418 (void)sanitizeAudioPortConfig(&config); 1419 status_t status = setAudioPortConfig(&config); 1420 reply->writeInt32(status); 1421 return NO_ERROR; 1422 } 1423 1424 case REGISTER_CLIENT: { 1425 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1426 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1427 data.readStrongBinder()); 1428 registerClient(client); 1429 return NO_ERROR; 1430 } break; 1431 1432 case SET_AUDIO_PORT_CALLBACK_ENABLED: { 1433 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1434 setAudioPortCallbacksEnabled(data.readInt32() == 1); 1435 return NO_ERROR; 1436 } break; 1437 1438 case ACQUIRE_SOUNDTRIGGER_SESSION: { 1439 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1440 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1441 data.readStrongBinder()); 1442 audio_session_t session = AUDIO_SESSION_NONE; 1443 audio_io_handle_t ioHandle = AUDIO_IO_HANDLE_NONE; 1444 audio_devices_t device = AUDIO_DEVICE_NONE; 1445 status_t status = acquireSoundTriggerSession(&session, &ioHandle, &device); 1446 reply->writeInt32(status); 1447 if (status == NO_ERROR) { 1448 reply->writeInt32(session); 1449 reply->writeInt32(ioHandle); 1450 reply->writeInt32(device); 1451 } 1452 return NO_ERROR; 1453 } break; 1454 1455 case RELEASE_SOUNDTRIGGER_SESSION: { 1456 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1457 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1458 data.readStrongBinder()); 1459 audio_session_t session = (audio_session_t)data.readInt32(); 1460 status_t status = releaseSoundTriggerSession(session); 1461 reply->writeInt32(status); 1462 return NO_ERROR; 1463 } break; 1464 1465 case GET_PHONE_STATE: { 1466 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1467 reply->writeInt32((int32_t)getPhoneState()); 1468 return NO_ERROR; 1469 } break; 1470 1471 case REGISTER_POLICY_MIXES: { 1472 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1473 bool registration = data.readInt32() == 1; 1474 Vector<AudioMix> mixes; 1475 size_t size = (size_t)data.readInt32(); 1476 if (size > MAX_MIXES_PER_POLICY) { 1477 size = MAX_MIXES_PER_POLICY; 1478 } 1479 for (size_t i = 0; i < size; i++) { 1480 AudioMix mix; 1481 if (mix.readFromParcel((Parcel*)&data) == NO_ERROR) { 1482 mixes.add(mix); 1483 } 1484 } 1485 status_t status = registerPolicyMixes(mixes, registration); 1486 reply->writeInt32(status); 1487 return NO_ERROR; 1488 } break; 1489 1490 case START_AUDIO_SOURCE: { 1491 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1492 struct audio_port_config source = {}; 1493 data.read(&source, sizeof(struct audio_port_config)); 1494 (void)sanitizeAudioPortConfig(&source); 1495 audio_attributes_t attributes = {}; 1496 data.read(&attributes, sizeof(audio_attributes_t)); 1497 sanetizeAudioAttributes(&attributes); 1498 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE; 1499 status_t status = startAudioSource(&source, &attributes, &handle); 1500 reply->writeInt32(status); 1501 reply->writeInt32(handle); 1502 return NO_ERROR; 1503 } break; 1504 1505 case STOP_AUDIO_SOURCE: { 1506 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1507 audio_patch_handle_t handle = (audio_patch_handle_t) data.readInt32(); 1508 status_t status = stopAudioSource(handle); 1509 reply->writeInt32(status); 1510 return NO_ERROR; 1511 } break; 1512 1513 case SET_MASTER_MONO: { 1514 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1515 bool mono = static_cast<bool>(data.readInt32()); 1516 status_t status = setMasterMono(mono); 1517 reply->writeInt32(status); 1518 return NO_ERROR; 1519 } break; 1520 1521 case GET_MASTER_MONO: { 1522 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1523 bool mono; 1524 status_t status = getMasterMono(&mono); 1525 reply->writeInt32(status); 1526 if (status == NO_ERROR) { 1527 reply->writeInt32(static_cast<int32_t>(mono)); 1528 } 1529 return NO_ERROR; 1530 } break; 1531 1532 case GET_STREAM_VOLUME_DB: { 1533 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1534 audio_stream_type_t stream = 1535 static_cast <audio_stream_type_t>(data.readInt32()); 1536 int index = static_cast <int>(data.readInt32()); 1537 audio_devices_t device = 1538 static_cast <audio_devices_t>(data.readUint32()); 1539 reply->writeFloat(getStreamVolumeDB(stream, index, device)); 1540 return NO_ERROR; 1541 } 1542 1543 case GET_SURROUND_FORMATS: { 1544 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1545 unsigned int numSurroundFormatsReq = data.readUint32(); 1546 if (numSurroundFormatsReq > MAX_ITEMS_PER_LIST) { 1547 numSurroundFormatsReq = MAX_ITEMS_PER_LIST; 1548 } 1549 bool reported = data.readBool(); 1550 unsigned int numSurroundFormats = numSurroundFormatsReq; 1551 audio_format_t *surroundFormats = (audio_format_t *)calloc( 1552 numSurroundFormats, sizeof(audio_format_t)); 1553 bool *surroundFormatsEnabled = (bool *)calloc(numSurroundFormats, sizeof(bool)); 1554 if (numSurroundFormatsReq > 0 && 1555 (surroundFormats == NULL || surroundFormatsEnabled == NULL)) { 1556 free(surroundFormats); 1557 free(surroundFormatsEnabled); 1558 reply->writeInt32(NO_MEMORY); 1559 return NO_ERROR; 1560 } 1561 status_t status = getSurroundFormats( 1562 &numSurroundFormats, surroundFormats, surroundFormatsEnabled, reported); 1563 reply->writeInt32(status); 1564 1565 if (status == NO_ERROR) { 1566 reply->writeUint32(numSurroundFormats); 1567 if (numSurroundFormatsReq > numSurroundFormats) { 1568 numSurroundFormatsReq = numSurroundFormats; 1569 } 1570 reply->write(surroundFormats, numSurroundFormatsReq * sizeof(audio_format_t)); 1571 reply->write(surroundFormatsEnabled, numSurroundFormatsReq * sizeof(bool)); 1572 } 1573 free(surroundFormats); 1574 free(surroundFormatsEnabled); 1575 return NO_ERROR; 1576 } 1577 1578 case SET_SURROUND_FORMAT_ENABLED: { 1579 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1580 audio_format_t audioFormat = (audio_format_t) data.readInt32(); 1581 bool enabled = data.readBool(); 1582 status_t status = setSurroundFormatEnabled(audioFormat, enabled); 1583 reply->writeInt32(status); 1584 return NO_ERROR; 1585 } 1586 1587 default: 1588 return BBinder::onTransact(code, data, reply, flags); 1589 } 1590} 1591 1592/** returns true if string overflow was prevented by zero termination */ 1593template <size_t size> 1594static bool preventStringOverflow(char (&s)[size]) { 1595 if (strnlen(s, size) < size) return false; 1596 s[size - 1] = '\0'; 1597 return true; 1598} 1599 1600void BnAudioPolicyService::sanetizeAudioAttributes(audio_attributes_t* attr) 1601{ 1602 const size_t tagsMaxSize = AUDIO_ATTRIBUTES_TAGS_MAX_SIZE; 1603 if (strnlen(attr->tags, tagsMaxSize) >= tagsMaxSize) { 1604 android_errorWriteLog(0x534e4554, "68953950"); // SafetyNet logging 1605 } 1606 attr->tags[tagsMaxSize - 1] = '\0'; 1607} 1608 1609/** returns BAD_VALUE if sanitization was required. */ 1610status_t BnAudioPolicyService::sanitizeEffectDescriptor(effect_descriptor_t* desc) 1611{ 1612 if (preventStringOverflow(desc->name) 1613 | /* always */ preventStringOverflow(desc->implementor)) { 1614 android_errorWriteLog(0x534e4554, "73126106"); // SafetyNet logging 1615 return BAD_VALUE; 1616 } 1617 return NO_ERROR; 1618} 1619 1620/** returns BAD_VALUE if sanitization was required. */ 1621status_t BnAudioPolicyService::sanitizeAudioPortConfig(struct audio_port_config* config) 1622{ 1623 if (config->type == AUDIO_PORT_TYPE_DEVICE && 1624 preventStringOverflow(config->ext.device.address)) { 1625 return BAD_VALUE; 1626 } 1627 return NO_ERROR; 1628} 1629 1630// ---------------------------------------------------------------------------- 1631 1632} // namespace android 1633