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