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