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