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