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 30 namespace android { 31 32 enum { 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 }; 61 62 class BpAudioPolicyService : public BpInterface<IAudioPolicyService> 63 { 64 public: 65 BpAudioPolicyService(const sp<IBinder>& impl) 66 : BpInterface<IAudioPolicyService>(impl) 67 { 68 } 69 70 virtual status_t setDeviceConnectionState( 71 audio_devices_t device, 72 audio_policy_dev_state_t state, 73 const char *device_address) 74 { 75 Parcel data, reply; 76 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 77 data.writeInt32(static_cast <uint32_t>(device)); 78 data.writeInt32(static_cast <uint32_t>(state)); 79 data.writeCString(device_address); 80 remote()->transact(SET_DEVICE_CONNECTION_STATE, data, &reply); 81 return static_cast <status_t> (reply.readInt32()); 82 } 83 84 virtual audio_policy_dev_state_t getDeviceConnectionState( 85 audio_devices_t device, 86 const char *device_address) 87 { 88 Parcel data, reply; 89 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 90 data.writeInt32(static_cast <uint32_t>(device)); 91 data.writeCString(device_address); 92 remote()->transact(GET_DEVICE_CONNECTION_STATE, data, &reply); 93 return static_cast <audio_policy_dev_state_t>(reply.readInt32()); 94 } 95 96 virtual status_t setPhoneState(audio_mode_t state) 97 { 98 Parcel data, reply; 99 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 100 data.writeInt32(state); 101 remote()->transact(SET_PHONE_STATE, data, &reply); 102 return static_cast <status_t> (reply.readInt32()); 103 } 104 105 virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) 106 { 107 Parcel data, reply; 108 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 109 data.writeInt32(static_cast <uint32_t>(usage)); 110 data.writeInt32(static_cast <uint32_t>(config)); 111 remote()->transact(SET_FORCE_USE, data, &reply); 112 return static_cast <status_t> (reply.readInt32()); 113 } 114 115 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) 116 { 117 Parcel data, reply; 118 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 119 data.writeInt32(static_cast <uint32_t>(usage)); 120 remote()->transact(GET_FORCE_USE, data, &reply); 121 return static_cast <audio_policy_forced_cfg_t> (reply.readInt32()); 122 } 123 124 virtual audio_io_handle_t getOutput( 125 audio_stream_type_t stream, 126 uint32_t samplingRate, 127 audio_format_t format, 128 audio_channel_mask_t channelMask, 129 audio_output_flags_t flags) 130 { 131 Parcel data, reply; 132 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 133 data.writeInt32(static_cast <uint32_t>(stream)); 134 data.writeInt32(samplingRate); 135 data.writeInt32(static_cast <uint32_t>(format)); 136 data.writeInt32(channelMask); 137 data.writeInt32(static_cast <uint32_t>(flags)); 138 remote()->transact(GET_OUTPUT, data, &reply); 139 return static_cast <audio_io_handle_t> (reply.readInt32()); 140 } 141 142 virtual status_t startOutput(audio_io_handle_t output, 143 audio_stream_type_t stream, 144 int session) 145 { 146 Parcel data, reply; 147 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 148 data.writeInt32(output); 149 data.writeInt32((int32_t) stream); 150 data.writeInt32(session); 151 remote()->transact(START_OUTPUT, data, &reply); 152 return static_cast <status_t> (reply.readInt32()); 153 } 154 155 virtual status_t stopOutput(audio_io_handle_t output, 156 audio_stream_type_t stream, 157 int session) 158 { 159 Parcel data, reply; 160 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 161 data.writeInt32(output); 162 data.writeInt32((int32_t) stream); 163 data.writeInt32(session); 164 remote()->transact(STOP_OUTPUT, data, &reply); 165 return static_cast <status_t> (reply.readInt32()); 166 } 167 168 virtual void releaseOutput(audio_io_handle_t output) 169 { 170 Parcel data, reply; 171 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 172 data.writeInt32(output); 173 remote()->transact(RELEASE_OUTPUT, data, &reply); 174 } 175 176 virtual audio_io_handle_t getInput( 177 audio_source_t inputSource, 178 uint32_t samplingRate, 179 audio_format_t format, 180 audio_channel_mask_t channelMask, 181 int audioSession) 182 { 183 Parcel data, reply; 184 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 185 data.writeInt32((int32_t) inputSource); 186 data.writeInt32(samplingRate); 187 data.writeInt32(static_cast <uint32_t>(format)); 188 data.writeInt32(channelMask); 189 data.writeInt32(audioSession); 190 remote()->transact(GET_INPUT, data, &reply); 191 return static_cast <audio_io_handle_t> (reply.readInt32()); 192 } 193 194 virtual status_t startInput(audio_io_handle_t input) 195 { 196 Parcel data, reply; 197 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 198 data.writeInt32(input); 199 remote()->transact(START_INPUT, data, &reply); 200 return static_cast <status_t> (reply.readInt32()); 201 } 202 203 virtual status_t stopInput(audio_io_handle_t input) 204 { 205 Parcel data, reply; 206 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 207 data.writeInt32(input); 208 remote()->transact(STOP_INPUT, data, &reply); 209 return static_cast <status_t> (reply.readInt32()); 210 } 211 212 virtual void releaseInput(audio_io_handle_t input) 213 { 214 Parcel data, reply; 215 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 216 data.writeInt32(input); 217 remote()->transact(RELEASE_INPUT, data, &reply); 218 } 219 220 virtual status_t initStreamVolume(audio_stream_type_t stream, 221 int indexMin, 222 int indexMax) 223 { 224 Parcel data, reply; 225 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 226 data.writeInt32(static_cast <uint32_t>(stream)); 227 data.writeInt32(indexMin); 228 data.writeInt32(indexMax); 229 remote()->transact(INIT_STREAM_VOLUME, data, &reply); 230 return static_cast <status_t> (reply.readInt32()); 231 } 232 233 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, 234 int index, 235 audio_devices_t device) 236 { 237 Parcel data, reply; 238 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 239 data.writeInt32(static_cast <uint32_t>(stream)); 240 data.writeInt32(index); 241 data.writeInt32(static_cast <uint32_t>(device)); 242 remote()->transact(SET_STREAM_VOLUME, data, &reply); 243 return static_cast <status_t> (reply.readInt32()); 244 } 245 246 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, 247 int *index, 248 audio_devices_t device) 249 { 250 Parcel data, reply; 251 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 252 data.writeInt32(static_cast <uint32_t>(stream)); 253 data.writeInt32(static_cast <uint32_t>(device)); 254 255 remote()->transact(GET_STREAM_VOLUME, data, &reply); 256 int lIndex = reply.readInt32(); 257 if (index) *index = lIndex; 258 return static_cast <status_t> (reply.readInt32()); 259 } 260 261 virtual uint32_t getStrategyForStream(audio_stream_type_t stream) 262 { 263 Parcel data, reply; 264 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 265 data.writeInt32(static_cast <uint32_t>(stream)); 266 remote()->transact(GET_STRATEGY_FOR_STREAM, data, &reply); 267 return reply.readInt32(); 268 } 269 270 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) 271 { 272 Parcel data, reply; 273 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 274 data.writeInt32(static_cast <uint32_t>(stream)); 275 remote()->transact(GET_DEVICES_FOR_STREAM, data, &reply); 276 return (audio_devices_t) reply.readInt32(); 277 } 278 279 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) 280 { 281 Parcel data, reply; 282 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 283 data.write(desc, sizeof(effect_descriptor_t)); 284 remote()->transact(GET_OUTPUT_FOR_EFFECT, data, &reply); 285 return static_cast <audio_io_handle_t> (reply.readInt32()); 286 } 287 288 virtual status_t registerEffect(const effect_descriptor_t *desc, 289 audio_io_handle_t io, 290 uint32_t strategy, 291 int session, 292 int id) 293 { 294 Parcel data, reply; 295 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 296 data.write(desc, sizeof(effect_descriptor_t)); 297 data.writeInt32(io); 298 data.writeInt32(strategy); 299 data.writeInt32(session); 300 data.writeInt32(id); 301 remote()->transact(REGISTER_EFFECT, data, &reply); 302 return static_cast <status_t> (reply.readInt32()); 303 } 304 305 virtual status_t unregisterEffect(int id) 306 { 307 Parcel data, reply; 308 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 309 data.writeInt32(id); 310 remote()->transact(UNREGISTER_EFFECT, data, &reply); 311 return static_cast <status_t> (reply.readInt32()); 312 } 313 314 virtual status_t setEffectEnabled(int id, bool enabled) 315 { 316 Parcel data, reply; 317 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 318 data.writeInt32(id); 319 data.writeInt32(enabled); 320 remote()->transact(SET_EFFECT_ENABLED, data, &reply); 321 return static_cast <status_t> (reply.readInt32()); 322 } 323 324 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const 325 { 326 Parcel data, reply; 327 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 328 data.writeInt32((int32_t) stream); 329 data.writeInt32(inPastMs); 330 remote()->transact(IS_STREAM_ACTIVE, data, &reply); 331 return reply.readInt32(); 332 } 333 334 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const 335 { 336 Parcel data, reply; 337 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 338 data.writeInt32((int32_t) stream); 339 data.writeInt32(inPastMs); 340 remote()->transact(IS_STREAM_ACTIVE_REMOTELY, data, &reply); 341 return reply.readInt32(); 342 } 343 344 virtual bool isSourceActive(audio_source_t source) const 345 { 346 Parcel data, reply; 347 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 348 data.writeInt32((int32_t) source); 349 remote()->transact(IS_SOURCE_ACTIVE, data, &reply); 350 return reply.readInt32(); 351 } 352 353 virtual status_t queryDefaultPreProcessing(int audioSession, 354 effect_descriptor_t *descriptors, 355 uint32_t *count) 356 { 357 if (descriptors == NULL || count == NULL) { 358 return BAD_VALUE; 359 } 360 Parcel data, reply; 361 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 362 data.writeInt32(audioSession); 363 data.writeInt32(*count); 364 status_t status = remote()->transact(QUERY_DEFAULT_PRE_PROCESSING, data, &reply); 365 if (status != NO_ERROR) { 366 return status; 367 } 368 status = static_cast <status_t> (reply.readInt32()); 369 uint32_t retCount = reply.readInt32(); 370 if (retCount != 0) { 371 uint32_t numDesc = (retCount < *count) ? retCount : *count; 372 reply.read(descriptors, sizeof(effect_descriptor_t) * numDesc); 373 } 374 *count = retCount; 375 return status; 376 } 377 }; 378 379 IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService"); 380 381 // ---------------------------------------------------------------------- 382 383 384 status_t BnAudioPolicyService::onTransact( 385 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 386 { 387 switch (code) { 388 case SET_DEVICE_CONNECTION_STATE: { 389 CHECK_INTERFACE(IAudioPolicyService, data, reply); 390 audio_devices_t device = 391 static_cast <audio_devices_t>(data.readInt32()); 392 audio_policy_dev_state_t state = 393 static_cast <audio_policy_dev_state_t>(data.readInt32()); 394 const char *device_address = data.readCString(); 395 reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device, 396 state, 397 device_address))); 398 return NO_ERROR; 399 } break; 400 401 case GET_DEVICE_CONNECTION_STATE: { 402 CHECK_INTERFACE(IAudioPolicyService, data, reply); 403 audio_devices_t device = 404 static_cast<audio_devices_t> (data.readInt32()); 405 const char *device_address = data.readCString(); 406 reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device, 407 device_address))); 408 return NO_ERROR; 409 } break; 410 411 case SET_PHONE_STATE: { 412 CHECK_INTERFACE(IAudioPolicyService, data, reply); 413 reply->writeInt32(static_cast <uint32_t>(setPhoneState( 414 (audio_mode_t) data.readInt32()))); 415 return NO_ERROR; 416 } break; 417 418 case SET_FORCE_USE: { 419 CHECK_INTERFACE(IAudioPolicyService, data, reply); 420 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>( 421 data.readInt32()); 422 audio_policy_forced_cfg_t config = 423 static_cast <audio_policy_forced_cfg_t>(data.readInt32()); 424 reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config))); 425 return NO_ERROR; 426 } break; 427 428 case GET_FORCE_USE: { 429 CHECK_INTERFACE(IAudioPolicyService, data, reply); 430 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>( 431 data.readInt32()); 432 reply->writeInt32(static_cast <uint32_t>(getForceUse(usage))); 433 return NO_ERROR; 434 } break; 435 436 case GET_OUTPUT: { 437 CHECK_INTERFACE(IAudioPolicyService, data, reply); 438 audio_stream_type_t stream = 439 static_cast <audio_stream_type_t>(data.readInt32()); 440 uint32_t samplingRate = data.readInt32(); 441 audio_format_t format = (audio_format_t) data.readInt32(); 442 audio_channel_mask_t channelMask = data.readInt32(); 443 audio_output_flags_t flags = 444 static_cast <audio_output_flags_t>(data.readInt32()); 445 446 audio_io_handle_t output = getOutput(stream, 447 samplingRate, 448 format, 449 channelMask, 450 flags); 451 reply->writeInt32(static_cast <int>(output)); 452 return NO_ERROR; 453 } break; 454 455 case START_OUTPUT: { 456 CHECK_INTERFACE(IAudioPolicyService, data, reply); 457 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 458 uint32_t stream = data.readInt32(); 459 int session = data.readInt32(); 460 reply->writeInt32(static_cast <uint32_t>(startOutput(output, 461 (audio_stream_type_t)stream, 462 session))); 463 return NO_ERROR; 464 } break; 465 466 case STOP_OUTPUT: { 467 CHECK_INTERFACE(IAudioPolicyService, data, reply); 468 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 469 uint32_t stream = data.readInt32(); 470 int session = data.readInt32(); 471 reply->writeInt32(static_cast <uint32_t>(stopOutput(output, 472 (audio_stream_type_t)stream, 473 session))); 474 return NO_ERROR; 475 } break; 476 477 case RELEASE_OUTPUT: { 478 CHECK_INTERFACE(IAudioPolicyService, data, reply); 479 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 480 releaseOutput(output); 481 return NO_ERROR; 482 } break; 483 484 case GET_INPUT: { 485 CHECK_INTERFACE(IAudioPolicyService, data, reply); 486 audio_source_t inputSource = (audio_source_t) data.readInt32(); 487 uint32_t samplingRate = data.readInt32(); 488 audio_format_t format = (audio_format_t) data.readInt32(); 489 audio_channel_mask_t channelMask = data.readInt32(); 490 int audioSession = data.readInt32(); 491 audio_io_handle_t input = getInput(inputSource, 492 samplingRate, 493 format, 494 channelMask, 495 audioSession); 496 reply->writeInt32(static_cast <int>(input)); 497 return NO_ERROR; 498 } break; 499 500 case START_INPUT: { 501 CHECK_INTERFACE(IAudioPolicyService, data, reply); 502 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 503 reply->writeInt32(static_cast <uint32_t>(startInput(input))); 504 return NO_ERROR; 505 } break; 506 507 case STOP_INPUT: { 508 CHECK_INTERFACE(IAudioPolicyService, data, reply); 509 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 510 reply->writeInt32(static_cast <uint32_t>(stopInput(input))); 511 return NO_ERROR; 512 } break; 513 514 case RELEASE_INPUT: { 515 CHECK_INTERFACE(IAudioPolicyService, data, reply); 516 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 517 releaseInput(input); 518 return NO_ERROR; 519 } break; 520 521 case INIT_STREAM_VOLUME: { 522 CHECK_INTERFACE(IAudioPolicyService, data, reply); 523 audio_stream_type_t stream = 524 static_cast <audio_stream_type_t>(data.readInt32()); 525 int indexMin = data.readInt32(); 526 int indexMax = data.readInt32(); 527 reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax))); 528 return NO_ERROR; 529 } break; 530 531 case SET_STREAM_VOLUME: { 532 CHECK_INTERFACE(IAudioPolicyService, data, reply); 533 audio_stream_type_t stream = 534 static_cast <audio_stream_type_t>(data.readInt32()); 535 int index = data.readInt32(); 536 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 537 reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream, 538 index, 539 device))); 540 return NO_ERROR; 541 } break; 542 543 case GET_STREAM_VOLUME: { 544 CHECK_INTERFACE(IAudioPolicyService, data, reply); 545 audio_stream_type_t stream = 546 static_cast <audio_stream_type_t>(data.readInt32()); 547 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 548 int index; 549 status_t status = getStreamVolumeIndex(stream, &index, device); 550 reply->writeInt32(index); 551 reply->writeInt32(static_cast <uint32_t>(status)); 552 return NO_ERROR; 553 } break; 554 555 case GET_STRATEGY_FOR_STREAM: { 556 CHECK_INTERFACE(IAudioPolicyService, data, reply); 557 audio_stream_type_t stream = 558 static_cast <audio_stream_type_t>(data.readInt32()); 559 reply->writeInt32(getStrategyForStream(stream)); 560 return NO_ERROR; 561 } break; 562 563 case GET_DEVICES_FOR_STREAM: { 564 CHECK_INTERFACE(IAudioPolicyService, data, reply); 565 audio_stream_type_t stream = 566 static_cast <audio_stream_type_t>(data.readInt32()); 567 reply->writeInt32(static_cast <int>(getDevicesForStream(stream))); 568 return NO_ERROR; 569 } break; 570 571 case GET_OUTPUT_FOR_EFFECT: { 572 CHECK_INTERFACE(IAudioPolicyService, data, reply); 573 effect_descriptor_t desc; 574 data.read(&desc, sizeof(effect_descriptor_t)); 575 audio_io_handle_t output = getOutputForEffect(&desc); 576 reply->writeInt32(static_cast <int>(output)); 577 return NO_ERROR; 578 } break; 579 580 case REGISTER_EFFECT: { 581 CHECK_INTERFACE(IAudioPolicyService, data, reply); 582 effect_descriptor_t desc; 583 data.read(&desc, sizeof(effect_descriptor_t)); 584 audio_io_handle_t io = data.readInt32(); 585 uint32_t strategy = data.readInt32(); 586 int session = data.readInt32(); 587 int id = data.readInt32(); 588 reply->writeInt32(static_cast <int32_t>(registerEffect(&desc, 589 io, 590 strategy, 591 session, 592 id))); 593 return NO_ERROR; 594 } break; 595 596 case UNREGISTER_EFFECT: { 597 CHECK_INTERFACE(IAudioPolicyService, data, reply); 598 int id = data.readInt32(); 599 reply->writeInt32(static_cast <int32_t>(unregisterEffect(id))); 600 return NO_ERROR; 601 } break; 602 603 case SET_EFFECT_ENABLED: { 604 CHECK_INTERFACE(IAudioPolicyService, data, reply); 605 int id = data.readInt32(); 606 bool enabled = static_cast <bool>(data.readInt32()); 607 reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled))); 608 return NO_ERROR; 609 } break; 610 611 case IS_STREAM_ACTIVE: { 612 CHECK_INTERFACE(IAudioPolicyService, data, reply); 613 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 614 uint32_t inPastMs = (uint32_t)data.readInt32(); 615 reply->writeInt32( isStreamActive((audio_stream_type_t) stream, inPastMs) ); 616 return NO_ERROR; 617 } break; 618 619 case IS_STREAM_ACTIVE_REMOTELY: { 620 CHECK_INTERFACE(IAudioPolicyService, data, reply); 621 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 622 uint32_t inPastMs = (uint32_t)data.readInt32(); 623 reply->writeInt32( isStreamActiveRemotely((audio_stream_type_t) stream, inPastMs) ); 624 return NO_ERROR; 625 } break; 626 627 case IS_SOURCE_ACTIVE: { 628 CHECK_INTERFACE(IAudioPolicyService, data, reply); 629 audio_source_t source = (audio_source_t) data.readInt32(); 630 reply->writeInt32( isSourceActive(source)); 631 return NO_ERROR; 632 } 633 634 case QUERY_DEFAULT_PRE_PROCESSING: { 635 CHECK_INTERFACE(IAudioPolicyService, data, reply); 636 int audioSession = data.readInt32(); 637 uint32_t count = data.readInt32(); 638 uint32_t retCount = count; 639 effect_descriptor_t *descriptors = 640 (effect_descriptor_t *)new char[count * sizeof(effect_descriptor_t)]; 641 status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount); 642 reply->writeInt32(status); 643 if (status != NO_ERROR && status != NO_MEMORY) { 644 retCount = 0; 645 } 646 reply->writeInt32(retCount); 647 if (retCount) { 648 if (retCount < count) { 649 count = retCount; 650 } 651 reply->write(descriptors, sizeof(effect_descriptor_t) * count); 652 } 653 delete[] descriptors; 654 return status; 655 } 656 657 default: 658 return BBinder::onTransact(code, data, reply, flags); 659 } 660 } 661 662 // ---------------------------------------------------------------------------- 663 664 }; // namespace android 665
