IAudioPolicyService.cpp revision 2fdd16b3cbe1c1e53d1c4b305f4c0174b995ad1a
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, 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}; 74 75#define MAX_ITEMS_PER_LIST 1024 76 77class BpAudioPolicyService : public BpInterface<IAudioPolicyService> 78{ 79public: 80 BpAudioPolicyService(const sp<IBinder>& impl) 81 : BpInterface<IAudioPolicyService>(impl) 82 { 83 } 84 85 virtual status_t setDeviceConnectionState( 86 audio_devices_t device, 87 audio_policy_dev_state_t state, 88 const char *device_address) 89 { 90 Parcel data, reply; 91 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 92 data.writeInt32(static_cast <uint32_t>(device)); 93 data.writeInt32(static_cast <uint32_t>(state)); 94 data.writeCString(device_address); 95 remote()->transact(SET_DEVICE_CONNECTION_STATE, data, &reply); 96 return static_cast <status_t> (reply.readInt32()); 97 } 98 99 virtual audio_policy_dev_state_t getDeviceConnectionState( 100 audio_devices_t device, 101 const char *device_address) 102 { 103 Parcel data, reply; 104 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 105 data.writeInt32(static_cast <uint32_t>(device)); 106 data.writeCString(device_address); 107 remote()->transact(GET_DEVICE_CONNECTION_STATE, data, &reply); 108 return static_cast <audio_policy_dev_state_t>(reply.readInt32()); 109 } 110 111 virtual status_t setPhoneState(audio_mode_t state) 112 { 113 Parcel data, reply; 114 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 115 data.writeInt32(state); 116 remote()->transact(SET_PHONE_STATE, data, &reply); 117 return static_cast <status_t> (reply.readInt32()); 118 } 119 120 virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) 121 { 122 Parcel data, reply; 123 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 124 data.writeInt32(static_cast <uint32_t>(usage)); 125 data.writeInt32(static_cast <uint32_t>(config)); 126 remote()->transact(SET_FORCE_USE, data, &reply); 127 return static_cast <status_t> (reply.readInt32()); 128 } 129 130 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) 131 { 132 Parcel data, reply; 133 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 134 data.writeInt32(static_cast <uint32_t>(usage)); 135 remote()->transact(GET_FORCE_USE, data, &reply); 136 return static_cast <audio_policy_forced_cfg_t> (reply.readInt32()); 137 } 138 139 virtual audio_io_handle_t getOutput( 140 audio_stream_type_t stream, 141 uint32_t samplingRate, 142 audio_format_t format, 143 audio_channel_mask_t channelMask, 144 audio_output_flags_t flags, 145 const audio_offload_info_t *offloadInfo) 146 { 147 Parcel data, reply; 148 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 149 data.writeInt32(static_cast <uint32_t>(stream)); 150 data.writeInt32(samplingRate); 151 data.writeInt32(static_cast <uint32_t>(format)); 152 data.writeInt32(channelMask); 153 data.writeInt32(static_cast <uint32_t>(flags)); 154 // hasOffloadInfo 155 if (offloadInfo == NULL) { 156 data.writeInt32(0); 157 } else { 158 data.writeInt32(1); 159 data.write(offloadInfo, sizeof(audio_offload_info_t)); 160 } 161 remote()->transact(GET_OUTPUT, data, &reply); 162 return static_cast <audio_io_handle_t> (reply.readInt32()); 163 } 164 165 virtual audio_io_handle_t getOutputForAttr( 166 const audio_attributes_t *attr, 167 uint32_t samplingRate, 168 audio_format_t format, 169 audio_channel_mask_t channelMask, 170 audio_output_flags_t flags, 171 const audio_offload_info_t *offloadInfo) 172 { 173 Parcel data, reply; 174 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 175 if (attr == NULL) { 176 ALOGE("Writing NULL audio attributes - shouldn't happen"); 177 return (audio_io_handle_t) 0; 178 } 179 data.write(attr, sizeof(audio_attributes_t)); 180 data.writeInt32(samplingRate); 181 data.writeInt32(static_cast <uint32_t>(format)); 182 data.writeInt32(channelMask); 183 data.writeInt32(static_cast <uint32_t>(flags)); 184 // hasOffloadInfo 185 if (offloadInfo == NULL) { 186 data.writeInt32(0); 187 } else { 188 data.writeInt32(1); 189 data.write(offloadInfo, sizeof(audio_offload_info_t)); 190 } 191 remote()->transact(GET_OUTPUT_FOR_ATTR, data, &reply); 192 return static_cast <audio_io_handle_t> (reply.readInt32()); 193 } 194 195 virtual status_t startOutput(audio_io_handle_t output, 196 audio_stream_type_t stream, 197 int session) 198 { 199 Parcel data, reply; 200 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 201 data.writeInt32(output); 202 data.writeInt32((int32_t) stream); 203 data.writeInt32(session); 204 remote()->transact(START_OUTPUT, data, &reply); 205 return static_cast <status_t> (reply.readInt32()); 206 } 207 208 virtual status_t stopOutput(audio_io_handle_t output, 209 audio_stream_type_t stream, 210 int session) 211 { 212 Parcel data, reply; 213 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 214 data.writeInt32(output); 215 data.writeInt32((int32_t) stream); 216 data.writeInt32(session); 217 remote()->transact(STOP_OUTPUT, data, &reply); 218 return static_cast <status_t> (reply.readInt32()); 219 } 220 221 virtual void releaseOutput(audio_io_handle_t output) 222 { 223 Parcel data, reply; 224 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 225 data.writeInt32(output); 226 remote()->transact(RELEASE_OUTPUT, data, &reply); 227 } 228 229 virtual audio_io_handle_t getInput( 230 audio_source_t inputSource, 231 uint32_t samplingRate, 232 audio_format_t format, 233 audio_channel_mask_t channelMask, 234 int audioSession, 235 audio_input_flags_t flags) 236 { 237 Parcel data, reply; 238 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 239 data.writeInt32((int32_t) inputSource); 240 data.writeInt32(samplingRate); 241 data.writeInt32(static_cast <uint32_t>(format)); 242 data.writeInt32(channelMask); 243 data.writeInt32(audioSession); 244 data.writeInt32(flags); 245 remote()->transact(GET_INPUT, data, &reply); 246 return static_cast <audio_io_handle_t> (reply.readInt32()); 247 } 248 249 virtual status_t startInput(audio_io_handle_t input, 250 audio_session_t session) 251 { 252 Parcel data, reply; 253 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 254 data.writeInt32(input); 255 data.writeInt32(session); 256 remote()->transact(START_INPUT, data, &reply); 257 return static_cast <status_t> (reply.readInt32()); 258 } 259 260 virtual status_t stopInput(audio_io_handle_t input, 261 audio_session_t session) 262 { 263 Parcel data, reply; 264 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 265 data.writeInt32(input); 266 data.writeInt32(session); 267 remote()->transact(STOP_INPUT, data, &reply); 268 return static_cast <status_t> (reply.readInt32()); 269 } 270 271 virtual void releaseInput(audio_io_handle_t input, 272 audio_session_t session) 273 { 274 Parcel data, reply; 275 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 276 data.writeInt32(input); 277 data.writeInt32(session); 278 remote()->transact(RELEASE_INPUT, data, &reply); 279 } 280 281 virtual status_t initStreamVolume(audio_stream_type_t stream, 282 int indexMin, 283 int indexMax) 284 { 285 Parcel data, reply; 286 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 287 data.writeInt32(static_cast <uint32_t>(stream)); 288 data.writeInt32(indexMin); 289 data.writeInt32(indexMax); 290 remote()->transact(INIT_STREAM_VOLUME, data, &reply); 291 return static_cast <status_t> (reply.readInt32()); 292 } 293 294 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, 295 int index, 296 audio_devices_t device) 297 { 298 Parcel data, reply; 299 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 300 data.writeInt32(static_cast <uint32_t>(stream)); 301 data.writeInt32(index); 302 data.writeInt32(static_cast <uint32_t>(device)); 303 remote()->transact(SET_STREAM_VOLUME, data, &reply); 304 return static_cast <status_t> (reply.readInt32()); 305 } 306 307 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, 308 int *index, 309 audio_devices_t device) 310 { 311 Parcel data, reply; 312 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 313 data.writeInt32(static_cast <uint32_t>(stream)); 314 data.writeInt32(static_cast <uint32_t>(device)); 315 316 remote()->transact(GET_STREAM_VOLUME, data, &reply); 317 int lIndex = reply.readInt32(); 318 if (index) *index = lIndex; 319 return static_cast <status_t> (reply.readInt32()); 320 } 321 322 virtual uint32_t getStrategyForStream(audio_stream_type_t stream) 323 { 324 Parcel data, reply; 325 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 326 data.writeInt32(static_cast <uint32_t>(stream)); 327 remote()->transact(GET_STRATEGY_FOR_STREAM, data, &reply); 328 return reply.readInt32(); 329 } 330 331 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) 332 { 333 Parcel data, reply; 334 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 335 data.writeInt32(static_cast <uint32_t>(stream)); 336 remote()->transact(GET_DEVICES_FOR_STREAM, data, &reply); 337 return (audio_devices_t) reply.readInt32(); 338 } 339 340 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) 341 { 342 Parcel data, reply; 343 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 344 data.write(desc, sizeof(effect_descriptor_t)); 345 remote()->transact(GET_OUTPUT_FOR_EFFECT, data, &reply); 346 return static_cast <audio_io_handle_t> (reply.readInt32()); 347 } 348 349 virtual status_t registerEffect(const effect_descriptor_t *desc, 350 audio_io_handle_t io, 351 uint32_t strategy, 352 int session, 353 int id) 354 { 355 Parcel data, reply; 356 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 357 data.write(desc, sizeof(effect_descriptor_t)); 358 data.writeInt32(io); 359 data.writeInt32(strategy); 360 data.writeInt32(session); 361 data.writeInt32(id); 362 remote()->transact(REGISTER_EFFECT, data, &reply); 363 return static_cast <status_t> (reply.readInt32()); 364 } 365 366 virtual status_t unregisterEffect(int id) 367 { 368 Parcel data, reply; 369 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 370 data.writeInt32(id); 371 remote()->transact(UNREGISTER_EFFECT, data, &reply); 372 return static_cast <status_t> (reply.readInt32()); 373 } 374 375 virtual status_t setEffectEnabled(int id, bool enabled) 376 { 377 Parcel data, reply; 378 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 379 data.writeInt32(id); 380 data.writeInt32(enabled); 381 remote()->transact(SET_EFFECT_ENABLED, data, &reply); 382 return static_cast <status_t> (reply.readInt32()); 383 } 384 385 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const 386 { 387 Parcel data, reply; 388 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 389 data.writeInt32((int32_t) stream); 390 data.writeInt32(inPastMs); 391 remote()->transact(IS_STREAM_ACTIVE, data, &reply); 392 return reply.readInt32(); 393 } 394 395 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const 396 { 397 Parcel data, reply; 398 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 399 data.writeInt32((int32_t) stream); 400 data.writeInt32(inPastMs); 401 remote()->transact(IS_STREAM_ACTIVE_REMOTELY, data, &reply); 402 return reply.readInt32(); 403 } 404 405 virtual bool isSourceActive(audio_source_t source) const 406 { 407 Parcel data, reply; 408 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 409 data.writeInt32((int32_t) source); 410 remote()->transact(IS_SOURCE_ACTIVE, data, &reply); 411 return reply.readInt32(); 412 } 413 414 virtual status_t queryDefaultPreProcessing(int audioSession, 415 effect_descriptor_t *descriptors, 416 uint32_t *count) 417 { 418 if (descriptors == NULL || count == NULL) { 419 return BAD_VALUE; 420 } 421 Parcel data, reply; 422 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 423 data.writeInt32(audioSession); 424 data.writeInt32(*count); 425 status_t status = remote()->transact(QUERY_DEFAULT_PRE_PROCESSING, data, &reply); 426 if (status != NO_ERROR) { 427 return status; 428 } 429 status = static_cast <status_t> (reply.readInt32()); 430 uint32_t retCount = reply.readInt32(); 431 if (retCount != 0) { 432 uint32_t numDesc = (retCount < *count) ? retCount : *count; 433 reply.read(descriptors, sizeof(effect_descriptor_t) * numDesc); 434 } 435 *count = retCount; 436 return status; 437 } 438 439 virtual bool isOffloadSupported(const audio_offload_info_t& info) 440 { 441 Parcel data, reply; 442 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 443 data.write(&info, sizeof(audio_offload_info_t)); 444 remote()->transact(IS_OFFLOAD_SUPPORTED, data, &reply); 445 return reply.readInt32(); 446 } 447 448 virtual status_t listAudioPorts(audio_port_role_t role, 449 audio_port_type_t type, 450 unsigned int *num_ports, 451 struct audio_port *ports, 452 unsigned int *generation) 453 { 454 if (num_ports == NULL || (*num_ports != 0 && ports == NULL) || 455 generation == NULL) { 456 return BAD_VALUE; 457 } 458 Parcel data, reply; 459 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 460 unsigned int numPortsReq = (ports == NULL) ? 0 : *num_ports; 461 data.writeInt32(role); 462 data.writeInt32(type); 463 data.writeInt32(numPortsReq); 464 status_t status = remote()->transact(LIST_AUDIO_PORTS, data, &reply); 465 if (status == NO_ERROR) { 466 status = (status_t)reply.readInt32(); 467 *num_ports = (unsigned int)reply.readInt32(); 468 } 469 if (status == NO_ERROR) { 470 if (numPortsReq > *num_ports) { 471 numPortsReq = *num_ports; 472 } 473 if (numPortsReq > 0) { 474 reply.read(ports, numPortsReq * sizeof(struct audio_port)); 475 } 476 *generation = reply.readInt32(); 477 } 478 return status; 479 } 480 481 virtual status_t getAudioPort(struct audio_port *port) 482 { 483 if (port == NULL) { 484 return BAD_VALUE; 485 } 486 Parcel data, reply; 487 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 488 data.write(port, sizeof(struct audio_port)); 489 status_t status = remote()->transact(GET_AUDIO_PORT, data, &reply); 490 if (status != NO_ERROR || 491 (status = (status_t)reply.readInt32()) != NO_ERROR) { 492 return status; 493 } 494 reply.read(port, sizeof(struct audio_port)); 495 return status; 496 } 497 498 virtual status_t createAudioPatch(const struct audio_patch *patch, 499 audio_patch_handle_t *handle) 500 { 501 if (patch == NULL || handle == NULL) { 502 return BAD_VALUE; 503 } 504 Parcel data, reply; 505 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 506 data.write(patch, sizeof(struct audio_patch)); 507 data.write(handle, sizeof(audio_patch_handle_t)); 508 status_t status = remote()->transact(CREATE_AUDIO_PATCH, data, &reply); 509 if (status != NO_ERROR || 510 (status = (status_t)reply.readInt32()) != NO_ERROR) { 511 return status; 512 } 513 reply.read(handle, sizeof(audio_patch_handle_t)); 514 return status; 515 } 516 517 virtual status_t releaseAudioPatch(audio_patch_handle_t handle) 518 { 519 Parcel data, reply; 520 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 521 data.write(&handle, sizeof(audio_patch_handle_t)); 522 status_t status = remote()->transact(RELEASE_AUDIO_PATCH, data, &reply); 523 if (status != NO_ERROR) { 524 status = (status_t)reply.readInt32(); 525 } 526 return status; 527 } 528 529 virtual status_t listAudioPatches(unsigned int *num_patches, 530 struct audio_patch *patches, 531 unsigned int *generation) 532 { 533 if (num_patches == NULL || (*num_patches != 0 && patches == NULL) || 534 generation == NULL) { 535 return BAD_VALUE; 536 } 537 Parcel data, reply; 538 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 539 unsigned int numPatchesReq = (patches == NULL) ? 0 : *num_patches; 540 data.writeInt32(numPatchesReq); 541 status_t status = remote()->transact(LIST_AUDIO_PATCHES, data, &reply); 542 if (status == NO_ERROR) { 543 status = (status_t)reply.readInt32(); 544 *num_patches = (unsigned int)reply.readInt32(); 545 } 546 if (status == NO_ERROR) { 547 if (numPatchesReq > *num_patches) { 548 numPatchesReq = *num_patches; 549 } 550 if (numPatchesReq > 0) { 551 reply.read(patches, numPatchesReq * sizeof(struct audio_patch)); 552 } 553 *generation = reply.readInt32(); 554 } 555 return status; 556 } 557 558 virtual status_t setAudioPortConfig(const struct audio_port_config *config) 559 { 560 if (config == NULL) { 561 return BAD_VALUE; 562 } 563 Parcel data, reply; 564 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 565 data.write(config, sizeof(struct audio_port_config)); 566 status_t status = remote()->transact(SET_AUDIO_PORT_CONFIG, data, &reply); 567 if (status != NO_ERROR) { 568 status = (status_t)reply.readInt32(); 569 } 570 return status; 571 } 572 573 virtual void registerClient(const sp<IAudioPolicyServiceClient>& client) 574 { 575 Parcel data, reply; 576 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 577 data.writeStrongBinder(client->asBinder()); 578 remote()->transact(REGISTER_CLIENT, data, &reply); 579 } 580 581 virtual status_t acquireSoundTriggerSession(audio_session_t *session, 582 audio_io_handle_t *ioHandle, 583 audio_devices_t *device) 584 { 585 if (session == NULL || ioHandle == NULL || device == NULL) { 586 return BAD_VALUE; 587 } 588 Parcel data, reply; 589 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 590 status_t status = remote()->transact(ACQUIRE_SOUNDTRIGGER_SESSION, data, &reply); 591 if (status != NO_ERROR) { 592 return status; 593 } 594 status = (status_t)reply.readInt32(); 595 if (status == NO_ERROR) { 596 *session = (audio_session_t)reply.readInt32(); 597 *ioHandle = (audio_io_handle_t)reply.readInt32(); 598 *device = (audio_devices_t)reply.readInt32(); 599 } 600 return status; 601 } 602 603 virtual status_t releaseSoundTriggerSession(audio_session_t session) 604 { 605 Parcel data, reply; 606 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 607 data.writeInt32(session); 608 status_t status = remote()->transact(RELEASE_SOUNDTRIGGER_SESSION, data, &reply); 609 if (status != NO_ERROR) { 610 return status; 611 } 612 return (status_t)reply.readInt32(); 613 } 614 615 virtual audio_mode_t getPhoneState() 616 { 617 Parcel data, reply; 618 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 619 status_t status = remote()->transact(GET_PHONE_STATE, data, &reply); 620 if (status != NO_ERROR) { 621 return AUDIO_MODE_INVALID; 622 } 623 return (audio_mode_t)reply.readInt32(); 624 } 625}; 626 627IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService"); 628 629// ---------------------------------------------------------------------- 630 631 632status_t BnAudioPolicyService::onTransact( 633 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 634{ 635 switch (code) { 636 case SET_DEVICE_CONNECTION_STATE: { 637 CHECK_INTERFACE(IAudioPolicyService, data, reply); 638 audio_devices_t device = 639 static_cast <audio_devices_t>(data.readInt32()); 640 audio_policy_dev_state_t state = 641 static_cast <audio_policy_dev_state_t>(data.readInt32()); 642 const char *device_address = data.readCString(); 643 reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device, 644 state, 645 device_address))); 646 return NO_ERROR; 647 } break; 648 649 case GET_DEVICE_CONNECTION_STATE: { 650 CHECK_INTERFACE(IAudioPolicyService, data, reply); 651 audio_devices_t device = 652 static_cast<audio_devices_t> (data.readInt32()); 653 const char *device_address = data.readCString(); 654 reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device, 655 device_address))); 656 return NO_ERROR; 657 } break; 658 659 case SET_PHONE_STATE: { 660 CHECK_INTERFACE(IAudioPolicyService, data, reply); 661 reply->writeInt32(static_cast <uint32_t>(setPhoneState( 662 (audio_mode_t) data.readInt32()))); 663 return NO_ERROR; 664 } break; 665 666 case SET_FORCE_USE: { 667 CHECK_INTERFACE(IAudioPolicyService, data, reply); 668 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>( 669 data.readInt32()); 670 audio_policy_forced_cfg_t config = 671 static_cast <audio_policy_forced_cfg_t>(data.readInt32()); 672 reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config))); 673 return NO_ERROR; 674 } break; 675 676 case GET_FORCE_USE: { 677 CHECK_INTERFACE(IAudioPolicyService, data, reply); 678 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>( 679 data.readInt32()); 680 reply->writeInt32(static_cast <uint32_t>(getForceUse(usage))); 681 return NO_ERROR; 682 } break; 683 684 case GET_OUTPUT: { 685 CHECK_INTERFACE(IAudioPolicyService, data, reply); 686 audio_stream_type_t stream = 687 static_cast <audio_stream_type_t>(data.readInt32()); 688 uint32_t samplingRate = data.readInt32(); 689 audio_format_t format = (audio_format_t) data.readInt32(); 690 audio_channel_mask_t channelMask = data.readInt32(); 691 audio_output_flags_t flags = 692 static_cast <audio_output_flags_t>(data.readInt32()); 693 bool hasOffloadInfo = data.readInt32() != 0; 694 audio_offload_info_t offloadInfo; 695 if (hasOffloadInfo) { 696 data.read(&offloadInfo, sizeof(audio_offload_info_t)); 697 } 698 audio_io_handle_t output = getOutput(stream, 699 samplingRate, 700 format, 701 channelMask, 702 flags, 703 hasOffloadInfo ? &offloadInfo : NULL); 704 reply->writeInt32(static_cast <int>(output)); 705 return NO_ERROR; 706 } break; 707 708 case GET_OUTPUT_FOR_ATTR: { 709 CHECK_INTERFACE(IAudioPolicyService, data, reply); 710 audio_attributes_t *attr = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t)); 711 data.read(attr, sizeof(audio_attributes_t)); 712 uint32_t samplingRate = data.readInt32(); 713 audio_format_t format = (audio_format_t) data.readInt32(); 714 audio_channel_mask_t channelMask = data.readInt32(); 715 audio_output_flags_t flags = 716 static_cast <audio_output_flags_t>(data.readInt32()); 717 bool hasOffloadInfo = data.readInt32() != 0; 718 audio_offload_info_t offloadInfo; 719 if (hasOffloadInfo) { 720 data.read(&offloadInfo, sizeof(audio_offload_info_t)); 721 } 722 audio_io_handle_t output = getOutputForAttr(attr, 723 samplingRate, 724 format, 725 channelMask, 726 flags, 727 hasOffloadInfo ? &offloadInfo : NULL); 728 reply->writeInt32(static_cast <int>(output)); 729 return NO_ERROR; 730 } break; 731 732 case START_OUTPUT: { 733 CHECK_INTERFACE(IAudioPolicyService, data, reply); 734 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 735 audio_stream_type_t stream = 736 static_cast <audio_stream_type_t>(data.readInt32()); 737 int session = data.readInt32(); 738 reply->writeInt32(static_cast <uint32_t>(startOutput(output, 739 stream, 740 session))); 741 return NO_ERROR; 742 } break; 743 744 case STOP_OUTPUT: { 745 CHECK_INTERFACE(IAudioPolicyService, data, reply); 746 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 747 audio_stream_type_t stream = 748 static_cast <audio_stream_type_t>(data.readInt32()); 749 int session = data.readInt32(); 750 reply->writeInt32(static_cast <uint32_t>(stopOutput(output, 751 stream, 752 session))); 753 return NO_ERROR; 754 } break; 755 756 case RELEASE_OUTPUT: { 757 CHECK_INTERFACE(IAudioPolicyService, data, reply); 758 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 759 releaseOutput(output); 760 return NO_ERROR; 761 } break; 762 763 case GET_INPUT: { 764 CHECK_INTERFACE(IAudioPolicyService, data, reply); 765 audio_source_t inputSource = (audio_source_t) data.readInt32(); 766 uint32_t samplingRate = data.readInt32(); 767 audio_format_t format = (audio_format_t) data.readInt32(); 768 audio_channel_mask_t channelMask = data.readInt32(); 769 int audioSession = data.readInt32(); 770 audio_input_flags_t flags = (audio_input_flags_t) data.readInt32(); 771 audio_io_handle_t input = getInput(inputSource, 772 samplingRate, 773 format, 774 channelMask, 775 audioSession, 776 flags); 777 reply->writeInt32(static_cast <int>(input)); 778 return NO_ERROR; 779 } break; 780 781 case START_INPUT: { 782 CHECK_INTERFACE(IAudioPolicyService, data, reply); 783 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 784 audio_session_t session = static_cast <audio_session_t>(data.readInt32()); 785 reply->writeInt32(static_cast <uint32_t>(startInput(input, session))); 786 return NO_ERROR; 787 } break; 788 789 case STOP_INPUT: { 790 CHECK_INTERFACE(IAudioPolicyService, data, reply); 791 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 792 audio_session_t session = static_cast <audio_session_t>(data.readInt32()); 793 reply->writeInt32(static_cast <uint32_t>(stopInput(input, session))); 794 return NO_ERROR; 795 } break; 796 797 case RELEASE_INPUT: { 798 CHECK_INTERFACE(IAudioPolicyService, data, reply); 799 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 800 audio_session_t session = static_cast <audio_session_t>(data.readInt32()); 801 releaseInput(input, session); 802 return NO_ERROR; 803 } break; 804 805 case INIT_STREAM_VOLUME: { 806 CHECK_INTERFACE(IAudioPolicyService, data, reply); 807 audio_stream_type_t stream = 808 static_cast <audio_stream_type_t>(data.readInt32()); 809 int indexMin = data.readInt32(); 810 int indexMax = data.readInt32(); 811 reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax))); 812 return NO_ERROR; 813 } break; 814 815 case SET_STREAM_VOLUME: { 816 CHECK_INTERFACE(IAudioPolicyService, data, reply); 817 audio_stream_type_t stream = 818 static_cast <audio_stream_type_t>(data.readInt32()); 819 int index = data.readInt32(); 820 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 821 reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream, 822 index, 823 device))); 824 return NO_ERROR; 825 } break; 826 827 case GET_STREAM_VOLUME: { 828 CHECK_INTERFACE(IAudioPolicyService, data, reply); 829 audio_stream_type_t stream = 830 static_cast <audio_stream_type_t>(data.readInt32()); 831 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 832 int index; 833 status_t status = getStreamVolumeIndex(stream, &index, device); 834 reply->writeInt32(index); 835 reply->writeInt32(static_cast <uint32_t>(status)); 836 return NO_ERROR; 837 } break; 838 839 case GET_STRATEGY_FOR_STREAM: { 840 CHECK_INTERFACE(IAudioPolicyService, data, reply); 841 audio_stream_type_t stream = 842 static_cast <audio_stream_type_t>(data.readInt32()); 843 reply->writeInt32(getStrategyForStream(stream)); 844 return NO_ERROR; 845 } break; 846 847 case GET_DEVICES_FOR_STREAM: { 848 CHECK_INTERFACE(IAudioPolicyService, data, reply); 849 audio_stream_type_t stream = 850 static_cast <audio_stream_type_t>(data.readInt32()); 851 reply->writeInt32(static_cast <int>(getDevicesForStream(stream))); 852 return NO_ERROR; 853 } break; 854 855 case GET_OUTPUT_FOR_EFFECT: { 856 CHECK_INTERFACE(IAudioPolicyService, data, reply); 857 effect_descriptor_t desc; 858 data.read(&desc, sizeof(effect_descriptor_t)); 859 audio_io_handle_t output = getOutputForEffect(&desc); 860 reply->writeInt32(static_cast <int>(output)); 861 return NO_ERROR; 862 } break; 863 864 case REGISTER_EFFECT: { 865 CHECK_INTERFACE(IAudioPolicyService, data, reply); 866 effect_descriptor_t desc; 867 data.read(&desc, sizeof(effect_descriptor_t)); 868 audio_io_handle_t io = data.readInt32(); 869 uint32_t strategy = data.readInt32(); 870 int session = data.readInt32(); 871 int id = data.readInt32(); 872 reply->writeInt32(static_cast <int32_t>(registerEffect(&desc, 873 io, 874 strategy, 875 session, 876 id))); 877 return NO_ERROR; 878 } break; 879 880 case UNREGISTER_EFFECT: { 881 CHECK_INTERFACE(IAudioPolicyService, data, reply); 882 int id = data.readInt32(); 883 reply->writeInt32(static_cast <int32_t>(unregisterEffect(id))); 884 return NO_ERROR; 885 } break; 886 887 case SET_EFFECT_ENABLED: { 888 CHECK_INTERFACE(IAudioPolicyService, data, reply); 889 int id = data.readInt32(); 890 bool enabled = static_cast <bool>(data.readInt32()); 891 reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled))); 892 return NO_ERROR; 893 } break; 894 895 case IS_STREAM_ACTIVE: { 896 CHECK_INTERFACE(IAudioPolicyService, data, reply); 897 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 898 uint32_t inPastMs = (uint32_t)data.readInt32(); 899 reply->writeInt32( isStreamActive(stream, inPastMs) ); 900 return NO_ERROR; 901 } break; 902 903 case IS_STREAM_ACTIVE_REMOTELY: { 904 CHECK_INTERFACE(IAudioPolicyService, data, reply); 905 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 906 uint32_t inPastMs = (uint32_t)data.readInt32(); 907 reply->writeInt32( isStreamActiveRemotely(stream, inPastMs) ); 908 return NO_ERROR; 909 } break; 910 911 case IS_SOURCE_ACTIVE: { 912 CHECK_INTERFACE(IAudioPolicyService, data, reply); 913 audio_source_t source = (audio_source_t) data.readInt32(); 914 reply->writeInt32( isSourceActive(source)); 915 return NO_ERROR; 916 } 917 918 case QUERY_DEFAULT_PRE_PROCESSING: { 919 CHECK_INTERFACE(IAudioPolicyService, data, reply); 920 int audioSession = data.readInt32(); 921 uint32_t count = data.readInt32(); 922 if (count > AudioEffect::kMaxPreProcessing) { 923 count = AudioEffect::kMaxPreProcessing; 924 } 925 uint32_t retCount = count; 926 effect_descriptor_t *descriptors = new effect_descriptor_t[count]; 927 status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount); 928 reply->writeInt32(status); 929 if (status != NO_ERROR && status != NO_MEMORY) { 930 retCount = 0; 931 } 932 reply->writeInt32(retCount); 933 if (retCount != 0) { 934 if (retCount < count) { 935 count = retCount; 936 } 937 reply->write(descriptors, sizeof(effect_descriptor_t) * count); 938 } 939 delete[] descriptors; 940 return status; 941 } 942 943 case IS_OFFLOAD_SUPPORTED: { 944 CHECK_INTERFACE(IAudioPolicyService, data, reply); 945 audio_offload_info_t info; 946 data.read(&info, sizeof(audio_offload_info_t)); 947 bool isSupported = isOffloadSupported(info); 948 reply->writeInt32(isSupported); 949 return NO_ERROR; 950 } 951 952 case LIST_AUDIO_PORTS: { 953 CHECK_INTERFACE(IAudioPolicyService, data, reply); 954 audio_port_role_t role = (audio_port_role_t)data.readInt32(); 955 audio_port_type_t type = (audio_port_type_t)data.readInt32(); 956 unsigned int numPortsReq = data.readInt32(); 957 if (numPortsReq > MAX_ITEMS_PER_LIST) { 958 numPortsReq = MAX_ITEMS_PER_LIST; 959 } 960 unsigned int numPorts = numPortsReq; 961 struct audio_port *ports = 962 (struct audio_port *)calloc(numPortsReq, sizeof(struct audio_port)); 963 if (ports == NULL) { 964 reply->writeInt32(NO_MEMORY); 965 reply->writeInt32(0); 966 return NO_ERROR; 967 } 968 unsigned int generation; 969 status_t status = listAudioPorts(role, type, &numPorts, ports, &generation); 970 reply->writeInt32(status); 971 reply->writeInt32(numPorts); 972 973 if (status == NO_ERROR) { 974 if (numPortsReq > numPorts) { 975 numPortsReq = numPorts; 976 } 977 reply->write(ports, numPortsReq * sizeof(struct audio_port)); 978 reply->writeInt32(generation); 979 } 980 free(ports); 981 return NO_ERROR; 982 } 983 984 case GET_AUDIO_PORT: { 985 CHECK_INTERFACE(IAudioPolicyService, data, reply); 986 struct audio_port port; 987 data.read(&port, sizeof(struct audio_port)); 988 status_t status = getAudioPort(&port); 989 reply->writeInt32(status); 990 if (status == NO_ERROR) { 991 reply->write(&port, sizeof(struct audio_port)); 992 } 993 return NO_ERROR; 994 } 995 996 case CREATE_AUDIO_PATCH: { 997 CHECK_INTERFACE(IAudioPolicyService, data, reply); 998 struct audio_patch patch; 999 data.read(&patch, sizeof(struct audio_patch)); 1000 audio_patch_handle_t handle; 1001 data.read(&handle, sizeof(audio_patch_handle_t)); 1002 status_t status = createAudioPatch(&patch, &handle); 1003 reply->writeInt32(status); 1004 if (status == NO_ERROR) { 1005 reply->write(&handle, sizeof(audio_patch_handle_t)); 1006 } 1007 return NO_ERROR; 1008 } 1009 1010 case RELEASE_AUDIO_PATCH: { 1011 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1012 audio_patch_handle_t handle; 1013 data.read(&handle, sizeof(audio_patch_handle_t)); 1014 status_t status = releaseAudioPatch(handle); 1015 reply->writeInt32(status); 1016 return NO_ERROR; 1017 } 1018 1019 case LIST_AUDIO_PATCHES: { 1020 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1021 unsigned int numPatchesReq = data.readInt32(); 1022 if (numPatchesReq > MAX_ITEMS_PER_LIST) { 1023 numPatchesReq = MAX_ITEMS_PER_LIST; 1024 } 1025 unsigned int numPatches = numPatchesReq; 1026 struct audio_patch *patches = 1027 (struct audio_patch *)calloc(numPatchesReq, 1028 sizeof(struct audio_patch)); 1029 if (patches == NULL) { 1030 reply->writeInt32(NO_MEMORY); 1031 reply->writeInt32(0); 1032 return NO_ERROR; 1033 } 1034 unsigned int generation; 1035 status_t status = listAudioPatches(&numPatches, patches, &generation); 1036 reply->writeInt32(status); 1037 reply->writeInt32(numPatches); 1038 if (status == NO_ERROR) { 1039 if (numPatchesReq > numPatches) { 1040 numPatchesReq = numPatches; 1041 } 1042 reply->write(patches, numPatchesReq * sizeof(struct audio_patch)); 1043 reply->writeInt32(generation); 1044 } 1045 free(patches); 1046 return NO_ERROR; 1047 } 1048 1049 case SET_AUDIO_PORT_CONFIG: { 1050 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1051 struct audio_port_config config; 1052 data.read(&config, sizeof(struct audio_port_config)); 1053 status_t status = setAudioPortConfig(&config); 1054 reply->writeInt32(status); 1055 return NO_ERROR; 1056 } 1057 1058 case REGISTER_CLIENT: { 1059 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1060 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1061 data.readStrongBinder()); 1062 registerClient(client); 1063 return NO_ERROR; 1064 } break; 1065 1066 case ACQUIRE_SOUNDTRIGGER_SESSION: { 1067 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1068 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1069 data.readStrongBinder()); 1070 audio_session_t session; 1071 audio_io_handle_t ioHandle; 1072 audio_devices_t device; 1073 status_t status = acquireSoundTriggerSession(&session, &ioHandle, &device); 1074 reply->writeInt32(status); 1075 if (status == NO_ERROR) { 1076 reply->writeInt32(session); 1077 reply->writeInt32(ioHandle); 1078 reply->writeInt32(device); 1079 } 1080 return NO_ERROR; 1081 } break; 1082 1083 case RELEASE_SOUNDTRIGGER_SESSION: { 1084 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1085 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1086 data.readStrongBinder()); 1087 audio_session_t session = (audio_session_t)data.readInt32(); 1088 status_t status = releaseSoundTriggerSession(session); 1089 reply->writeInt32(status); 1090 return NO_ERROR; 1091 } break; 1092 1093 case GET_PHONE_STATE: { 1094 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1095 reply->writeInt32((int32_t)getPhoneState()); 1096 return NO_ERROR; 1097 } break; 1098 1099 default: 1100 return BBinder::onTransact(code, data, reply, flags); 1101 } 1102} 1103 1104// ---------------------------------------------------------------------------- 1105 1106}; // namespace android 1107