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