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