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 260 status_t ret = mMediaRecorder->setAudioEncoder(ae); 261 if (OK != ret) { 262 ALOGV("setAudioEncoder failed: %d", ret); 263 mCurrentState = MEDIA_RECORDER_ERROR; 264 return ret; 265 } 266 mIsAudioEncoderSet = true; 267 return ret; 268} 269 270status_t MediaRecorder::setOutputFile(int fd) 271{ 272 ALOGV("setOutputFile(%d)", fd); 273 if (mMediaRecorder == NULL) { 274 ALOGE("media recorder is not initialized yet"); 275 return INVALID_OPERATION; 276 } 277 if (mIsOutputFileSet) { 278 ALOGE("output file has already been set"); 279 return INVALID_OPERATION; 280 } 281 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 282 ALOGE("setOutputFile called in an invalid state(%d)", mCurrentState); 283 return INVALID_OPERATION; 284 } 285 286 // It appears that if an invalid file descriptor is passed through 287 // binder calls, the server-side of the inter-process function call 288 // is skipped. As a result, the check at the server-side to catch 289 // the invalid file descritpor never gets invoked. This is to workaround 290 // this issue by checking the file descriptor first before passing 291 // it through binder call. 292 int flags = fcntl(fd, F_GETFL); 293 if (flags == -1) { 294 ALOGE("Fail to get File Status Flags err: %s", strerror(errno)); 295 } 296 // fd must be in read-write mode or write-only mode. 297 if ((flags & (O_RDWR | O_WRONLY)) == 0) { 298 ALOGE("File descriptor is not in read-write mode or write-only mode"); 299 return BAD_VALUE; 300 } 301 302 status_t ret = mMediaRecorder->setOutputFile(fd); 303 if (OK != ret) { 304 ALOGE("setOutputFile failed: %d", ret); 305 mCurrentState = MEDIA_RECORDER_ERROR; 306 return ret; 307 } 308 mIsOutputFileSet = true; 309 return ret; 310} 311 312status_t MediaRecorder::setNextOutputFile(int fd) 313{ 314 ALOGV("setNextOutputFile(%d)", fd); 315 if (mMediaRecorder == NULL) { 316 ALOGE("media recorder is not initialized yet"); 317 return INVALID_OPERATION; 318 } 319 320 // It appears that if an invalid file descriptor is passed through 321 // binder calls, the server-side of the inter-process function call 322 // is skipped. As a result, the check at the server-side to catch 323 // the invalid file descritpor never gets invoked. This is to workaround 324 // this issue by checking the file descriptor first before passing 325 // it through binder call. 326 int flags = fcntl(fd, F_GETFL); 327 if (flags == -1) { 328 ALOGE("Fail to get File Status Flags err: %s", strerror(errno)); 329 } 330 // fd must be in read-write mode or write-only mode. 331 if ((flags & (O_RDWR | O_WRONLY)) == 0) { 332 ALOGE("File descriptor is not in read-write mode or write-only mode"); 333 return BAD_VALUE; 334 } 335 336 status_t ret = mMediaRecorder->setNextOutputFile(fd); 337 if (OK != ret) { 338 ALOGE("setNextOutputFile failed: %d", ret); 339 } 340 return ret; 341} 342 343status_t MediaRecorder::setVideoSize(int width, int height) 344{ 345 ALOGV("setVideoSize(%d, %d)", width, height); 346 if (mMediaRecorder == NULL) { 347 ALOGE("media recorder is not initialized yet"); 348 return INVALID_OPERATION; 349 } 350 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 351 ALOGE("setVideoSize called in an invalid state: %d", mCurrentState); 352 return INVALID_OPERATION; 353 } 354 if (!mIsVideoSourceSet) { 355 ALOGE("Cannot set video size without setting video source first"); 356 return INVALID_OPERATION; 357 } 358 359 status_t ret = mMediaRecorder->setVideoSize(width, height); 360 if (OK != ret) { 361 ALOGE("setVideoSize failed: %d", ret); 362 mCurrentState = MEDIA_RECORDER_ERROR; 363 return ret; 364 } 365 366 return ret; 367} 368 369// Query a SurfaceMediaSurface through the Mediaserver, over the 370// binder interface. This is used by the Filter Framework (MediaEncoder) 371// to get an <IGraphicBufferProducer> object to hook up to ANativeWindow. 372sp<IGraphicBufferProducer> MediaRecorder:: 373 querySurfaceMediaSourceFromMediaServer() 374{ 375 Mutex::Autolock _l(mLock); 376 mSurfaceMediaSource = 377 mMediaRecorder->querySurfaceMediaSource(); 378 if (mSurfaceMediaSource == NULL) { 379 ALOGE("SurfaceMediaSource could not be initialized!"); 380 } 381 return mSurfaceMediaSource; 382} 383 384 385 386status_t MediaRecorder::setInputSurface(const sp<PersistentSurface>& surface) 387{ 388 ALOGV("setInputSurface"); 389 if (mMediaRecorder == NULL) { 390 ALOGE("media recorder is not initialized yet"); 391 return INVALID_OPERATION; 392 } 393 bool isInvalidState = (mCurrentState & 394 (MEDIA_RECORDER_PREPARED | 395 MEDIA_RECORDER_RECORDING)); 396 if (isInvalidState) { 397 ALOGE("setInputSurface is called in an invalid state: %d", mCurrentState); 398 return INVALID_OPERATION; 399 } 400 401 return mMediaRecorder->setInputSurface(surface); 402} 403 404status_t MediaRecorder::setVideoFrameRate(int frames_per_second) 405{ 406 ALOGV("setVideoFrameRate(%d)", frames_per_second); 407 if (mMediaRecorder == NULL) { 408 ALOGE("media recorder is not initialized yet"); 409 return INVALID_OPERATION; 410 } 411 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 412 ALOGE("setVideoFrameRate called in an invalid state: %d", mCurrentState); 413 return INVALID_OPERATION; 414 } 415 if (!mIsVideoSourceSet) { 416 ALOGE("Cannot set video frame rate without setting video source first"); 417 return INVALID_OPERATION; 418 } 419 420 status_t ret = mMediaRecorder->setVideoFrameRate(frames_per_second); 421 if (OK != ret) { 422 ALOGE("setVideoFrameRate failed: %d", ret); 423 mCurrentState = MEDIA_RECORDER_ERROR; 424 return ret; 425 } 426 return ret; 427} 428 429status_t MediaRecorder::setParameters(const String8& params) { 430 ALOGV("setParameters(%s)", params.string()); 431 if (mMediaRecorder == NULL) { 432 ALOGE("media recorder is not initialized yet"); 433 return INVALID_OPERATION; 434 } 435 436 bool isInvalidState = (mCurrentState & 437 (MEDIA_RECORDER_PREPARED | 438 MEDIA_RECORDER_RECORDING | 439 MEDIA_RECORDER_ERROR)); 440 if (isInvalidState) { 441 ALOGE("setParameters is called in an invalid state: %d", mCurrentState); 442 return INVALID_OPERATION; 443 } 444 445 status_t ret = mMediaRecorder->setParameters(params); 446 if (OK != ret) { 447 ALOGE("setParameters(%s) failed: %d", params.string(), ret); 448 // Do not change our current state to MEDIA_RECORDER_ERROR, failures 449 // of the only currently supported parameters, "max-duration" and 450 // "max-filesize" are _not_ fatal. 451 } 452 453 return ret; 454} 455 456status_t MediaRecorder::prepare() 457{ 458 ALOGV("prepare"); 459 if (mMediaRecorder == NULL) { 460 ALOGE("media recorder is not initialized yet"); 461 return INVALID_OPERATION; 462 } 463 if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) { 464 ALOGE("prepare called in an invalid state: %d", mCurrentState); 465 return INVALID_OPERATION; 466 } 467 if (mIsAudioSourceSet != mIsAudioEncoderSet) { 468 if (mIsAudioSourceSet) { 469 ALOGE("audio source is set, but audio encoder is not set"); 470 } else { // must not happen, since setAudioEncoder checks this already 471 ALOGE("audio encoder is set, but audio source is not set"); 472 } 473 return INVALID_OPERATION; 474 } 475 476 if (mIsVideoSourceSet != mIsVideoEncoderSet) { 477 if (mIsVideoSourceSet) { 478 ALOGE("video source is set, but video encoder is not set"); 479 } else { // must not happen, since setVideoEncoder checks this already 480 ALOGE("video encoder is set, but video source is not set"); 481 } 482 return INVALID_OPERATION; 483 } 484 485 status_t ret = mMediaRecorder->prepare(); 486 if (OK != ret) { 487 ALOGE("prepare failed: %d", ret); 488 mCurrentState = MEDIA_RECORDER_ERROR; 489 return ret; 490 } 491 mCurrentState = MEDIA_RECORDER_PREPARED; 492 return ret; 493} 494 495status_t MediaRecorder::getMaxAmplitude(int* max) 496{ 497 ALOGV("getMaxAmplitude"); 498 if (mMediaRecorder == NULL) { 499 ALOGE("media recorder is not initialized yet"); 500 return INVALID_OPERATION; 501 } 502 if (mCurrentState & MEDIA_RECORDER_ERROR) { 503 ALOGE("getMaxAmplitude called in an invalid state: %d", mCurrentState); 504 return INVALID_OPERATION; 505 } 506 507 status_t ret = mMediaRecorder->getMaxAmplitude(max); 508 if (OK != ret) { 509 ALOGE("getMaxAmplitude failed: %d", ret); 510 mCurrentState = MEDIA_RECORDER_ERROR; 511 return ret; 512 } 513 return ret; 514} 515 516status_t MediaRecorder::getMetrics(Parcel *reply) { 517 518 ALOGV("getMetrics"); 519 520 status_t ret = mMediaRecorder->getMetrics(reply); 521 if (OK != ret) { 522 ALOGE("getMetrics failed: %d", ret); 523 } 524 return ret; 525} 526 527status_t MediaRecorder::start() 528{ 529 ALOGV("start"); 530 if (mMediaRecorder == NULL) { 531 ALOGE("media recorder is not initialized yet"); 532 return INVALID_OPERATION; 533 } 534 if (!(mCurrentState & MEDIA_RECORDER_PREPARED)) { 535 ALOGE("start called in an invalid state: %d", mCurrentState); 536 return INVALID_OPERATION; 537 } 538 539 status_t ret = mMediaRecorder->start(); 540 if (OK != ret) { 541 ALOGE("start failed: %d", ret); 542 mCurrentState = MEDIA_RECORDER_ERROR; 543 return ret; 544 } 545 mCurrentState = MEDIA_RECORDER_RECORDING; 546 return ret; 547} 548 549status_t MediaRecorder::stop() 550{ 551 ALOGV("stop"); 552 if (mMediaRecorder == NULL) { 553 ALOGE("media recorder is not initialized yet"); 554 return INVALID_OPERATION; 555 } 556 if (!(mCurrentState & MEDIA_RECORDER_RECORDING)) { 557 ALOGE("stop called in an invalid state: %d", mCurrentState); 558 return INVALID_OPERATION; 559 } 560 561 status_t ret = mMediaRecorder->stop(); 562 if (OK != ret) { 563 ALOGE("stop failed: %d", ret); 564 mCurrentState = MEDIA_RECORDER_ERROR; 565 return ret; 566 } 567 568 // FIXME: 569 // stop and reset are semantically different. 570 // We treat them the same for now, and will change this in the future. 571 doCleanUp(); 572 mCurrentState = MEDIA_RECORDER_IDLE; 573 return ret; 574} 575 576// Reset should be OK in any state 577status_t MediaRecorder::reset() 578{ 579 ALOGV("reset"); 580 if (mMediaRecorder == NULL) { 581 ALOGE("media recorder is not initialized yet"); 582 return INVALID_OPERATION; 583 } 584 585 doCleanUp(); 586 status_t ret = UNKNOWN_ERROR; 587 switch (mCurrentState) { 588 case MEDIA_RECORDER_IDLE: 589 ret = OK; 590 break; 591 592 case MEDIA_RECORDER_RECORDING: 593 case MEDIA_RECORDER_DATASOURCE_CONFIGURED: 594 case MEDIA_RECORDER_PREPARED: 595 case MEDIA_RECORDER_ERROR: { 596 ret = doReset(); 597 if (OK != ret) { 598 return ret; // No need to continue 599 } 600 } // Intentional fall through 601 case MEDIA_RECORDER_INITIALIZED: 602 ret = close(); 603 break; 604 605 default: { 606 ALOGE("Unexpected non-existing state: %d", mCurrentState); 607 break; 608 } 609 } 610 return ret; 611} 612 613status_t MediaRecorder::pause() 614{ 615 ALOGV("pause"); 616 if (mMediaRecorder == NULL) { 617 ALOGE("media recorder is not initialized yet"); 618 return INVALID_OPERATION; 619 } 620 if (!(mCurrentState & MEDIA_RECORDER_RECORDING)) { 621 ALOGE("stop called in an invalid state: %d", mCurrentState); 622 return INVALID_OPERATION; 623 } 624 625 status_t ret = mMediaRecorder->pause(); 626 if (OK != ret) { 627 ALOGE("pause failed: %d", ret); 628 mCurrentState = MEDIA_RECORDER_ERROR; 629 return ret; 630 } 631 632 return ret; 633} 634 635status_t MediaRecorder::resume() 636{ 637 ALOGV("resume"); 638 if (mMediaRecorder == NULL) { 639 ALOGE("media recorder is not initialized yet"); 640 return INVALID_OPERATION; 641 } 642 if (!(mCurrentState & MEDIA_RECORDER_RECORDING)) { 643 ALOGE("resume called in an invalid state: %d", mCurrentState); 644 return INVALID_OPERATION; 645 } 646 647 status_t ret = mMediaRecorder->resume(); 648 if (OK != ret) { 649 ALOGE("resume failed: %d", ret); 650 mCurrentState = MEDIA_RECORDER_ERROR; 651 return ret; 652 } 653 654 return ret; 655} 656 657status_t MediaRecorder::close() 658{ 659 ALOGV("close"); 660 if (!(mCurrentState & MEDIA_RECORDER_INITIALIZED)) { 661 ALOGE("close called in an invalid state: %d", mCurrentState); 662 return INVALID_OPERATION; 663 } 664 status_t ret = mMediaRecorder->close(); 665 if (OK != ret) { 666 ALOGE("close failed: %d", ret); 667 mCurrentState = MEDIA_RECORDER_ERROR; 668 return UNKNOWN_ERROR; 669 } else { 670 mCurrentState = MEDIA_RECORDER_IDLE; 671 } 672 return ret; 673} 674 675status_t MediaRecorder::doReset() 676{ 677 ALOGV("doReset"); 678 status_t ret = mMediaRecorder->reset(); 679 if (OK != ret) { 680 ALOGE("doReset failed: %d", ret); 681 mCurrentState = MEDIA_RECORDER_ERROR; 682 return ret; 683 } else { 684 mCurrentState = MEDIA_RECORDER_INITIALIZED; 685 } 686 return ret; 687} 688 689void MediaRecorder::doCleanUp() 690{ 691 ALOGV("doCleanUp"); 692 mIsAudioSourceSet = false; 693 mIsVideoSourceSet = false; 694 mIsAudioEncoderSet = false; 695 mIsVideoEncoderSet = false; 696 mIsOutputFileSet = false; 697} 698 699// Release should be OK in any state 700status_t MediaRecorder::release() 701{ 702 ALOGV("release"); 703 if (mMediaRecorder != NULL) { 704 return mMediaRecorder->release(); 705 } 706 return INVALID_OPERATION; 707} 708 709MediaRecorder::MediaRecorder(const String16& opPackageName) : mSurfaceMediaSource(NULL) 710{ 711 ALOGV("constructor"); 712 713 const sp<IMediaPlayerService> service(getMediaPlayerService()); 714 if (service != NULL) { 715 mMediaRecorder = service->createMediaRecorder(opPackageName); 716 } 717 if (mMediaRecorder != NULL) { 718 mCurrentState = MEDIA_RECORDER_IDLE; 719 } 720 721 722 doCleanUp(); 723} 724 725status_t MediaRecorder::initCheck() 726{ 727 return mMediaRecorder != 0 ? NO_ERROR : NO_INIT; 728} 729 730MediaRecorder::~MediaRecorder() 731{ 732 ALOGV("destructor"); 733 if (mMediaRecorder != NULL) { 734 mMediaRecorder.clear(); 735 } 736 737 if (mSurfaceMediaSource != NULL) { 738 mSurfaceMediaSource.clear(); 739 } 740} 741 742status_t MediaRecorder::setListener(const sp<MediaRecorderListener>& listener) 743{ 744 ALOGV("setListener"); 745 Mutex::Autolock _l(mLock); 746 mListener = listener; 747 748 return NO_ERROR; 749} 750 751status_t MediaRecorder::setClientName(const String16& clientName) 752{ 753 ALOGV("setClientName"); 754 if (mMediaRecorder == NULL) { 755 ALOGE("media recorder is not initialized yet"); 756 return INVALID_OPERATION; 757 } 758 bool isInvalidState = (mCurrentState & 759 (MEDIA_RECORDER_PREPARED | 760 MEDIA_RECORDER_RECORDING | 761 MEDIA_RECORDER_ERROR)); 762 if (isInvalidState) { 763 ALOGE("setClientName is called in an invalid state: %d", mCurrentState); 764 return INVALID_OPERATION; 765 } 766 767 mMediaRecorder->setClientName(clientName); 768 769 return NO_ERROR; 770} 771 772void MediaRecorder::notify(int msg, int ext1, int ext2) 773{ 774 ALOGV("message received msg=%d, ext1=%d, ext2=%d", msg, ext1, ext2); 775 776 sp<MediaRecorderListener> listener; 777 mLock.lock(); 778 listener = mListener; 779 mLock.unlock(); 780 781 if (listener != NULL) { 782 Mutex::Autolock _l(mNotifyLock); 783 ALOGV("callback application"); 784 listener->notify(msg, ext1, ext2); 785 ALOGV("back from callback"); 786 } 787} 788 789void MediaRecorder::died() 790{ 791 ALOGV("died"); 792 notify(MEDIA_RECORDER_EVENT_ERROR, MEDIA_ERROR_SERVER_DIED, 0); 793} 794 795} // namespace android 796