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