1/* 2 ** 3 ** Copyright (c) 2008 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 "MediaRecorder" 20 21#include <inttypes.h> 22 23#include <utils/Log.h> 24#include <media/mediarecorder.h> 25#include <binder/IServiceManager.h> 26#include <utils/String8.h> 27#include <media/IMediaPlayerService.h> 28#include <media/IMediaRecorder.h> 29#include <media/mediaplayer.h> // for MEDIA_ERROR_SERVER_DIED 30#include <media/stagefright/PersistentSurface.h> 31#include <gui/IGraphicBufferProducer.h> 32 33namespace android { 34 35status_t MediaRecorder::setCamera(const sp<hardware::ICamera>& camera, 36 const sp<ICameraRecordingProxy>& proxy) 37{ 38 ALOGV("setCamera(%p,%p)", camera.get(), proxy.get()); 39 if (mMediaRecorder == NULL) { 40 ALOGE("media recorder is not initialized yet"); 41 return INVALID_OPERATION; 42 } 43 if (!(mCurrentState & MEDIA_RECORDER_IDLE)) { 44 ALOGE("setCamera called in an invalid state(%d)", mCurrentState); 45 return INVALID_OPERATION; 46 } 47 48 status_t ret = mMediaRecorder->setCamera(camera, proxy); 49 if (OK != ret) { 50 ALOGV("setCamera failed: %d", ret); 51 mCurrentState = MEDIA_RECORDER_ERROR; 52 return ret; 53 } 54 return ret; 55} 56 57status_t MediaRecorder::setPreviewSurface(const sp<IGraphicBufferProducer>& surface) 58{ 59 ALOGV("setPreviewSurface(%p)", surface.get()); 60 if (mMediaRecorder == NULL) { 61 ALOGE("media recorder is not initialized yet"); 62 return INVALID_OPERATION; 63 } 64 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 65 ALOGE("setPreviewSurface called in an invalid state(%d)", mCurrentState); 66 return INVALID_OPERATION; 67 } 68 if (!mIsVideoSourceSet) { 69 ALOGE("try to set preview surface without setting the video source first"); 70 return INVALID_OPERATION; 71 } 72 73 status_t ret = mMediaRecorder->setPreviewSurface(surface); 74 if (OK != ret) { 75 ALOGV("setPreviewSurface failed: %d", ret); 76 mCurrentState = MEDIA_RECORDER_ERROR; 77 return ret; 78 } 79 return ret; 80} 81 82status_t MediaRecorder::init() 83{ 84 ALOGV("init"); 85 if (mMediaRecorder == NULL) { 86 ALOGE("media recorder is not initialized yet"); 87 return INVALID_OPERATION; 88 } 89 if (!(mCurrentState & MEDIA_RECORDER_IDLE)) { 90 ALOGE("init called in an invalid state(%d)", mCurrentState); 91 return INVALID_OPERATION; 92 } 93 94 status_t ret = mMediaRecorder->init(); 95 if (OK != ret) { 96 ALOGV("init failed: %d", ret); 97 mCurrentState = MEDIA_RECORDER_ERROR; 98 return ret; 99 } 100 101 ret = mMediaRecorder->setListener(this); 102 if (OK != ret) { 103 ALOGV("setListener failed: %d", ret); 104 mCurrentState = MEDIA_RECORDER_ERROR; 105 return ret; 106 } 107 108 mCurrentState = MEDIA_RECORDER_INITIALIZED; 109 return ret; 110} 111 112status_t MediaRecorder::setVideoSource(int vs) 113{ 114 ALOGV("setVideoSource(%d)", vs); 115 if (mMediaRecorder == NULL) { 116 ALOGE("media recorder is not initialized yet"); 117 return INVALID_OPERATION; 118 } 119 if (mIsVideoSourceSet) { 120 ALOGE("video source has already been set"); 121 return INVALID_OPERATION; 122 } 123 if (mCurrentState & MEDIA_RECORDER_IDLE) { 124 ALOGV("Call init() since the media recorder is not initialized yet"); 125 status_t ret = init(); 126 if (OK != ret) { 127 return ret; 128 } 129 } 130 if (!(mCurrentState & MEDIA_RECORDER_INITIALIZED)) { 131 ALOGE("setVideoSource called in an invalid state(%d)", mCurrentState); 132 return INVALID_OPERATION; 133 } 134 135 // following call is made over the Binder Interface 136 status_t ret = mMediaRecorder->setVideoSource(vs); 137 138 if (OK != ret) { 139 ALOGV("setVideoSource failed: %d", ret); 140 mCurrentState = MEDIA_RECORDER_ERROR; 141 return ret; 142 } 143 mIsVideoSourceSet = true; 144 return ret; 145} 146 147status_t MediaRecorder::setAudioSource(int as) 148{ 149 ALOGV("setAudioSource(%d)", as); 150 if (mMediaRecorder == NULL) { 151 ALOGE("media recorder is not initialized yet"); 152 return INVALID_OPERATION; 153 } 154 if (mCurrentState & MEDIA_RECORDER_IDLE) { 155 ALOGV("Call init() since the media recorder is not initialized yet"); 156 status_t ret = init(); 157 if (OK != ret) { 158 return ret; 159 } 160 } 161 if (mIsAudioSourceSet) { 162 ALOGE("audio source has already been set"); 163 return INVALID_OPERATION; 164 } 165 if (!(mCurrentState & MEDIA_RECORDER_INITIALIZED)) { 166 ALOGE("setAudioSource called in an invalid state(%d)", mCurrentState); 167 return INVALID_OPERATION; 168 } 169 170 status_t ret = mMediaRecorder->setAudioSource(as); 171 if (OK != ret) { 172 ALOGV("setAudioSource failed: %d", ret); 173 mCurrentState = MEDIA_RECORDER_ERROR; 174 return ret; 175 } 176 mIsAudioSourceSet = true; 177 return ret; 178} 179 180status_t MediaRecorder::setOutputFormat(int of) 181{ 182 ALOGV("setOutputFormat(%d)", of); 183 if (mMediaRecorder == NULL) { 184 ALOGE("media recorder is not initialized yet"); 185 return INVALID_OPERATION; 186 } 187 if (!(mCurrentState & MEDIA_RECORDER_INITIALIZED)) { 188 ALOGE("setOutputFormat called in an invalid state: %d", mCurrentState); 189 return INVALID_OPERATION; 190 } 191 if (mIsVideoSourceSet 192 && of >= OUTPUT_FORMAT_AUDIO_ONLY_START //first non-video output format 193 && of < OUTPUT_FORMAT_AUDIO_ONLY_END) { 194 ALOGE("output format (%d) is meant for audio recording only" 195 " and incompatible with video recording", of); 196 return INVALID_OPERATION; 197 } 198 199 status_t ret = mMediaRecorder->setOutputFormat(of); 200 if (OK != ret) { 201 ALOGE("setOutputFormat failed: %d", ret); 202 mCurrentState = MEDIA_RECORDER_ERROR; 203 return ret; 204 } 205 mCurrentState = MEDIA_RECORDER_DATASOURCE_CONFIGURED; 206 return ret; 207} 208 209status_t MediaRecorder::setVideoEncoder(int ve) 210{ 211 ALOGV("setVideoEncoder(%d)", ve); 212 if (mMediaRecorder == NULL) { 213 ALOGE("media recorder is not initialized yet"); 214 return INVALID_OPERATION; 215 } 216 if (!mIsVideoSourceSet) { 217 ALOGE("try to set the video encoder without setting the video source first"); 218 return INVALID_OPERATION; 219 } 220 if (mIsVideoEncoderSet) { 221 ALOGE("video encoder has already been set"); 222 return INVALID_OPERATION; 223 } 224 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 225 ALOGE("setVideoEncoder called in an invalid state(%d)", mCurrentState); 226 return INVALID_OPERATION; 227 } 228 229 status_t ret = mMediaRecorder->setVideoEncoder(ve); 230 if (OK != ret) { 231 ALOGV("setVideoEncoder failed: %d", ret); 232 mCurrentState = MEDIA_RECORDER_ERROR; 233 return ret; 234 } 235 mIsVideoEncoderSet = true; 236 return ret; 237} 238 239status_t MediaRecorder::setAudioEncoder(int ae) 240{ 241 ALOGV("setAudioEncoder(%d)", ae); 242 if (mMediaRecorder == NULL) { 243 ALOGE("media recorder is not initialized yet"); 244 return INVALID_OPERATION; 245 } 246 if (!mIsAudioSourceSet) { 247 ALOGE("try to set the audio encoder without setting the audio source first"); 248 return INVALID_OPERATION; 249 } 250 if (mIsAudioEncoderSet) { 251 ALOGE("audio encoder has already been set"); 252 return INVALID_OPERATION; 253 } 254 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 255 ALOGE("setAudioEncoder called in an invalid state(%d)", mCurrentState); 256 return INVALID_OPERATION; 257 } 258 259 status_t ret = mMediaRecorder->setAudioEncoder(ae); 260 if (OK != ret) { 261 ALOGV("setAudioEncoder failed: %d", ret); 262 mCurrentState = MEDIA_RECORDER_ERROR; 263 return ret; 264 } 265 mIsAudioEncoderSet = true; 266 return ret; 267} 268 269status_t MediaRecorder::setOutputFile(int fd, int64_t offset, int64_t length) 270{ 271 ALOGV("setOutputFile(%d, %" PRId64 ", %" PRId64 ")", fd, offset, length); 272 if (mMediaRecorder == NULL) { 273 ALOGE("media recorder is not initialized yet"); 274 return INVALID_OPERATION; 275 } 276 if (mIsOutputFileSet) { 277 ALOGE("output file has already been set"); 278 return INVALID_OPERATION; 279 } 280 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 281 ALOGE("setOutputFile called in an invalid state(%d)", mCurrentState); 282 return INVALID_OPERATION; 283 } 284 285 // It appears that if an invalid file descriptor is passed through 286 // binder calls, the server-side of the inter-process function call 287 // is skipped. As a result, the check at the server-side to catch 288 // the invalid file descritpor never gets invoked. This is to workaround 289 // this issue by checking the file descriptor first before passing 290 // it through binder call. 291 if (fd < 0) { 292 ALOGE("Invalid file descriptor: %d", fd); 293 return BAD_VALUE; 294 } 295 296 status_t ret = mMediaRecorder->setOutputFile(fd, offset, length); 297 if (OK != ret) { 298 ALOGV("setOutputFile failed: %d", ret); 299 mCurrentState = MEDIA_RECORDER_ERROR; 300 return ret; 301 } 302 mIsOutputFileSet = true; 303 return ret; 304} 305 306status_t MediaRecorder::setVideoSize(int width, int height) 307{ 308 ALOGV("setVideoSize(%d, %d)", width, height); 309 if (mMediaRecorder == NULL) { 310 ALOGE("media recorder is not initialized yet"); 311 return INVALID_OPERATION; 312 } 313 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 314 ALOGE("setVideoSize called in an invalid state: %d", mCurrentState); 315 return INVALID_OPERATION; 316 } 317 if (!mIsVideoSourceSet) { 318 ALOGE("Cannot set video size without setting video source first"); 319 return INVALID_OPERATION; 320 } 321 322 status_t ret = mMediaRecorder->setVideoSize(width, height); 323 if (OK != ret) { 324 ALOGE("setVideoSize failed: %d", ret); 325 mCurrentState = MEDIA_RECORDER_ERROR; 326 return ret; 327 } 328 329 return ret; 330} 331 332// Query a SurfaceMediaSurface through the Mediaserver, over the 333// binder interface. This is used by the Filter Framework (MediaEncoder) 334// to get an <IGraphicBufferProducer> object to hook up to ANativeWindow. 335sp<IGraphicBufferProducer> MediaRecorder:: 336 querySurfaceMediaSourceFromMediaServer() 337{ 338 Mutex::Autolock _l(mLock); 339 mSurfaceMediaSource = 340 mMediaRecorder->querySurfaceMediaSource(); 341 if (mSurfaceMediaSource == NULL) { 342 ALOGE("SurfaceMediaSource could not be initialized!"); 343 } 344 return mSurfaceMediaSource; 345} 346 347 348 349status_t MediaRecorder::setInputSurface(const sp<PersistentSurface>& surface) 350{ 351 ALOGV("setInputSurface"); 352 if (mMediaRecorder == NULL) { 353 ALOGE("media recorder is not initialized yet"); 354 return INVALID_OPERATION; 355 } 356 bool isInvalidState = (mCurrentState & 357 (MEDIA_RECORDER_PREPARED | 358 MEDIA_RECORDER_RECORDING)); 359 if (isInvalidState) { 360 ALOGE("setInputSurface is called in an invalid state: %d", mCurrentState); 361 return INVALID_OPERATION; 362 } 363 364 return mMediaRecorder->setInputSurface(surface->getBufferConsumer()); 365} 366 367status_t MediaRecorder::setVideoFrameRate(int frames_per_second) 368{ 369 ALOGV("setVideoFrameRate(%d)", frames_per_second); 370 if (mMediaRecorder == NULL) { 371 ALOGE("media recorder is not initialized yet"); 372 return INVALID_OPERATION; 373 } 374 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 375 ALOGE("setVideoFrameRate called in an invalid state: %d", mCurrentState); 376 return INVALID_OPERATION; 377 } 378 if (!mIsVideoSourceSet) { 379 ALOGE("Cannot set video frame rate without setting video source first"); 380 return INVALID_OPERATION; 381 } 382 383 status_t ret = mMediaRecorder->setVideoFrameRate(frames_per_second); 384 if (OK != ret) { 385 ALOGE("setVideoFrameRate failed: %d", ret); 386 mCurrentState = MEDIA_RECORDER_ERROR; 387 return ret; 388 } 389 return ret; 390} 391 392status_t MediaRecorder::setParameters(const String8& params) { 393 ALOGV("setParameters(%s)", params.string()); 394 if (mMediaRecorder == NULL) { 395 ALOGE("media recorder is not initialized yet"); 396 return INVALID_OPERATION; 397 } 398 399 bool isInvalidState = (mCurrentState & 400 (MEDIA_RECORDER_PREPARED | 401 MEDIA_RECORDER_RECORDING | 402 MEDIA_RECORDER_ERROR)); 403 if (isInvalidState) { 404 ALOGE("setParameters is called in an invalid state: %d", mCurrentState); 405 return INVALID_OPERATION; 406 } 407 408 status_t ret = mMediaRecorder->setParameters(params); 409 if (OK != ret) { 410 ALOGE("setParameters(%s) failed: %d", params.string(), ret); 411 // Do not change our current state to MEDIA_RECORDER_ERROR, failures 412 // of the only currently supported parameters, "max-duration" and 413 // "max-filesize" are _not_ fatal. 414 } 415 416 return ret; 417} 418 419status_t MediaRecorder::prepare() 420{ 421 ALOGV("prepare"); 422 if (mMediaRecorder == NULL) { 423 ALOGE("media recorder is not initialized yet"); 424 return INVALID_OPERATION; 425 } 426 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 427 ALOGE("prepare called in an invalid state: %d", mCurrentState); 428 return INVALID_OPERATION; 429 } 430 if (mIsAudioSourceSet != mIsAudioEncoderSet) { 431 if (mIsAudioSourceSet) { 432 ALOGE("audio source is set, but audio encoder is not set"); 433 } else { // must not happen, since setAudioEncoder checks this already 434 ALOGE("audio encoder is set, but audio source is not set"); 435 } 436 return INVALID_OPERATION; 437 } 438 439 if (mIsVideoSourceSet != mIsVideoEncoderSet) { 440 if (mIsVideoSourceSet) { 441 ALOGE("video source is set, but video encoder is not set"); 442 } else { // must not happen, since setVideoEncoder checks this already 443 ALOGE("video encoder is set, but video source is not set"); 444 } 445 return INVALID_OPERATION; 446 } 447 448 status_t ret = mMediaRecorder->prepare(); 449 if (OK != ret) { 450 ALOGE("prepare failed: %d", ret); 451 mCurrentState = MEDIA_RECORDER_ERROR; 452 return ret; 453 } 454 mCurrentState = MEDIA_RECORDER_PREPARED; 455 return ret; 456} 457 458status_t MediaRecorder::getMaxAmplitude(int* max) 459{ 460 ALOGV("getMaxAmplitude"); 461 if (mMediaRecorder == NULL) { 462 ALOGE("media recorder is not initialized yet"); 463 return INVALID_OPERATION; 464 } 465 if (mCurrentState & MEDIA_RECORDER_ERROR) { 466 ALOGE("getMaxAmplitude called in an invalid state: %d", mCurrentState); 467 return INVALID_OPERATION; 468 } 469 470 status_t ret = mMediaRecorder->getMaxAmplitude(max); 471 if (OK != ret) { 472 ALOGE("getMaxAmplitude failed: %d", ret); 473 mCurrentState = MEDIA_RECORDER_ERROR; 474 return ret; 475 } 476 return ret; 477} 478 479status_t MediaRecorder::start() 480{ 481 ALOGV("start"); 482 if (mMediaRecorder == NULL) { 483 ALOGE("media recorder is not initialized yet"); 484 return INVALID_OPERATION; 485 } 486 if (!(mCurrentState & MEDIA_RECORDER_PREPARED)) { 487 ALOGE("start called in an invalid state: %d", mCurrentState); 488 return INVALID_OPERATION; 489 } 490 491 status_t ret = mMediaRecorder->start(); 492 if (OK != ret) { 493 ALOGE("start failed: %d", ret); 494 mCurrentState = MEDIA_RECORDER_ERROR; 495 return ret; 496 } 497 mCurrentState = MEDIA_RECORDER_RECORDING; 498 return ret; 499} 500 501status_t MediaRecorder::stop() 502{ 503 ALOGV("stop"); 504 if (mMediaRecorder == NULL) { 505 ALOGE("media recorder is not initialized yet"); 506 return INVALID_OPERATION; 507 } 508 if (!(mCurrentState & MEDIA_RECORDER_RECORDING)) { 509 ALOGE("stop called in an invalid state: %d", mCurrentState); 510 return INVALID_OPERATION; 511 } 512 513 status_t ret = mMediaRecorder->stop(); 514 if (OK != ret) { 515 ALOGE("stop failed: %d", ret); 516 mCurrentState = MEDIA_RECORDER_ERROR; 517 return ret; 518 } 519 520 // FIXME: 521 // stop and reset are semantically different. 522 // We treat them the same for now, and will change this in the future. 523 doCleanUp(); 524 mCurrentState = MEDIA_RECORDER_IDLE; 525 return ret; 526} 527 528// Reset should be OK in any state 529status_t MediaRecorder::reset() 530{ 531 ALOGV("reset"); 532 if (mMediaRecorder == NULL) { 533 ALOGE("media recorder is not initialized yet"); 534 return INVALID_OPERATION; 535 } 536 537 doCleanUp(); 538 status_t ret = UNKNOWN_ERROR; 539 switch (mCurrentState) { 540 case MEDIA_RECORDER_IDLE: 541 ret = OK; 542 break; 543 544 case MEDIA_RECORDER_RECORDING: 545 case MEDIA_RECORDER_DATASOURCE_CONFIGURED: 546 case MEDIA_RECORDER_PREPARED: 547 case MEDIA_RECORDER_ERROR: { 548 ret = doReset(); 549 if (OK != ret) { 550 return ret; // No need to continue 551 } 552 } // Intentional fall through 553 case MEDIA_RECORDER_INITIALIZED: 554 ret = close(); 555 break; 556 557 default: { 558 ALOGE("Unexpected non-existing state: %d", mCurrentState); 559 break; 560 } 561 } 562 return ret; 563} 564 565status_t MediaRecorder::pause() 566{ 567 ALOGV("pause"); 568 if (mMediaRecorder == NULL) { 569 ALOGE("media recorder is not initialized yet"); 570 return INVALID_OPERATION; 571 } 572 if (!(mCurrentState & MEDIA_RECORDER_RECORDING)) { 573 ALOGE("stop called in an invalid state: %d", mCurrentState); 574 return INVALID_OPERATION; 575 } 576 577 status_t ret = mMediaRecorder->pause(); 578 if (OK != ret) { 579 ALOGE("pause failed: %d", ret); 580 mCurrentState = MEDIA_RECORDER_ERROR; 581 return ret; 582 } 583 584 return ret; 585} 586 587status_t MediaRecorder::resume() 588{ 589 ALOGV("resume"); 590 if (mMediaRecorder == NULL) { 591 ALOGE("media recorder is not initialized yet"); 592 return INVALID_OPERATION; 593 } 594 if (!(mCurrentState & MEDIA_RECORDER_RECORDING)) { 595 ALOGE("resume called in an invalid state: %d", mCurrentState); 596 return INVALID_OPERATION; 597 } 598 599 status_t ret = mMediaRecorder->resume(); 600 if (OK != ret) { 601 ALOGE("resume failed: %d", ret); 602 mCurrentState = MEDIA_RECORDER_ERROR; 603 return ret; 604 } 605 606 return ret; 607} 608 609status_t MediaRecorder::close() 610{ 611 ALOGV("close"); 612 if (!(mCurrentState & MEDIA_RECORDER_INITIALIZED)) { 613 ALOGE("close called in an invalid state: %d", mCurrentState); 614 return INVALID_OPERATION; 615 } 616 status_t ret = mMediaRecorder->close(); 617 if (OK != ret) { 618 ALOGE("close failed: %d", ret); 619 mCurrentState = MEDIA_RECORDER_ERROR; 620 return UNKNOWN_ERROR; 621 } else { 622 mCurrentState = MEDIA_RECORDER_IDLE; 623 } 624 return ret; 625} 626 627status_t MediaRecorder::doReset() 628{ 629 ALOGV("doReset"); 630 status_t ret = mMediaRecorder->reset(); 631 if (OK != ret) { 632 ALOGE("doReset failed: %d", ret); 633 mCurrentState = MEDIA_RECORDER_ERROR; 634 return ret; 635 } else { 636 mCurrentState = MEDIA_RECORDER_INITIALIZED; 637 } 638 return ret; 639} 640 641void MediaRecorder::doCleanUp() 642{ 643 ALOGV("doCleanUp"); 644 mIsAudioSourceSet = false; 645 mIsVideoSourceSet = false; 646 mIsAudioEncoderSet = false; 647 mIsVideoEncoderSet = false; 648 mIsOutputFileSet = false; 649} 650 651// Release should be OK in any state 652status_t MediaRecorder::release() 653{ 654 ALOGV("release"); 655 if (mMediaRecorder != NULL) { 656 return mMediaRecorder->release(); 657 } 658 return INVALID_OPERATION; 659} 660 661MediaRecorder::MediaRecorder(const String16& opPackageName) : mSurfaceMediaSource(NULL) 662{ 663 ALOGV("constructor"); 664 665 const sp<IMediaPlayerService> service(getMediaPlayerService()); 666 if (service != NULL) { 667 mMediaRecorder = service->createMediaRecorder(opPackageName); 668 } 669 if (mMediaRecorder != NULL) { 670 mCurrentState = MEDIA_RECORDER_IDLE; 671 } 672 673 674 doCleanUp(); 675} 676 677status_t MediaRecorder::initCheck() 678{ 679 return mMediaRecorder != 0 ? NO_ERROR : NO_INIT; 680} 681 682MediaRecorder::~MediaRecorder() 683{ 684 ALOGV("destructor"); 685 if (mMediaRecorder != NULL) { 686 mMediaRecorder.clear(); 687 } 688 689 if (mSurfaceMediaSource != NULL) { 690 mSurfaceMediaSource.clear(); 691 } 692} 693 694status_t MediaRecorder::setListener(const sp<MediaRecorderListener>& listener) 695{ 696 ALOGV("setListener"); 697 Mutex::Autolock _l(mLock); 698 mListener = listener; 699 700 return NO_ERROR; 701} 702 703status_t MediaRecorder::setClientName(const String16& clientName) 704{ 705 ALOGV("setClientName"); 706 if (mMediaRecorder == NULL) { 707 ALOGE("media recorder is not initialized yet"); 708 return INVALID_OPERATION; 709 } 710 bool isInvalidState = (mCurrentState & 711 (MEDIA_RECORDER_PREPARED | 712 MEDIA_RECORDER_RECORDING | 713 MEDIA_RECORDER_ERROR)); 714 if (isInvalidState) { 715 ALOGE("setClientName is called in an invalid state: %d", mCurrentState); 716 return INVALID_OPERATION; 717 } 718 719 mMediaRecorder->setClientName(clientName); 720 721 return NO_ERROR; 722} 723 724void MediaRecorder::notify(int msg, int ext1, int ext2) 725{ 726 ALOGV("message received msg=%d, ext1=%d, ext2=%d", msg, ext1, ext2); 727 728 sp<MediaRecorderListener> listener; 729 mLock.lock(); 730 listener = mListener; 731 mLock.unlock(); 732 733 if (listener != NULL) { 734 Mutex::Autolock _l(mNotifyLock); 735 ALOGV("callback application"); 736 listener->notify(msg, ext1, ext2); 737 ALOGV("back from callback"); 738 } 739} 740 741void MediaRecorder::died() 742{ 743 ALOGV("died"); 744 notify(MEDIA_RECORDER_EVENT_ERROR, MEDIA_ERROR_SERVER_DIED, 0); 745} 746 747} // namespace android 748