IAudioPolicyService.cpp revision b3b1660ecb67f61f9da54efced8677fa3a6f4863
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 { 245 Parcel data, reply; 246 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 247 data.writeInt32(input); 248 remote()->transact(START_INPUT, data, &reply); 249 return static_cast <status_t> (reply.readInt32()); 250 } 251 252 virtual status_t stopInput(audio_io_handle_t input) 253 { 254 Parcel data, reply; 255 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 256 data.writeInt32(input); 257 remote()->transact(STOP_INPUT, data, &reply); 258 return static_cast <status_t> (reply.readInt32()); 259 } 260 261 virtual void releaseInput(audio_io_handle_t input) 262 { 263 Parcel data, reply; 264 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 265 data.writeInt32(input); 266 remote()->transact(RELEASE_INPUT, data, &reply); 267 } 268 269 virtual status_t initStreamVolume(audio_stream_type_t stream, 270 int indexMin, 271 int indexMax) 272 { 273 Parcel data, reply; 274 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 275 data.writeInt32(static_cast <uint32_t>(stream)); 276 data.writeInt32(indexMin); 277 data.writeInt32(indexMax); 278 remote()->transact(INIT_STREAM_VOLUME, data, &reply); 279 return static_cast <status_t> (reply.readInt32()); 280 } 281 282 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, 283 int index, 284 audio_devices_t device) 285 { 286 Parcel data, reply; 287 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 288 data.writeInt32(static_cast <uint32_t>(stream)); 289 data.writeInt32(index); 290 data.writeInt32(static_cast <uint32_t>(device)); 291 remote()->transact(SET_STREAM_VOLUME, data, &reply); 292 return static_cast <status_t> (reply.readInt32()); 293 } 294 295 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, 296 int *index, 297 audio_devices_t device) 298 { 299 Parcel data, reply; 300 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 301 data.writeInt32(static_cast <uint32_t>(stream)); 302 data.writeInt32(static_cast <uint32_t>(device)); 303 304 remote()->transact(GET_STREAM_VOLUME, data, &reply); 305 int lIndex = reply.readInt32(); 306 if (index) *index = lIndex; 307 return static_cast <status_t> (reply.readInt32()); 308 } 309 310 virtual uint32_t getStrategyForStream(audio_stream_type_t stream) 311 { 312 Parcel data, reply; 313 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 314 data.writeInt32(static_cast <uint32_t>(stream)); 315 remote()->transact(GET_STRATEGY_FOR_STREAM, data, &reply); 316 return reply.readInt32(); 317 } 318 319 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) 320 { 321 Parcel data, reply; 322 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 323 data.writeInt32(static_cast <uint32_t>(stream)); 324 remote()->transact(GET_DEVICES_FOR_STREAM, data, &reply); 325 return (audio_devices_t) reply.readInt32(); 326 } 327 328 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) 329 { 330 Parcel data, reply; 331 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 332 data.write(desc, sizeof(effect_descriptor_t)); 333 remote()->transact(GET_OUTPUT_FOR_EFFECT, data, &reply); 334 return static_cast <audio_io_handle_t> (reply.readInt32()); 335 } 336 337 virtual status_t registerEffect(const effect_descriptor_t *desc, 338 audio_io_handle_t io, 339 uint32_t strategy, 340 int session, 341 int id) 342 { 343 Parcel data, reply; 344 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 345 data.write(desc, sizeof(effect_descriptor_t)); 346 data.writeInt32(io); 347 data.writeInt32(strategy); 348 data.writeInt32(session); 349 data.writeInt32(id); 350 remote()->transact(REGISTER_EFFECT, data, &reply); 351 return static_cast <status_t> (reply.readInt32()); 352 } 353 354 virtual status_t unregisterEffect(int id) 355 { 356 Parcel data, reply; 357 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 358 data.writeInt32(id); 359 remote()->transact(UNREGISTER_EFFECT, data, &reply); 360 return static_cast <status_t> (reply.readInt32()); 361 } 362 363 virtual status_t setEffectEnabled(int id, bool enabled) 364 { 365 Parcel data, reply; 366 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 367 data.writeInt32(id); 368 data.writeInt32(enabled); 369 remote()->transact(SET_EFFECT_ENABLED, data, &reply); 370 return static_cast <status_t> (reply.readInt32()); 371 } 372 373 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const 374 { 375 Parcel data, reply; 376 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 377 data.writeInt32((int32_t) stream); 378 data.writeInt32(inPastMs); 379 remote()->transact(IS_STREAM_ACTIVE, data, &reply); 380 return reply.readInt32(); 381 } 382 383 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const 384 { 385 Parcel data, reply; 386 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 387 data.writeInt32((int32_t) stream); 388 data.writeInt32(inPastMs); 389 remote()->transact(IS_STREAM_ACTIVE_REMOTELY, data, &reply); 390 return reply.readInt32(); 391 } 392 393 virtual bool isSourceActive(audio_source_t source) const 394 { 395 Parcel data, reply; 396 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 397 data.writeInt32((int32_t) source); 398 remote()->transact(IS_SOURCE_ACTIVE, data, &reply); 399 return reply.readInt32(); 400 } 401 402 virtual status_t queryDefaultPreProcessing(int audioSession, 403 effect_descriptor_t *descriptors, 404 uint32_t *count) 405 { 406 if (descriptors == NULL || count == NULL) { 407 return BAD_VALUE; 408 } 409 Parcel data, reply; 410 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 411 data.writeInt32(audioSession); 412 data.writeInt32(*count); 413 status_t status = remote()->transact(QUERY_DEFAULT_PRE_PROCESSING, data, &reply); 414 if (status != NO_ERROR) { 415 return status; 416 } 417 status = static_cast <status_t> (reply.readInt32()); 418 uint32_t retCount = reply.readInt32(); 419 if (retCount != 0) { 420 uint32_t numDesc = (retCount < *count) ? retCount : *count; 421 reply.read(descriptors, sizeof(effect_descriptor_t) * numDesc); 422 } 423 *count = retCount; 424 return status; 425 } 426 427 virtual bool isOffloadSupported(const audio_offload_info_t& info) 428 { 429 Parcel data, reply; 430 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 431 data.write(&info, sizeof(audio_offload_info_t)); 432 remote()->transact(IS_OFFLOAD_SUPPORTED, data, &reply); 433 return reply.readInt32(); 434 } 435 436 virtual status_t listAudioPorts(audio_port_role_t role, 437 audio_port_type_t type, 438 unsigned int *num_ports, 439 struct audio_port *ports, 440 unsigned int *generation) 441 { 442 if (num_ports == NULL || (*num_ports != 0 && ports == NULL) || 443 generation == NULL) { 444 return BAD_VALUE; 445 } 446 Parcel data, reply; 447 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 448 unsigned int numPortsReq = (ports == NULL) ? 0 : *num_ports; 449 data.writeInt32(role); 450 data.writeInt32(type); 451 data.writeInt32(numPortsReq); 452 status_t status = remote()->transact(LIST_AUDIO_PORTS, data, &reply); 453 if (status == NO_ERROR) { 454 status = (status_t)reply.readInt32(); 455 *num_ports = (unsigned int)reply.readInt32(); 456 } 457 if (status == NO_ERROR) { 458 if (numPortsReq > *num_ports) { 459 numPortsReq = *num_ports; 460 } 461 if (numPortsReq > 0) { 462 reply.read(ports, numPortsReq * sizeof(struct audio_port)); 463 } 464 *generation = reply.readInt32(); 465 } 466 return status; 467 } 468 469 virtual status_t getAudioPort(struct audio_port *port) 470 { 471 if (port == NULL) { 472 return BAD_VALUE; 473 } 474 Parcel data, reply; 475 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 476 data.write(port, sizeof(struct audio_port)); 477 status_t status = remote()->transact(GET_AUDIO_PORT, data, &reply); 478 if (status != NO_ERROR || 479 (status = (status_t)reply.readInt32()) != NO_ERROR) { 480 return status; 481 } 482 reply.read(port, sizeof(struct audio_port)); 483 return status; 484 } 485 486 virtual status_t createAudioPatch(const struct audio_patch *patch, 487 audio_patch_handle_t *handle) 488 { 489 if (patch == NULL || handle == NULL) { 490 return BAD_VALUE; 491 } 492 Parcel data, reply; 493 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 494 data.write(patch, sizeof(struct audio_patch)); 495 data.write(handle, sizeof(audio_patch_handle_t)); 496 status_t status = remote()->transact(CREATE_AUDIO_PATCH, data, &reply); 497 if (status != NO_ERROR || 498 (status = (status_t)reply.readInt32()) != NO_ERROR) { 499 return status; 500 } 501 reply.read(handle, sizeof(audio_patch_handle_t)); 502 return status; 503 } 504 505 virtual status_t releaseAudioPatch(audio_patch_handle_t handle) 506 { 507 Parcel data, reply; 508 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 509 data.write(&handle, sizeof(audio_patch_handle_t)); 510 status_t status = remote()->transact(RELEASE_AUDIO_PATCH, data, &reply); 511 if (status != NO_ERROR) { 512 status = (status_t)reply.readInt32(); 513 } 514 return status; 515 } 516 517 virtual status_t listAudioPatches(unsigned int *num_patches, 518 struct audio_patch *patches, 519 unsigned int *generation) 520 { 521 if (num_patches == NULL || (*num_patches != 0 && patches == NULL) || 522 generation == NULL) { 523 return BAD_VALUE; 524 } 525 Parcel data, reply; 526 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 527 unsigned int numPatchesReq = (patches == NULL) ? 0 : *num_patches; 528 data.writeInt32(numPatchesReq); 529 status_t status = remote()->transact(LIST_AUDIO_PATCHES, data, &reply); 530 if (status == NO_ERROR) { 531 status = (status_t)reply.readInt32(); 532 *num_patches = (unsigned int)reply.readInt32(); 533 } 534 if (status == NO_ERROR) { 535 if (numPatchesReq > *num_patches) { 536 numPatchesReq = *num_patches; 537 } 538 if (numPatchesReq > 0) { 539 reply.read(patches, numPatchesReq * sizeof(struct audio_patch)); 540 } 541 *generation = reply.readInt32(); 542 } 543 return status; 544 } 545 546 virtual status_t setAudioPortConfig(const struct audio_port_config *config) 547 { 548 if (config == NULL) { 549 return BAD_VALUE; 550 } 551 Parcel data, reply; 552 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 553 data.write(config, sizeof(struct audio_port_config)); 554 status_t status = remote()->transact(SET_AUDIO_PORT_CONFIG, data, &reply); 555 if (status != NO_ERROR) { 556 status = (status_t)reply.readInt32(); 557 } 558 return status; 559 } 560 virtual void registerClient(const sp<IAudioPolicyServiceClient>& client) 561 { 562 Parcel data, reply; 563 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 564 data.writeStrongBinder(client->asBinder()); 565 remote()->transact(REGISTER_CLIENT, data, &reply); 566 } 567}; 568 569IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService"); 570 571// ---------------------------------------------------------------------- 572 573 574status_t BnAudioPolicyService::onTransact( 575 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 576{ 577 switch (code) { 578 case SET_DEVICE_CONNECTION_STATE: { 579 CHECK_INTERFACE(IAudioPolicyService, data, reply); 580 audio_devices_t device = 581 static_cast <audio_devices_t>(data.readInt32()); 582 audio_policy_dev_state_t state = 583 static_cast <audio_policy_dev_state_t>(data.readInt32()); 584 const char *device_address = data.readCString(); 585 reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device, 586 state, 587 device_address))); 588 return NO_ERROR; 589 } break; 590 591 case GET_DEVICE_CONNECTION_STATE: { 592 CHECK_INTERFACE(IAudioPolicyService, data, reply); 593 audio_devices_t device = 594 static_cast<audio_devices_t> (data.readInt32()); 595 const char *device_address = data.readCString(); 596 reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device, 597 device_address))); 598 return NO_ERROR; 599 } break; 600 601 case SET_PHONE_STATE: { 602 CHECK_INTERFACE(IAudioPolicyService, data, reply); 603 reply->writeInt32(static_cast <uint32_t>(setPhoneState( 604 (audio_mode_t) data.readInt32()))); 605 return NO_ERROR; 606 } break; 607 608 case SET_FORCE_USE: { 609 CHECK_INTERFACE(IAudioPolicyService, data, reply); 610 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>( 611 data.readInt32()); 612 audio_policy_forced_cfg_t config = 613 static_cast <audio_policy_forced_cfg_t>(data.readInt32()); 614 reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config))); 615 return NO_ERROR; 616 } break; 617 618 case GET_FORCE_USE: { 619 CHECK_INTERFACE(IAudioPolicyService, data, reply); 620 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>( 621 data.readInt32()); 622 reply->writeInt32(static_cast <uint32_t>(getForceUse(usage))); 623 return NO_ERROR; 624 } break; 625 626 case GET_OUTPUT: { 627 CHECK_INTERFACE(IAudioPolicyService, data, reply); 628 audio_stream_type_t stream = 629 static_cast <audio_stream_type_t>(data.readInt32()); 630 uint32_t samplingRate = data.readInt32(); 631 audio_format_t format = (audio_format_t) data.readInt32(); 632 audio_channel_mask_t channelMask = data.readInt32(); 633 audio_output_flags_t flags = 634 static_cast <audio_output_flags_t>(data.readInt32()); 635 bool hasOffloadInfo = data.readInt32() != 0; 636 audio_offload_info_t offloadInfo; 637 if (hasOffloadInfo) { 638 data.read(&offloadInfo, sizeof(audio_offload_info_t)); 639 } 640 audio_io_handle_t output = getOutput(stream, 641 samplingRate, 642 format, 643 channelMask, 644 flags, 645 hasOffloadInfo ? &offloadInfo : NULL); 646 reply->writeInt32(static_cast <int>(output)); 647 return NO_ERROR; 648 } break; 649 650 case GET_OUTPUT_FOR_ATTR: { 651 CHECK_INTERFACE(IAudioPolicyService, data, reply); 652 audio_attributes_t *attr = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t)); 653 data.read(attr, sizeof(audio_attributes_t)); 654 uint32_t samplingRate = data.readInt32(); 655 audio_format_t format = (audio_format_t) data.readInt32(); 656 audio_channel_mask_t channelMask = data.readInt32(); 657 audio_output_flags_t flags = 658 static_cast <audio_output_flags_t>(data.readInt32()); 659 bool hasOffloadInfo = data.readInt32() != 0; 660 audio_offload_info_t offloadInfo; 661 if (hasOffloadInfo) { 662 data.read(&offloadInfo, sizeof(audio_offload_info_t)); 663 } 664 audio_io_handle_t output = getOutputForAttr(attr, 665 samplingRate, 666 format, 667 channelMask, 668 flags, 669 hasOffloadInfo ? &offloadInfo : NULL); 670 reply->writeInt32(static_cast <int>(output)); 671 return NO_ERROR; 672 } break; 673 674 case START_OUTPUT: { 675 CHECK_INTERFACE(IAudioPolicyService, data, reply); 676 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 677 audio_stream_type_t stream = 678 static_cast <audio_stream_type_t>(data.readInt32()); 679 int session = data.readInt32(); 680 reply->writeInt32(static_cast <uint32_t>(startOutput(output, 681 stream, 682 session))); 683 return NO_ERROR; 684 } break; 685 686 case STOP_OUTPUT: { 687 CHECK_INTERFACE(IAudioPolicyService, data, reply); 688 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 689 audio_stream_type_t stream = 690 static_cast <audio_stream_type_t>(data.readInt32()); 691 int session = data.readInt32(); 692 reply->writeInt32(static_cast <uint32_t>(stopOutput(output, 693 stream, 694 session))); 695 return NO_ERROR; 696 } break; 697 698 case RELEASE_OUTPUT: { 699 CHECK_INTERFACE(IAudioPolicyService, data, reply); 700 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 701 releaseOutput(output); 702 return NO_ERROR; 703 } break; 704 705 case GET_INPUT: { 706 CHECK_INTERFACE(IAudioPolicyService, data, reply); 707 audio_source_t inputSource = (audio_source_t) data.readInt32(); 708 uint32_t samplingRate = data.readInt32(); 709 audio_format_t format = (audio_format_t) data.readInt32(); 710 audio_channel_mask_t channelMask = data.readInt32(); 711 int audioSession = data.readInt32(); 712 audio_input_flags_t flags = (audio_input_flags_t) data.readInt32(); 713 audio_io_handle_t input = getInput(inputSource, 714 samplingRate, 715 format, 716 channelMask, 717 audioSession, 718 flags); 719 reply->writeInt32(static_cast <int>(input)); 720 return NO_ERROR; 721 } break; 722 723 case START_INPUT: { 724 CHECK_INTERFACE(IAudioPolicyService, data, reply); 725 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 726 reply->writeInt32(static_cast <uint32_t>(startInput(input))); 727 return NO_ERROR; 728 } break; 729 730 case STOP_INPUT: { 731 CHECK_INTERFACE(IAudioPolicyService, data, reply); 732 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 733 reply->writeInt32(static_cast <uint32_t>(stopInput(input))); 734 return NO_ERROR; 735 } break; 736 737 case RELEASE_INPUT: { 738 CHECK_INTERFACE(IAudioPolicyService, data, reply); 739 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 740 releaseInput(input); 741 return NO_ERROR; 742 } break; 743 744 case INIT_STREAM_VOLUME: { 745 CHECK_INTERFACE(IAudioPolicyService, data, reply); 746 audio_stream_type_t stream = 747 static_cast <audio_stream_type_t>(data.readInt32()); 748 int indexMin = data.readInt32(); 749 int indexMax = data.readInt32(); 750 reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax))); 751 return NO_ERROR; 752 } break; 753 754 case SET_STREAM_VOLUME: { 755 CHECK_INTERFACE(IAudioPolicyService, data, reply); 756 audio_stream_type_t stream = 757 static_cast <audio_stream_type_t>(data.readInt32()); 758 int index = data.readInt32(); 759 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 760 reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream, 761 index, 762 device))); 763 return NO_ERROR; 764 } break; 765 766 case GET_STREAM_VOLUME: { 767 CHECK_INTERFACE(IAudioPolicyService, data, reply); 768 audio_stream_type_t stream = 769 static_cast <audio_stream_type_t>(data.readInt32()); 770 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 771 int index; 772 status_t status = getStreamVolumeIndex(stream, &index, device); 773 reply->writeInt32(index); 774 reply->writeInt32(static_cast <uint32_t>(status)); 775 return NO_ERROR; 776 } break; 777 778 case GET_STRATEGY_FOR_STREAM: { 779 CHECK_INTERFACE(IAudioPolicyService, data, reply); 780 audio_stream_type_t stream = 781 static_cast <audio_stream_type_t>(data.readInt32()); 782 reply->writeInt32(getStrategyForStream(stream)); 783 return NO_ERROR; 784 } break; 785 786 case GET_DEVICES_FOR_STREAM: { 787 CHECK_INTERFACE(IAudioPolicyService, data, reply); 788 audio_stream_type_t stream = 789 static_cast <audio_stream_type_t>(data.readInt32()); 790 reply->writeInt32(static_cast <int>(getDevicesForStream(stream))); 791 return NO_ERROR; 792 } break; 793 794 case GET_OUTPUT_FOR_EFFECT: { 795 CHECK_INTERFACE(IAudioPolicyService, data, reply); 796 effect_descriptor_t desc; 797 data.read(&desc, sizeof(effect_descriptor_t)); 798 audio_io_handle_t output = getOutputForEffect(&desc); 799 reply->writeInt32(static_cast <int>(output)); 800 return NO_ERROR; 801 } break; 802 803 case REGISTER_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 io = data.readInt32(); 808 uint32_t strategy = data.readInt32(); 809 int session = data.readInt32(); 810 int id = data.readInt32(); 811 reply->writeInt32(static_cast <int32_t>(registerEffect(&desc, 812 io, 813 strategy, 814 session, 815 id))); 816 return NO_ERROR; 817 } break; 818 819 case UNREGISTER_EFFECT: { 820 CHECK_INTERFACE(IAudioPolicyService, data, reply); 821 int id = data.readInt32(); 822 reply->writeInt32(static_cast <int32_t>(unregisterEffect(id))); 823 return NO_ERROR; 824 } break; 825 826 case SET_EFFECT_ENABLED: { 827 CHECK_INTERFACE(IAudioPolicyService, data, reply); 828 int id = data.readInt32(); 829 bool enabled = static_cast <bool>(data.readInt32()); 830 reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled))); 831 return NO_ERROR; 832 } break; 833 834 case IS_STREAM_ACTIVE: { 835 CHECK_INTERFACE(IAudioPolicyService, data, reply); 836 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 837 uint32_t inPastMs = (uint32_t)data.readInt32(); 838 reply->writeInt32( isStreamActive(stream, inPastMs) ); 839 return NO_ERROR; 840 } break; 841 842 case IS_STREAM_ACTIVE_REMOTELY: { 843 CHECK_INTERFACE(IAudioPolicyService, data, reply); 844 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 845 uint32_t inPastMs = (uint32_t)data.readInt32(); 846 reply->writeInt32( isStreamActiveRemotely(stream, inPastMs) ); 847 return NO_ERROR; 848 } break; 849 850 case IS_SOURCE_ACTIVE: { 851 CHECK_INTERFACE(IAudioPolicyService, data, reply); 852 audio_source_t source = (audio_source_t) data.readInt32(); 853 reply->writeInt32( isSourceActive(source)); 854 return NO_ERROR; 855 } 856 857 case QUERY_DEFAULT_PRE_PROCESSING: { 858 CHECK_INTERFACE(IAudioPolicyService, data, reply); 859 int audioSession = data.readInt32(); 860 uint32_t count = data.readInt32(); 861 uint32_t retCount = count; 862 effect_descriptor_t *descriptors = 863 (effect_descriptor_t *)new char[count * sizeof(effect_descriptor_t)]; 864 status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount); 865 reply->writeInt32(status); 866 if (status != NO_ERROR && status != NO_MEMORY) { 867 retCount = 0; 868 } 869 reply->writeInt32(retCount); 870 if (retCount) { 871 if (retCount < count) { 872 count = retCount; 873 } 874 reply->write(descriptors, sizeof(effect_descriptor_t) * count); 875 } 876 delete[] descriptors; 877 return status; 878 } 879 880 case IS_OFFLOAD_SUPPORTED: { 881 CHECK_INTERFACE(IAudioPolicyService, data, reply); 882 audio_offload_info_t info; 883 data.read(&info, sizeof(audio_offload_info_t)); 884 bool isSupported = isOffloadSupported(info); 885 reply->writeInt32(isSupported); 886 return NO_ERROR; 887 } 888 889 case LIST_AUDIO_PORTS: { 890 CHECK_INTERFACE(IAudioPolicyService, data, reply); 891 audio_port_role_t role = (audio_port_role_t)data.readInt32(); 892 audio_port_type_t type = (audio_port_type_t)data.readInt32(); 893 unsigned int numPortsReq = data.readInt32(); 894 unsigned int numPorts = numPortsReq; 895 unsigned int generation; 896 struct audio_port *ports = 897 (struct audio_port *)calloc(numPortsReq, sizeof(struct audio_port)); 898 status_t status = listAudioPorts(role, type, &numPorts, ports, &generation); 899 reply->writeInt32(status); 900 reply->writeInt32(numPorts); 901 902 if (status == NO_ERROR) { 903 if (numPortsReq > numPorts) { 904 numPortsReq = numPorts; 905 } 906 reply->write(ports, numPortsReq * sizeof(struct audio_port)); 907 reply->writeInt32(generation); 908 } 909 free(ports); 910 return NO_ERROR; 911 } 912 913 case GET_AUDIO_PORT: { 914 CHECK_INTERFACE(IAudioPolicyService, data, reply); 915 struct audio_port port; 916 data.read(&port, sizeof(struct audio_port)); 917 status_t status = getAudioPort(&port); 918 reply->writeInt32(status); 919 if (status == NO_ERROR) { 920 reply->write(&port, sizeof(struct audio_port)); 921 } 922 return NO_ERROR; 923 } 924 925 case CREATE_AUDIO_PATCH: { 926 CHECK_INTERFACE(IAudioPolicyService, data, reply); 927 struct audio_patch patch; 928 data.read(&patch, sizeof(struct audio_patch)); 929 audio_patch_handle_t handle; 930 data.read(&handle, sizeof(audio_patch_handle_t)); 931 status_t status = createAudioPatch(&patch, &handle); 932 reply->writeInt32(status); 933 if (status == NO_ERROR) { 934 reply->write(&handle, sizeof(audio_patch_handle_t)); 935 } 936 return NO_ERROR; 937 } 938 939 case RELEASE_AUDIO_PATCH: { 940 CHECK_INTERFACE(IAudioPolicyService, data, reply); 941 audio_patch_handle_t handle; 942 data.read(&handle, sizeof(audio_patch_handle_t)); 943 status_t status = releaseAudioPatch(handle); 944 reply->writeInt32(status); 945 return NO_ERROR; 946 } 947 948 case LIST_AUDIO_PATCHES: { 949 CHECK_INTERFACE(IAudioPolicyService, data, reply); 950 unsigned int numPatchesReq = data.readInt32(); 951 unsigned int numPatches = numPatchesReq; 952 unsigned int generation; 953 struct audio_patch *patches = 954 (struct audio_patch *)calloc(numPatchesReq, 955 sizeof(struct audio_patch)); 956 status_t status = listAudioPatches(&numPatches, patches, &generation); 957 reply->writeInt32(status); 958 reply->writeInt32(numPatches); 959 if (status == NO_ERROR) { 960 if (numPatchesReq > numPatches) { 961 numPatchesReq = numPatches; 962 } 963 reply->write(patches, numPatchesReq * sizeof(struct audio_patch)); 964 reply->writeInt32(generation); 965 } 966 free(patches); 967 return NO_ERROR; 968 } 969 970 case SET_AUDIO_PORT_CONFIG: { 971 CHECK_INTERFACE(IAudioPolicyService, data, reply); 972 struct audio_port_config config; 973 data.read(&config, sizeof(struct audio_port_config)); 974 status_t status = setAudioPortConfig(&config); 975 reply->writeInt32(status); 976 return NO_ERROR; 977 } 978 case REGISTER_CLIENT: { 979 CHECK_INTERFACE(IAudioPolicyService, data, reply); 980 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 981 data.readStrongBinder()); 982 registerClient(client); 983 return NO_ERROR; 984 } break; 985 986 default: 987 return BBinder::onTransact(code, data, reply, flags); 988 } 989} 990 991// ---------------------------------------------------------------------------- 992 993}; // namespace android 994