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((audio_mode_t) data.readInt32()))); 403 return NO_ERROR; 404 } break; 405 406 case SET_FORCE_USE: { 407 CHECK_INTERFACE(IAudioPolicyService, data, reply); 408 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(data.readInt32()); 409 audio_policy_forced_cfg_t config = 410 static_cast <audio_policy_forced_cfg_t>(data.readInt32()); 411 reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config))); 412 return NO_ERROR; 413 } break; 414 415 case GET_FORCE_USE: { 416 CHECK_INTERFACE(IAudioPolicyService, data, reply); 417 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(data.readInt32()); 418 reply->writeInt32(static_cast <uint32_t>(getForceUse(usage))); 419 return NO_ERROR; 420 } break; 421 422 case GET_OUTPUT: { 423 CHECK_INTERFACE(IAudioPolicyService, data, reply); 424 audio_stream_type_t stream = 425 static_cast <audio_stream_type_t>(data.readInt32()); 426 uint32_t samplingRate = data.readInt32(); 427 audio_format_t format = (audio_format_t) data.readInt32(); 428 audio_channel_mask_t channelMask = data.readInt32(); 429 audio_output_flags_t flags = 430 static_cast <audio_output_flags_t>(data.readInt32()); 431 432 audio_io_handle_t output = getOutput(stream, 433 samplingRate, 434 format, 435 channelMask, 436 flags); 437 reply->writeInt32(static_cast <int>(output)); 438 return NO_ERROR; 439 } break; 440 441 case START_OUTPUT: { 442 CHECK_INTERFACE(IAudioPolicyService, data, reply); 443 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 444 uint32_t stream = data.readInt32(); 445 int session = data.readInt32(); 446 reply->writeInt32(static_cast <uint32_t>(startOutput(output, 447 (audio_stream_type_t)stream, 448 session))); 449 return NO_ERROR; 450 } break; 451 452 case STOP_OUTPUT: { 453 CHECK_INTERFACE(IAudioPolicyService, data, reply); 454 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 455 uint32_t stream = data.readInt32(); 456 int session = data.readInt32(); 457 reply->writeInt32(static_cast <uint32_t>(stopOutput(output, 458 (audio_stream_type_t)stream, 459 session))); 460 return NO_ERROR; 461 } break; 462 463 case RELEASE_OUTPUT: { 464 CHECK_INTERFACE(IAudioPolicyService, data, reply); 465 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 466 releaseOutput(output); 467 return NO_ERROR; 468 } break; 469 470 case GET_INPUT: { 471 CHECK_INTERFACE(IAudioPolicyService, data, reply); 472 audio_source_t inputSource = (audio_source_t) data.readInt32(); 473 uint32_t samplingRate = data.readInt32(); 474 audio_format_t format = (audio_format_t) data.readInt32(); 475 audio_channel_mask_t channelMask = data.readInt32(); 476 int audioSession = data.readInt32(); 477 audio_io_handle_t input = getInput(inputSource, 478 samplingRate, 479 format, 480 channelMask, 481 audioSession); 482 reply->writeInt32(static_cast <int>(input)); 483 return NO_ERROR; 484 } break; 485 486 case START_INPUT: { 487 CHECK_INTERFACE(IAudioPolicyService, data, reply); 488 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 489 reply->writeInt32(static_cast <uint32_t>(startInput(input))); 490 return NO_ERROR; 491 } break; 492 493 case STOP_INPUT: { 494 CHECK_INTERFACE(IAudioPolicyService, data, reply); 495 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 496 reply->writeInt32(static_cast <uint32_t>(stopInput(input))); 497 return NO_ERROR; 498 } break; 499 500 case RELEASE_INPUT: { 501 CHECK_INTERFACE(IAudioPolicyService, data, reply); 502 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 503 releaseInput(input); 504 return NO_ERROR; 505 } break; 506 507 case INIT_STREAM_VOLUME: { 508 CHECK_INTERFACE(IAudioPolicyService, data, reply); 509 audio_stream_type_t stream = 510 static_cast <audio_stream_type_t>(data.readInt32()); 511 int indexMin = data.readInt32(); 512 int indexMax = data.readInt32(); 513 reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax))); 514 return NO_ERROR; 515 } break; 516 517 case SET_STREAM_VOLUME: { 518 CHECK_INTERFACE(IAudioPolicyService, data, reply); 519 audio_stream_type_t stream = 520 static_cast <audio_stream_type_t>(data.readInt32()); 521 int index = data.readInt32(); 522 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 523 reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream, 524 index, 525 device))); 526 return NO_ERROR; 527 } break; 528 529 case GET_STREAM_VOLUME: { 530 CHECK_INTERFACE(IAudioPolicyService, data, reply); 531 audio_stream_type_t stream = 532 static_cast <audio_stream_type_t>(data.readInt32()); 533 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 534 int index; 535 status_t status = getStreamVolumeIndex(stream, &index, device); 536 reply->writeInt32(index); 537 reply->writeInt32(static_cast <uint32_t>(status)); 538 return NO_ERROR; 539 } break; 540 541 case GET_STRATEGY_FOR_STREAM: { 542 CHECK_INTERFACE(IAudioPolicyService, data, reply); 543 audio_stream_type_t stream = 544 static_cast <audio_stream_type_t>(data.readInt32()); 545 reply->writeInt32(getStrategyForStream(stream)); 546 return NO_ERROR; 547 } break; 548 549 case GET_DEVICES_FOR_STREAM: { 550 CHECK_INTERFACE(IAudioPolicyService, data, reply); 551 audio_stream_type_t stream = 552 static_cast <audio_stream_type_t>(data.readInt32()); 553 reply->writeInt32(static_cast <int>(getDevicesForStream(stream))); 554 return NO_ERROR; 555 } break; 556 557 case GET_OUTPUT_FOR_EFFECT: { 558 CHECK_INTERFACE(IAudioPolicyService, data, reply); 559 effect_descriptor_t desc; 560 data.read(&desc, sizeof(effect_descriptor_t)); 561 audio_io_handle_t output = getOutputForEffect(&desc); 562 reply->writeInt32(static_cast <int>(output)); 563 return NO_ERROR; 564 } break; 565 566 case REGISTER_EFFECT: { 567 CHECK_INTERFACE(IAudioPolicyService, data, reply); 568 effect_descriptor_t desc; 569 data.read(&desc, sizeof(effect_descriptor_t)); 570 audio_io_handle_t io = data.readInt32(); 571 uint32_t strategy = data.readInt32(); 572 int session = data.readInt32(); 573 int id = data.readInt32(); 574 reply->writeInt32(static_cast <int32_t>(registerEffect(&desc, 575 io, 576 strategy, 577 session, 578 id))); 579 return NO_ERROR; 580 } break; 581 582 case UNREGISTER_EFFECT: { 583 CHECK_INTERFACE(IAudioPolicyService, data, reply); 584 int id = data.readInt32(); 585 reply->writeInt32(static_cast <int32_t>(unregisterEffect(id))); 586 return NO_ERROR; 587 } break; 588 589 case SET_EFFECT_ENABLED: { 590 CHECK_INTERFACE(IAudioPolicyService, data, reply); 591 int id = data.readInt32(); 592 bool enabled = static_cast <bool>(data.readInt32()); 593 reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled))); 594 return NO_ERROR; 595 } break; 596 597 case IS_STREAM_ACTIVE: { 598 CHECK_INTERFACE(IAudioPolicyService, data, reply); 599 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 600 uint32_t inPastMs = (uint32_t)data.readInt32(); 601 reply->writeInt32( isStreamActive((audio_stream_type_t) stream, inPastMs) ); 602 return NO_ERROR; 603 } break; 604 605 case IS_SOURCE_ACTIVE: { 606 CHECK_INTERFACE(IAudioPolicyService, data, reply); 607 audio_source_t source = (audio_source_t) data.readInt32(); 608 reply->writeInt32( isSourceActive(source)); 609 return NO_ERROR; 610 } 611 612 case QUERY_DEFAULT_PRE_PROCESSING: { 613 CHECK_INTERFACE(IAudioPolicyService, data, reply); 614 int audioSession = data.readInt32(); 615 uint32_t count = data.readInt32(); 616 uint32_t retCount = count; 617 effect_descriptor_t *descriptors = 618 (effect_descriptor_t *)new char[count * sizeof(effect_descriptor_t)]; 619 status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount); 620 reply->writeInt32(status); 621 if (status != NO_ERROR && status != NO_MEMORY) { 622 retCount = 0; 623 } 624 reply->writeInt32(retCount); 625 if (retCount) { 626 if (retCount < count) { 627 count = retCount; 628 } 629 reply->write(descriptors, sizeof(effect_descriptor_t) * count); 630 } 631 delete[] descriptors; 632 return status; 633 } 634 635 default: 636 return BBinder::onTransact(code, data, reply, flags); 637 } 638} 639 640// ---------------------------------------------------------------------------- 641 642}; // namespace android 643