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