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