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