mediaplayer.cpp revision d44b51d9fcb0b5d891d2abece83a551e71ebb73b
1/* mediaplayer.cpp 2** 3** Copyright 2006, 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_NDEBUG 0 19#define LOG_TAG "MediaPlayer" 20#include <utils/Log.h> 21 22#include <sys/types.h> 23#include <sys/stat.h> 24#include <unistd.h> 25#include <fcntl.h> 26 27#include <binder/IServiceManager.h> 28#include <binder/IPCThreadState.h> 29 30#include <media/mediaplayer.h> 31#include <media/AudioTrack.h> 32 33#include <surfaceflinger/Surface.h> 34 35#include <binder/MemoryBase.h> 36 37#include <utils/KeyedVector.h> 38#include <utils/String8.h> 39 40namespace android { 41 42MediaPlayer::MediaPlayer() 43{ 44 LOGV("constructor"); 45 mListener = NULL; 46 mCookie = NULL; 47 mDuration = -1; 48 mStreamType = AudioSystem::MUSIC; 49 mCurrentPosition = -1; 50 mSeekPosition = -1; 51 mCurrentState = MEDIA_PLAYER_IDLE; 52 mPrepareSync = false; 53 mPrepareStatus = NO_ERROR; 54 mLoop = false; 55 mLeftVolume = mRightVolume = 1.0; 56 mVideoWidth = mVideoHeight = 0; 57 mLockThreadId = 0; 58 mAudioSessionId = AudioSystem::newAudioSessionId(); 59} 60 61MediaPlayer::~MediaPlayer() 62{ 63 LOGV("destructor"); 64 disconnect(); 65 IPCThreadState::self()->flushCommands(); 66} 67 68void MediaPlayer::disconnect() 69{ 70 LOGV("disconnect"); 71 sp<IMediaPlayer> p; 72 { 73 Mutex::Autolock _l(mLock); 74 p = mPlayer; 75 mPlayer.clear(); 76 } 77 78 if (p != 0) { 79 p->disconnect(); 80 } 81} 82 83// always call with lock held 84void MediaPlayer::clear_l() 85{ 86 mDuration = -1; 87 mCurrentPosition = -1; 88 mSeekPosition = -1; 89 mVideoWidth = mVideoHeight = 0; 90} 91 92status_t MediaPlayer::setListener(const sp<MediaPlayerListener>& listener) 93{ 94 LOGV("setListener"); 95 Mutex::Autolock _l(mLock); 96 mListener = listener; 97 return NO_ERROR; 98} 99 100 101status_t MediaPlayer::setDataSource(const sp<IMediaPlayer>& player) 102{ 103 status_t err = UNKNOWN_ERROR; 104 sp<IMediaPlayer> p; 105 { // scope for the lock 106 Mutex::Autolock _l(mLock); 107 108 if ( !( (mCurrentState & MEDIA_PLAYER_IDLE) || 109 (mCurrentState == MEDIA_PLAYER_STATE_ERROR ) ) ) { 110 LOGE("setDataSource called in state %d", mCurrentState); 111 return INVALID_OPERATION; 112 } 113 114 clear_l(); 115 p = mPlayer; 116 mPlayer = player; 117 if (player != 0) { 118 mCurrentState = MEDIA_PLAYER_INITIALIZED; 119 err = NO_ERROR; 120 } else { 121 LOGE("Unable to to create media player"); 122 } 123 } 124 125 if (p != 0) { 126 p->disconnect(); 127 } 128 129 return err; 130} 131 132status_t MediaPlayer::setDataSource( 133 const char *url, const KeyedVector<String8, String8> *headers) 134{ 135 LOGV("setDataSource(%s)", url); 136 status_t err = BAD_VALUE; 137 if (url != NULL) { 138 const sp<IMediaPlayerService>& service(getMediaPlayerService()); 139 if (service != 0) { 140 sp<IMediaPlayer> player( 141 service->create(getpid(), this, url, headers, mAudioSessionId)); 142 err = setDataSource(player); 143 } 144 } 145 return err; 146} 147 148status_t MediaPlayer::setDataSource(int fd, int64_t offset, int64_t length) 149{ 150 LOGV("setDataSource(%d, %lld, %lld)", fd, offset, length); 151 status_t err = UNKNOWN_ERROR; 152 const sp<IMediaPlayerService>& service(getMediaPlayerService()); 153 if (service != 0) { 154 sp<IMediaPlayer> player(service->create(getpid(), this, fd, offset, length, mAudioSessionId)); 155 err = setDataSource(player); 156 } 157 return err; 158} 159 160status_t MediaPlayer::invoke(const Parcel& request, Parcel *reply) 161{ 162 Mutex::Autolock _l(mLock); 163 const bool hasBeenInitialized = 164 (mCurrentState != MEDIA_PLAYER_STATE_ERROR) && 165 ((mCurrentState & MEDIA_PLAYER_IDLE) != MEDIA_PLAYER_IDLE); 166 if ((mPlayer != NULL) && hasBeenInitialized) { 167 LOGV("invoke %d", request.dataSize()); 168 return mPlayer->invoke(request, reply); 169 } 170 LOGE("invoke failed: wrong state %X", mCurrentState); 171 return INVALID_OPERATION; 172} 173 174status_t MediaPlayer::suspend() { 175 Mutex::Autolock _l(mLock); 176 return mPlayer->suspend(); 177} 178 179status_t MediaPlayer::resume() { 180 Mutex::Autolock _l(mLock); 181 return mPlayer->resume(); 182} 183 184status_t MediaPlayer::setMetadataFilter(const Parcel& filter) 185{ 186 LOGD("setMetadataFilter"); 187 Mutex::Autolock lock(mLock); 188 if (mPlayer == NULL) { 189 return NO_INIT; 190 } 191 return mPlayer->setMetadataFilter(filter); 192} 193 194status_t MediaPlayer::getMetadata(bool update_only, bool apply_filter, Parcel *metadata) 195{ 196 LOGD("getMetadata"); 197 Mutex::Autolock lock(mLock); 198 if (mPlayer == NULL) { 199 return NO_INIT; 200 } 201 return mPlayer->getMetadata(update_only, apply_filter, metadata); 202} 203 204status_t MediaPlayer::setVideoSurface(const sp<Surface>& surface) 205{ 206 LOGV("setVideoSurface"); 207 Mutex::Autolock _l(mLock); 208 if (mPlayer == 0) return NO_INIT; 209 210 status_t err = mPlayer->setVideoISurface( 211 surface == NULL ? NULL : surface->getISurface()); 212 213 if (err != OK) { 214 return err; 215 } 216 217 return mPlayer->setVideoSurface(surface); 218} 219 220// must call with lock held 221status_t MediaPlayer::prepareAsync_l() 222{ 223 if ( (mPlayer != 0) && ( mCurrentState & ( MEDIA_PLAYER_INITIALIZED | MEDIA_PLAYER_STOPPED) ) ) { 224 mPlayer->setAudioStreamType(mStreamType); 225 mCurrentState = MEDIA_PLAYER_PREPARING; 226 return mPlayer->prepareAsync(); 227 } 228 LOGE("prepareAsync called in state %d", mCurrentState); 229 return INVALID_OPERATION; 230} 231 232// TODO: In case of error, prepareAsync provides the caller with 2 error codes, 233// one defined in the Android framework and one provided by the implementation 234// that generated the error. The sync version of prepare returns only 1 error 235// code. 236status_t MediaPlayer::prepare() 237{ 238 LOGV("prepare"); 239 Mutex::Autolock _l(mLock); 240 mLockThreadId = getThreadId(); 241 if (mPrepareSync) { 242 mLockThreadId = 0; 243 return -EALREADY; 244 } 245 mPrepareSync = true; 246 status_t ret = prepareAsync_l(); 247 if (ret != NO_ERROR) { 248 mLockThreadId = 0; 249 return ret; 250 } 251 252 if (mPrepareSync) { 253 mSignal.wait(mLock); // wait for prepare done 254 mPrepareSync = false; 255 } 256 LOGV("prepare complete - status=%d", mPrepareStatus); 257 mLockThreadId = 0; 258 return mPrepareStatus; 259} 260 261status_t MediaPlayer::prepareAsync() 262{ 263 LOGV("prepareAsync"); 264 Mutex::Autolock _l(mLock); 265 return prepareAsync_l(); 266} 267 268status_t MediaPlayer::start() 269{ 270 LOGV("start"); 271 Mutex::Autolock _l(mLock); 272 if (mCurrentState & MEDIA_PLAYER_STARTED) 273 return NO_ERROR; 274 if ( (mPlayer != 0) && ( mCurrentState & ( MEDIA_PLAYER_PREPARED | 275 MEDIA_PLAYER_PLAYBACK_COMPLETE | MEDIA_PLAYER_PAUSED ) ) ) { 276 mPlayer->setLooping(mLoop); 277 mPlayer->setVolume(mLeftVolume, mRightVolume); 278 mPlayer->setAuxEffectSendLevel(mSendLevel); 279 mCurrentState = MEDIA_PLAYER_STARTED; 280 status_t ret = mPlayer->start(); 281 if (ret != NO_ERROR) { 282 mCurrentState = MEDIA_PLAYER_STATE_ERROR; 283 } else { 284 if (mCurrentState == MEDIA_PLAYER_PLAYBACK_COMPLETE) { 285 LOGV("playback completed immediately following start()"); 286 } 287 } 288 return ret; 289 } 290 LOGE("start called in state %d", mCurrentState); 291 return INVALID_OPERATION; 292} 293 294status_t MediaPlayer::stop() 295{ 296 LOGV("stop"); 297 Mutex::Autolock _l(mLock); 298 if (mCurrentState & MEDIA_PLAYER_STOPPED) return NO_ERROR; 299 if ( (mPlayer != 0) && ( mCurrentState & ( MEDIA_PLAYER_STARTED | MEDIA_PLAYER_PREPARED | 300 MEDIA_PLAYER_PAUSED | MEDIA_PLAYER_PLAYBACK_COMPLETE ) ) ) { 301 status_t ret = mPlayer->stop(); 302 if (ret != NO_ERROR) { 303 mCurrentState = MEDIA_PLAYER_STATE_ERROR; 304 } else { 305 mCurrentState = MEDIA_PLAYER_STOPPED; 306 } 307 return ret; 308 } 309 LOGE("stop called in state %d", mCurrentState); 310 return INVALID_OPERATION; 311} 312 313status_t MediaPlayer::pause() 314{ 315 LOGV("pause"); 316 Mutex::Autolock _l(mLock); 317 if (mCurrentState & (MEDIA_PLAYER_PAUSED|MEDIA_PLAYER_PLAYBACK_COMPLETE)) 318 return NO_ERROR; 319 if ((mPlayer != 0) && (mCurrentState & MEDIA_PLAYER_STARTED)) { 320 status_t ret = mPlayer->pause(); 321 if (ret != NO_ERROR) { 322 mCurrentState = MEDIA_PLAYER_STATE_ERROR; 323 } else { 324 mCurrentState = MEDIA_PLAYER_PAUSED; 325 } 326 return ret; 327 } 328 LOGE("pause called in state %d", mCurrentState); 329 return INVALID_OPERATION; 330} 331 332bool MediaPlayer::isPlaying() 333{ 334 Mutex::Autolock _l(mLock); 335 if (mPlayer != 0) { 336 bool temp = false; 337 mPlayer->isPlaying(&temp); 338 LOGV("isPlaying: %d", temp); 339 if ((mCurrentState & MEDIA_PLAYER_STARTED) && ! temp) { 340 LOGE("internal/external state mismatch corrected"); 341 mCurrentState = MEDIA_PLAYER_PAUSED; 342 } 343 return temp; 344 } 345 LOGV("isPlaying: no active player"); 346 return false; 347} 348 349status_t MediaPlayer::getVideoWidth(int *w) 350{ 351 LOGV("getVideoWidth"); 352 Mutex::Autolock _l(mLock); 353 if (mPlayer == 0) return INVALID_OPERATION; 354 *w = mVideoWidth; 355 return NO_ERROR; 356} 357 358status_t MediaPlayer::getVideoHeight(int *h) 359{ 360 LOGV("getVideoHeight"); 361 Mutex::Autolock _l(mLock); 362 if (mPlayer == 0) return INVALID_OPERATION; 363 *h = mVideoHeight; 364 return NO_ERROR; 365} 366 367status_t MediaPlayer::getCurrentPosition(int *msec) 368{ 369 LOGV("getCurrentPosition"); 370 Mutex::Autolock _l(mLock); 371 if (mPlayer != 0) { 372 if (mCurrentPosition >= 0) { 373 LOGV("Using cached seek position: %d", mCurrentPosition); 374 *msec = mCurrentPosition; 375 return NO_ERROR; 376 } 377 return mPlayer->getCurrentPosition(msec); 378 } 379 return INVALID_OPERATION; 380} 381 382status_t MediaPlayer::getDuration_l(int *msec) 383{ 384 LOGV("getDuration"); 385 bool isValidState = (mCurrentState & (MEDIA_PLAYER_PREPARED | MEDIA_PLAYER_STARTED | MEDIA_PLAYER_PAUSED | MEDIA_PLAYER_STOPPED | MEDIA_PLAYER_PLAYBACK_COMPLETE)); 386 if (mPlayer != 0 && isValidState) { 387 status_t ret = NO_ERROR; 388 if (mDuration <= 0) 389 ret = mPlayer->getDuration(&mDuration); 390 if (msec) 391 *msec = mDuration; 392 return ret; 393 } 394 LOGE("Attempt to call getDuration without a valid mediaplayer"); 395 return INVALID_OPERATION; 396} 397 398status_t MediaPlayer::getDuration(int *msec) 399{ 400 Mutex::Autolock _l(mLock); 401 return getDuration_l(msec); 402} 403 404status_t MediaPlayer::seekTo_l(int msec) 405{ 406 LOGV("seekTo %d", msec); 407 if ((mPlayer != 0) && ( mCurrentState & ( MEDIA_PLAYER_STARTED | MEDIA_PLAYER_PREPARED | MEDIA_PLAYER_PAUSED | MEDIA_PLAYER_PLAYBACK_COMPLETE) ) ) { 408 if ( msec < 0 ) { 409 LOGW("Attempt to seek to invalid position: %d", msec); 410 msec = 0; 411 } else if ((mDuration > 0) && (msec > mDuration)) { 412 LOGW("Attempt to seek to past end of file: request = %d, EOF = %d", msec, mDuration); 413 msec = mDuration; 414 } 415 // cache duration 416 mCurrentPosition = msec; 417 if (mSeekPosition < 0) { 418 getDuration_l(NULL); 419 mSeekPosition = msec; 420 return mPlayer->seekTo(msec); 421 } 422 else { 423 LOGV("Seek in progress - queue up seekTo[%d]", msec); 424 return NO_ERROR; 425 } 426 } 427 LOGE("Attempt to perform seekTo in wrong state: mPlayer=%p, mCurrentState=%u", mPlayer.get(), mCurrentState); 428 return INVALID_OPERATION; 429} 430 431status_t MediaPlayer::seekTo(int msec) 432{ 433 mLockThreadId = getThreadId(); 434 Mutex::Autolock _l(mLock); 435 status_t result = seekTo_l(msec); 436 mLockThreadId = 0; 437 438 return result; 439} 440 441status_t MediaPlayer::reset() 442{ 443 LOGV("reset"); 444 Mutex::Autolock _l(mLock); 445 mLoop = false; 446 if (mCurrentState == MEDIA_PLAYER_IDLE) return NO_ERROR; 447 mPrepareSync = false; 448 if (mPlayer != 0) { 449 status_t ret = mPlayer->reset(); 450 if (ret != NO_ERROR) { 451 LOGE("reset() failed with return code (%d)", ret); 452 mCurrentState = MEDIA_PLAYER_STATE_ERROR; 453 } else { 454 mCurrentState = MEDIA_PLAYER_IDLE; 455 } 456 return ret; 457 } 458 clear_l(); 459 return NO_ERROR; 460} 461 462status_t MediaPlayer::setAudioStreamType(int type) 463{ 464 LOGV("MediaPlayer::setAudioStreamType"); 465 Mutex::Autolock _l(mLock); 466 if (mStreamType == type) return NO_ERROR; 467 if (mCurrentState & ( MEDIA_PLAYER_PREPARED | MEDIA_PLAYER_STARTED | 468 MEDIA_PLAYER_PAUSED | MEDIA_PLAYER_PLAYBACK_COMPLETE ) ) { 469 // Can't change the stream type after prepare 470 LOGE("setAudioStream called in state %d", mCurrentState); 471 return INVALID_OPERATION; 472 } 473 // cache 474 mStreamType = type; 475 return OK; 476} 477 478status_t MediaPlayer::setLooping(int loop) 479{ 480 LOGV("MediaPlayer::setLooping"); 481 Mutex::Autolock _l(mLock); 482 mLoop = (loop != 0); 483 if (mPlayer != 0) { 484 return mPlayer->setLooping(loop); 485 } 486 return OK; 487} 488 489bool MediaPlayer::isLooping() { 490 LOGV("isLooping"); 491 Mutex::Autolock _l(mLock); 492 if (mPlayer != 0) { 493 return mLoop; 494 } 495 LOGV("isLooping: no active player"); 496 return false; 497} 498 499status_t MediaPlayer::setVolume(float leftVolume, float rightVolume) 500{ 501 LOGV("MediaPlayer::setVolume(%f, %f)", leftVolume, rightVolume); 502 Mutex::Autolock _l(mLock); 503 mLeftVolume = leftVolume; 504 mRightVolume = rightVolume; 505 if (mPlayer != 0) { 506 return mPlayer->setVolume(leftVolume, rightVolume); 507 } 508 return OK; 509} 510 511status_t MediaPlayer::setAudioSessionId(int sessionId) 512{ 513 LOGV("MediaPlayer::setAudioSessionId(%d)", sessionId); 514 Mutex::Autolock _l(mLock); 515 if (!(mCurrentState & MEDIA_PLAYER_IDLE)) { 516 LOGE("setAudioSessionId called in state %d", mCurrentState); 517 return INVALID_OPERATION; 518 } 519 if (sessionId < 0) { 520 return BAD_VALUE; 521 } 522 mAudioSessionId = sessionId; 523 return NO_ERROR; 524} 525 526int MediaPlayer::getAudioSessionId() 527{ 528 Mutex::Autolock _l(mLock); 529 return mAudioSessionId; 530} 531 532status_t MediaPlayer::setAuxEffectSendLevel(float level) 533{ 534 LOGV("MediaPlayer::setAuxEffectSendLevel(%f)", level); 535 Mutex::Autolock _l(mLock); 536 mSendLevel = level; 537 if (mPlayer != 0) { 538 return mPlayer->setAuxEffectSendLevel(level); 539 } 540 return OK; 541} 542 543status_t MediaPlayer::attachAuxEffect(int effectId) 544{ 545 LOGV("MediaPlayer::attachAuxEffect(%d)", effectId); 546 Mutex::Autolock _l(mLock); 547 if (mPlayer == 0 || 548 (mCurrentState & MEDIA_PLAYER_IDLE) || 549 (mCurrentState == MEDIA_PLAYER_STATE_ERROR )) { 550 LOGE("attachAuxEffect called in state %d", mCurrentState); 551 return INVALID_OPERATION; 552 } 553 554 return mPlayer->attachAuxEffect(effectId); 555} 556 557void MediaPlayer::notify(int msg, int ext1, int ext2) 558{ 559 LOGV("message received msg=%d, ext1=%d, ext2=%d", msg, ext1, ext2); 560 bool send = true; 561 bool locked = false; 562 563 // TODO: In the future, we might be on the same thread if the app is 564 // running in the same process as the media server. In that case, 565 // this will deadlock. 566 // 567 // The threadId hack below works around this for the care of prepare 568 // and seekTo within the same process. 569 // FIXME: Remember, this is a hack, it's not even a hack that is applied 570 // consistently for all use-cases, this needs to be revisited. 571 if (mLockThreadId != getThreadId()) { 572 mLock.lock(); 573 locked = true; 574 } 575 576 // Allows calls from JNI in idle state to notify errors 577 if (!(msg == MEDIA_ERROR && mCurrentState == MEDIA_PLAYER_IDLE) && mPlayer == 0) { 578 LOGV("notify(%d, %d, %d) callback on disconnected mediaplayer", msg, ext1, ext2); 579 if (locked) mLock.unlock(); // release the lock when done. 580 return; 581 } 582 583 switch (msg) { 584 case MEDIA_NOP: // interface test message 585 break; 586 case MEDIA_PREPARED: 587 LOGV("prepared"); 588 mCurrentState = MEDIA_PLAYER_PREPARED; 589 if (mPrepareSync) { 590 LOGV("signal application thread"); 591 mPrepareSync = false; 592 mPrepareStatus = NO_ERROR; 593 mSignal.signal(); 594 } 595 break; 596 case MEDIA_PLAYBACK_COMPLETE: 597 LOGV("playback complete"); 598 if (mCurrentState == MEDIA_PLAYER_IDLE) { 599 LOGE("playback complete in idle state"); 600 } 601 if (!mLoop) { 602 mCurrentState = MEDIA_PLAYER_PLAYBACK_COMPLETE; 603 } 604 break; 605 case MEDIA_ERROR: 606 // Always log errors. 607 // ext1: Media framework error code. 608 // ext2: Implementation dependant error code. 609 LOGE("error (%d, %d)", ext1, ext2); 610 mCurrentState = MEDIA_PLAYER_STATE_ERROR; 611 if (mPrepareSync) 612 { 613 LOGV("signal application thread"); 614 mPrepareSync = false; 615 mPrepareStatus = ext1; 616 mSignal.signal(); 617 send = false; 618 } 619 break; 620 case MEDIA_INFO: 621 // ext1: Media framework error code. 622 // ext2: Implementation dependant error code. 623 LOGW("info/warning (%d, %d)", ext1, ext2); 624 break; 625 case MEDIA_SEEK_COMPLETE: 626 LOGV("Received seek complete"); 627 if (mSeekPosition != mCurrentPosition) { 628 LOGV("Executing queued seekTo(%d)", mSeekPosition); 629 mSeekPosition = -1; 630 seekTo_l(mCurrentPosition); 631 } 632 else { 633 LOGV("All seeks complete - return to regularly scheduled program"); 634 mCurrentPosition = mSeekPosition = -1; 635 } 636 break; 637 case MEDIA_BUFFERING_UPDATE: 638 LOGV("buffering %d", ext1); 639 break; 640 case MEDIA_SET_VIDEO_SIZE: 641 LOGV("New video size %d x %d", ext1, ext2); 642 mVideoWidth = ext1; 643 mVideoHeight = ext2; 644 break; 645 default: 646 LOGV("unrecognized message: (%d, %d, %d)", msg, ext1, ext2); 647 break; 648 } 649 650 sp<MediaPlayerListener> listener = mListener; 651 if (locked) mLock.unlock(); 652 653 // this prevents re-entrant calls into client code 654 if ((listener != 0) && send) { 655 Mutex::Autolock _l(mNotifyLock); 656 LOGV("callback application"); 657 listener->notify(msg, ext1, ext2); 658 LOGV("back from callback"); 659 } 660} 661 662/*static*/ sp<IMemory> MediaPlayer::decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, int* pFormat) 663{ 664 LOGV("decode(%s)", url); 665 sp<IMemory> p; 666 const sp<IMediaPlayerService>& service = getMediaPlayerService(); 667 if (service != 0) { 668 p = service->decode(url, pSampleRate, pNumChannels, pFormat); 669 } else { 670 LOGE("Unable to locate media service"); 671 } 672 return p; 673 674} 675 676void MediaPlayer::died() 677{ 678 LOGV("died"); 679 notify(MEDIA_ERROR, MEDIA_ERROR_SERVER_DIED, 0); 680} 681 682/*static*/ sp<IMemory> MediaPlayer::decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, int* pFormat) 683{ 684 LOGV("decode(%d, %lld, %lld)", fd, offset, length); 685 sp<IMemory> p; 686 const sp<IMediaPlayerService>& service = getMediaPlayerService(); 687 if (service != 0) { 688 p = service->decode(fd, offset, length, pSampleRate, pNumChannels, pFormat); 689 } else { 690 LOGE("Unable to locate media service"); 691 } 692 return p; 693 694} 695 696}; // namespace android 697