media/jni/android_media_MediaRecorder.cpp

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <assert.h>
  18 #include <fcntl.h>
  19 #include <inttypes.h>
  20 #include <limits.h>
  21 #include <stdio.h>
  22 #include <unistd.h>
  23
  24 //#define LOG_NDEBUG 0
  25 #define LOG_TAG "MediaRecorderJNI"
  26 #include <utils/Log.h>
  27
  28 #include <gui/Surface.h>
  29 #include <camera/Camera.h>
  30 #include <media/mediarecorder.h>
  31 #include <media/MediaAnalyticsItem.h>
  32 #include <media/stagefright/PersistentSurface.h>
  33 #include <utils/threads.h>
  34
  35 #include <ScopedUtfChars.h>
  36
  37 #include "jni.h"
  38 #include "JNIHelp.h"
  39 #include "android_media_MediaMetricsJNI.h"
  40 #include "android_runtime/AndroidRuntime.h"
  41
  42 #include <system/audio.h>
  43 #include <android_runtime/android_view_Surface.h>
  44
  45 // ----------------------------------------------------------------------------
  46
  47 using namespace android;
  48
  49 // ----------------------------------------------------------------------------
  50
  51 // helper function to extract a native Camera object from a Camera Java object
  52 extern sp<Camera> get_native_camera(JNIEnv *env, jobject thiz, struct JNICameraContext** context);
  53 extern sp<PersistentSurface>
  54 android_media_MediaCodec_getPersistentInputSurface(JNIEnv* env, jobject object);
  55
  56 struct fields_t {
  57     jfieldID    context;
  58     jfieldID    surface;
  59
  60     jmethodID   post_event;
  61 };
  62 static fields_t fields;
  63
  64 static Mutex sLock;
  65
  66 // ----------------------------------------------------------------------------
  67 // ref-counted object for callbacks
  68 class JNIMediaRecorderListener: public MediaRecorderListener
  69 {
  70 public:
  71     JNIMediaRecorderListener(JNIEnv* env, jobject thiz, jobject weak_thiz);
  72     ~JNIMediaRecorderListener();
  73     void notify(int msg, int ext1, int ext2);
  74 private:
  75     JNIMediaRecorderListener();
  76     jclass      mClass;     // Reference to MediaRecorder class
  77     jobject     mObject;    // Weak ref to MediaRecorder Java object to call on
  78 };
  79
  80 JNIMediaRecorderListener::JNIMediaRecorderListener(JNIEnv* env, jobject thiz, jobject weak_thiz)
  81 {
  82
  83     // Hold onto the MediaRecorder class for use in calling the static method
  84     // that posts events to the application thread.
  85     jclass clazz = env->GetObjectClass(thiz);
  86     if (clazz == NULL) {
  87         ALOGE("Can't find android/media/MediaRecorder");
  88         jniThrowException(env, "java/lang/Exception", NULL);
  89         return;
  90     }
  91     mClass = (jclass)env->NewGlobalRef(clazz);
  92
  93     // We use a weak reference so the MediaRecorder object can be garbage collected.
  94     // The reference is only used as a proxy for callbacks.
  95     mObject  = env->NewGlobalRef(weak_thiz);
  96 }
  97
  98 JNIMediaRecorderListener::~JNIMediaRecorderListener()
  99 {
 100     // remove global references
 101     JNIEnv *env = AndroidRuntime::getJNIEnv();
 102     env->DeleteGlobalRef(mObject);
 103     env->DeleteGlobalRef(mClass);
 104 }
 105
 106 void JNIMediaRecorderListener::notify(int msg, int ext1, int ext2)
 107 {
 108     ALOGV("JNIMediaRecorderListener::notify");
 109
 110     JNIEnv *env = AndroidRuntime::getJNIEnv();
 111     env->CallStaticVoidMethod(mClass, fields.post_event, mObject, msg, ext1, ext2, NULL);
 112 }
 113
 114 // ----------------------------------------------------------------------------
 115
 116 static sp<Surface> get_surface(JNIEnv* env, jobject clazz)
 117 {
 118     ALOGV("get_surface");
 119     return android_view_Surface_getSurface(env, clazz);
 120 }
 121
 122 static sp<PersistentSurface> get_persistentSurface(JNIEnv* env, jobject object)
 123 {
 124     ALOGV("get_persistentSurface");
 125     return android_media_MediaCodec_getPersistentInputSurface(env, object);
 126 }
 127
 128 // Returns true if it throws an exception.
 129 static bool process_media_recorder_call(JNIEnv *env, status_t opStatus, const char* exception, const char* message)
 130 {
 131     ALOGV("process_media_recorder_call");
 132     if (opStatus == (status_t)INVALID_OPERATION) {
 133         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 134         return true;
 135     } else if (opStatus != (status_t)OK) {
 136         jniThrowException(env, exception, message);
 137         return true;
 138     }
 139     return false;
 140 }
 141
 142 static sp<MediaRecorder> getMediaRecorder(JNIEnv* env, jobject thiz)
 143 {
 144     Mutex::Autolock l(sLock);
 145     MediaRecorder* const p = (MediaRecorder*)env->GetLongField(thiz, fields.context);
 146     return sp<MediaRecorder>(p);
 147 }
 148
 149 static sp<MediaRecorder> setMediaRecorder(JNIEnv* env, jobject thiz, const sp<MediaRecorder>& recorder)
 150 {
 151     Mutex::Autolock l(sLock);
 152     sp<MediaRecorder> old = (MediaRecorder*)env->GetLongField(thiz, fields.context);
 153     if (recorder.get()) {
 154         recorder->incStrong(thiz);
 155     }
 156     if (old != 0) {
 157         old->decStrong(thiz);
 158     }
 159     env->SetLongField(thiz, fields.context, (jlong)recorder.get());
 160     return old;
 161 }
 162
 163
 164 static void android_media_MediaRecorder_setCamera(JNIEnv* env, jobject thiz, jobject camera)
 165 {
 166     // we should not pass a null camera to get_native_camera() call.
 167     if (camera == NULL) {
 168         jniThrowNullPointerException(env, "camera object is a NULL pointer");
 169         return;
 170     }
 171     sp<Camera> c = get_native_camera(env, camera, NULL);
 172     if (c == NULL) {
 173         // get_native_camera will throw an exception in this case
 174         return;
 175     }
 176     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 177     if (mr == NULL) {
 178         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 179         return;
 180     }
 181     process_media_recorder_call(env, mr->setCamera(c->remote(), c->getRecordingProxy()),
 182             "java/lang/RuntimeException", "setCamera failed.");
 183 }
 184
 185 static void
 186 android_media_MediaRecorder_setVideoSource(JNIEnv *env, jobject thiz, jint vs)
 187 {
 188     ALOGV("setVideoSource(%d)", vs);
 189     if (vs < VIDEO_SOURCE_DEFAULT || vs >= VIDEO_SOURCE_LIST_END) {
 190         jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid video source");
 191         return;
 192     }
 193     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 194     if (mr == NULL) {
 195         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 196         return;
 197     }
 198     process_media_recorder_call(env, mr->setVideoSource(vs), "java/lang/RuntimeException", "setVideoSource failed.");
 199 }
 200
 201 static void
 202 android_media_MediaRecorder_setAudioSource(JNIEnv *env, jobject thiz, jint as)
 203 {
 204     ALOGV("setAudioSource(%d)", as);
 205     if (as < AUDIO_SOURCE_DEFAULT ||
 206         (as >= AUDIO_SOURCE_CNT && as != AUDIO_SOURCE_FM_TUNER)) {
 207         jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid audio source");
 208         return;
 209     }
 210
 211     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 212     if (mr == NULL) {
 213         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 214         return;
 215     }
 216     process_media_recorder_call(env, mr->setAudioSource(as), "java/lang/RuntimeException", "setAudioSource failed.");
 217 }
 218
 219 static void
 220 android_media_MediaRecorder_setOutputFormat(JNIEnv *env, jobject thiz, jint of)
 221 {
 222     ALOGV("setOutputFormat(%d)", of);
 223     if (of < OUTPUT_FORMAT_DEFAULT || of >= OUTPUT_FORMAT_LIST_END) {
 224         jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid output format");
 225         return;
 226     }
 227     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 228     if (mr == NULL) {
 229         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 230         return;
 231     }
 232     process_media_recorder_call(env, mr->setOutputFormat(of), "java/lang/RuntimeException", "setOutputFormat failed.");
 233 }
 234
 235 static void
 236 android_media_MediaRecorder_setVideoEncoder(JNIEnv *env, jobject thiz, jint ve)
 237 {
 238     ALOGV("setVideoEncoder(%d)", ve);
 239     if (ve < VIDEO_ENCODER_DEFAULT || ve >= VIDEO_ENCODER_LIST_END) {
 240         jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid video encoder");
 241         return;
 242     }
 243     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 244     if (mr == NULL) {
 245         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 246         return;
 247     }
 248     process_media_recorder_call(env, mr->setVideoEncoder(ve), "java/lang/RuntimeException", "setVideoEncoder failed.");
 249 }
 250
 251 static void
 252 android_media_MediaRecorder_setAudioEncoder(JNIEnv *env, jobject thiz, jint ae)
 253 {
 254     ALOGV("setAudioEncoder(%d)", ae);
 255     if (ae < AUDIO_ENCODER_DEFAULT || ae >= AUDIO_ENCODER_LIST_END) {
 256         jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid audio encoder");
 257         return;
 258     }
 259     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 260     if (mr == NULL) {
 261         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 262         return;
 263     }
 264     process_media_recorder_call(env, mr->setAudioEncoder(ae), "java/lang/RuntimeException", "setAudioEncoder failed.");
 265 }
 266
 267 static void
 268 android_media_MediaRecorder_setParameter(JNIEnv *env, jobject thiz, jstring params)
 269 {
 270     ALOGV("setParameter()");
 271     if (params == NULL)
 272     {
 273         ALOGE("Invalid or empty params string.  This parameter will be ignored.");
 274         return;
 275     }
 276
 277     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 278     if (mr == NULL) {
 279         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 280         return;
 281     }
 282
 283     const char* params8 = env->GetStringUTFChars(params, NULL);
 284     if (params8 == NULL)
 285     {
 286         ALOGE("Failed to covert jstring to String8.  This parameter will be ignored.");
 287         return;
 288     }
 289
 290     process_media_recorder_call(env, mr->setParameters(String8(params8)), "java/lang/RuntimeException", "setParameter failed.");
 291     env->ReleaseStringUTFChars(params,params8);
 292 }
 293
 294 static void
 295 android_media_MediaRecorder_setOutputFileFD(JNIEnv *env, jobject thiz, jobject fileDescriptor)
 296 {
 297     ALOGV("setOutputFile");
 298     if (fileDescriptor == NULL) {
 299         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
 300         return;
 301     }
 302     int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
 303     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 304     if (mr == NULL) {
 305         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 306         return;
 307     }
 308     status_t opStatus = mr->setOutputFile(fd);
 309     process_media_recorder_call(env, opStatus, "java/io/IOException", "setOutputFile failed.");
 310 }
 311
 312 static void
 313 android_media_MediaRecorder_setNextOutputFileFD(JNIEnv *env, jobject thiz, jobject fileDescriptor)
 314 {
 315     ALOGV("setNextOutputFile");
 316     if (fileDescriptor == NULL) {
 317         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
 318         return;
 319     }
 320     int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
 321     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 322     if (mr == NULL) {
 323         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 324         return;
 325     }
 326     status_t opStatus = mr->setNextOutputFile(fd);
 327     process_media_recorder_call(env, opStatus, "java/io/IOException", "setOutputFile failed.");
 328 }
 329
 330 static void
 331 android_media_MediaRecorder_setVideoSize(JNIEnv *env, jobject thiz, jint width, jint height)
 332 {
 333     ALOGV("setVideoSize(%d, %d)", width, height);
 334     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 335     if (mr == NULL) {
 336         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 337         return;
 338     }
 339
 340     if (width <= 0 || height <= 0) {
 341         jniThrowException(env, "java/lang/IllegalArgumentException", "invalid video size");
 342         return;
 343     }
 344     process_media_recorder_call(env, mr->setVideoSize(width, height), "java/lang/RuntimeException", "setVideoSize failed.");
 345 }
 346
 347 static void
 348 android_media_MediaRecorder_setVideoFrameRate(JNIEnv *env, jobject thiz, jint rate)
 349 {
 350     ALOGV("setVideoFrameRate(%d)", rate);
 351     if (rate <= 0) {
 352         jniThrowException(env, "java/lang/IllegalArgumentException", "invalid frame rate");
 353         return;
 354     }
 355     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 356     if (mr == NULL) {
 357         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 358         return;
 359     }
 360     process_media_recorder_call(env, mr->setVideoFrameRate(rate), "java/lang/RuntimeException", "setVideoFrameRate failed.");
 361 }
 362
 363 static void
 364 android_media_MediaRecorder_setMaxDuration(JNIEnv *env, jobject thiz, jint max_duration_ms)
 365 {
 366     ALOGV("setMaxDuration(%d)", max_duration_ms);
 367     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 368     if (mr == NULL) {
 369         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 370         return;
 371     }
 372
 373     char params[64];
 374     sprintf(params, "max-duration=%d", max_duration_ms);
 375
 376     process_media_recorder_call(env, mr->setParameters(String8(params)), "java/lang/RuntimeException", "setMaxDuration failed.");
 377 }
 378
 379 static void
 380 android_media_MediaRecorder_setMaxFileSize(
 381         JNIEnv *env, jobject thiz, jlong max_filesize_bytes)
 382 {
 383     ALOGV("setMaxFileSize(%lld)", (long long)max_filesize_bytes);
 384     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 385     if (mr == NULL) {
 386         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 387         return;
 388     }
 389
 390     char params[64];
 391     sprintf(params, "max-filesize=%" PRId64, max_filesize_bytes);
 392
 393     process_media_recorder_call(env, mr->setParameters(String8(params)), "java/lang/RuntimeException", "setMaxFileSize failed.");
 394 }
 395
 396 static void
 397 android_media_MediaRecorder_prepare(JNIEnv *env, jobject thiz)
 398 {
 399     ALOGV("prepare");
 400     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 401     if (mr == NULL) {
 402         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 403         return;
 404     }
 405
 406     jobject surface = env->GetObjectField(thiz, fields.surface);
 407     if (surface != NULL) {
 408         const sp<Surface> native_surface = get_surface(env, surface);
 409
 410         // The application may misbehave and
 411         // the preview surface becomes unavailable
 412         if (native_surface.get() == 0) {
 413             ALOGE("Application lost the surface");
 414             jniThrowException(env, "java/io/IOException", "invalid preview surface");
 415             return;
 416         }
 417
 418         ALOGI("prepare: surface=%p", native_surface.get());
 419         if (process_media_recorder_call(env, mr->setPreviewSurface(native_surface->getIGraphicBufferProducer()), "java/lang/RuntimeException", "setPreviewSurface failed.")) {
 420             return;
 421         }
 422     }
 423     process_media_recorder_call(env, mr->prepare(), "java/io/IOException", "prepare failed.");
 424 }
 425
 426 static jint
 427 android_media_MediaRecorder_native_getMaxAmplitude(JNIEnv *env, jobject thiz)
 428 {
 429     ALOGV("getMaxAmplitude");
 430     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 431     if (mr == NULL) {
 432         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 433         return 0;
 434     }
 435     int result = 0;
 436     process_media_recorder_call(env, mr->getMaxAmplitude(&result), "java/lang/RuntimeException", "getMaxAmplitude failed.");
 437     return (jint) result;
 438 }
 439
 440 static jobject
 441 android_media_MediaRecorder_getSurface(JNIEnv *env, jobject thiz)
 442 {
 443     ALOGV("getSurface");
 444     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 445     if (mr == NULL) {
 446         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 447         return NULL;
 448     }
 449
 450     sp<IGraphicBufferProducer> bufferProducer = mr->querySurfaceMediaSourceFromMediaServer();
 451     if (bufferProducer == NULL) {
 452         jniThrowException(
 453                 env,
 454                 "java/lang/IllegalStateException",
 455                 "failed to get surface");
 456         return NULL;
 457     }
 458
 459     // Wrap the IGBP in a Java-language Surface.
 460     return android_view_Surface_createFromIGraphicBufferProducer(env,
 461             bufferProducer);
 462 }
 463
 464 static void
 465 android_media_MediaRecorder_start(JNIEnv *env, jobject thiz)
 466 {
 467     ALOGV("start");
 468     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 469     if (mr == NULL) {
 470         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 471         return;
 472     }
 473     process_media_recorder_call(env, mr->start(), "java/lang/RuntimeException", "start failed.");
 474 }
 475
 476 static void
 477 android_media_MediaRecorder_stop(JNIEnv *env, jobject thiz)
 478 {
 479     ALOGV("stop");
 480     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 481     if (mr == NULL) {
 482         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 483         return;
 484     }
 485     process_media_recorder_call(env, mr->stop(), "java/lang/RuntimeException", "stop failed.");
 486 }
 487
 488 static void
 489 android_media_MediaRecorder_pause(JNIEnv *env, jobject thiz)
 490 {
 491     ALOGV("pause");
 492     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 493     if (mr == NULL) {
 494         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 495         return;
 496     }
 497     process_media_recorder_call(env, mr->pause(), "java/lang/RuntimeException", "pause failed.");
 498 }
 499
 500 static void
 501 android_media_MediaRecorder_resume(JNIEnv *env, jobject thiz)
 502 {
 503     ALOGV("resume");
 504     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 505     if (mr == NULL) {
 506         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 507         return;
 508     }
 509     process_media_recorder_call(env, mr->resume(), "java/lang/RuntimeException", "resume failed.");
 510 }
 511
 512 static void
 513 android_media_MediaRecorder_native_reset(JNIEnv *env, jobject thiz)
 514 {
 515     ALOGV("native_reset");
 516     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 517     if (mr == NULL) {
 518         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 519         return;
 520     }
 521     process_media_recorder_call(env, mr->reset(), "java/lang/RuntimeException", "native_reset failed.");
 522 }
 523
 524 static void
 525 android_media_MediaRecorder_release(JNIEnv *env, jobject thiz)
 526 {
 527     ALOGV("release");
 528     sp<MediaRecorder> mr = setMediaRecorder(env, thiz, 0);
 529     if (mr != NULL) {
 530         mr->setListener(NULL);
 531         mr->release();
 532     }
 533 }
 534
 535 // This function gets some field IDs, which in turn causes class initialization.
 536 // It is called from a static block in MediaRecorder, which won't run until the
 537 // first time an instance of this class is used.
 538 static void
 539 android_media_MediaRecorder_native_init(JNIEnv *env)
 540 {
 541     jclass clazz;
 542
 543     clazz = env->FindClass("android/media/MediaRecorder");
 544     if (clazz == NULL) {
 545         return;
 546     }
 547
 548     fields.context = env->GetFieldID(clazz, "mNativeContext", "J");
 549     if (fields.context == NULL) {
 550         return;
 551     }
 552
 553     fields.surface = env->GetFieldID(clazz, "mSurface", "Landroid/view/Surface;");
 554     if (fields.surface == NULL) {
 555         return;
 556     }
 557
 558     jclass surface = env->FindClass("android/view/Surface");
 559     if (surface == NULL) {
 560         return;
 561     }
 562
 563     fields.post_event = env->GetStaticMethodID(clazz, "postEventFromNative",
 564                                                "(Ljava/lang/Object;IIILjava/lang/Object;)V");
 565     if (fields.post_event == NULL) {
 566         return;
 567     }
 568 }
 569
 570
 571 static void
 572 android_media_MediaRecorder_native_setup(JNIEnv *env, jobject thiz, jobject weak_this,
 573                                          jstring packageName, jstring opPackageName)
 574 {
 575     ALOGV("setup");
 576
 577     ScopedUtfChars opPackageNameStr(env, opPackageName);
 578
 579     sp<MediaRecorder> mr = new MediaRecorder(String16(opPackageNameStr.c_str()));
 580     if (mr == NULL) {
 581         jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
 582         return;
 583     }
 584     if (mr->initCheck() != NO_ERROR) {
 585         jniThrowException(env, "java/lang/RuntimeException", "Unable to initialize media recorder");
 586         return;
 587     }
 588
 589     // create new listener and give it to MediaRecorder
 590     sp<JNIMediaRecorderListener> listener = new JNIMediaRecorderListener(env, thiz, weak_this);
 591     mr->setListener(listener);
 592
 593     // Convert client name jstring to String16
 594     const char16_t *rawClientName = reinterpret_cast<const char16_t*>(
 595         env->GetStringChars(packageName, NULL));
 596     jsize rawClientNameLen = env->GetStringLength(packageName);
 597     String16 clientName(rawClientName, rawClientNameLen);
 598     env->ReleaseStringChars(packageName,
 599                             reinterpret_cast<const jchar*>(rawClientName));
 600
 601     // pass client package name for permissions tracking
 602     mr->setClientName(clientName);
 603
 604     setMediaRecorder(env, thiz, mr);
 605 }
 606
 607 static void
 608 android_media_MediaRecorder_native_finalize(JNIEnv *env, jobject thiz)
 609 {
 610     ALOGV("finalize");
 611     android_media_MediaRecorder_release(env, thiz);
 612 }
 613
 614 void android_media_MediaRecorder_setInputSurface(
 615         JNIEnv* env, jobject thiz, jobject object) {
 616     ALOGV("android_media_MediaRecorder_setInputSurface");
 617
 618     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 619     if (mr == NULL) {
 620         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 621         return;
 622     }
 623
 624     sp<PersistentSurface> persistentSurface = get_persistentSurface(env, object);
 625
 626     process_media_recorder_call(env, mr->setInputSurface(persistentSurface),
 627             "java/lang/IllegalArgumentException", "native_setInputSurface failed.");
 628 }
 629
 630 static jobject
 631 android_media_MediaRecorder_native_getMetrics(JNIEnv *env, jobject thiz)
 632 {
 633     ALOGV("android_media_MediaRecorder_native_getMetrics");
 634
 635     sp<MediaRecorder> mr = getMediaRecorder(env, thiz);
 636     if (mr == NULL) {
 637         jniThrowException(env, "java/lang/IllegalStateException", NULL);
 638         return NULL;
 639     }
 640
 641     // get what we have for the metrics from the codec
 642     Parcel reply;
 643     status_t err = mr->getMetrics(&reply);
 644     if (err != OK) {
 645         ALOGE("getMetrics failed");
 646         return (jobject) NULL;
 647     }
 648
 649     // build and return the Bundle
 650     MediaAnalyticsItem *item = new MediaAnalyticsItem;
 651     item->readFromParcel(reply);
 652     jobject mybundle = MediaMetricsJNI::writeMetricsToBundle(env, item, NULL);
 653
 654     // housekeeping
 655     delete item;
 656     item = NULL;
 657     return mybundle;
 658
 659 }
 660 // ----------------------------------------------------------------------------
 661
 662 static const JNINativeMethod gMethods[] = {
 663     {"setCamera",            "(Landroid/hardware/Camera;)V",    (void *)android_media_MediaRecorder_setCamera},
 664     {"setVideoSource",       "(I)V",                            (void *)android_media_MediaRecorder_setVideoSource},
 665     {"setAudioSource",       "(I)V",                            (void *)android_media_MediaRecorder_setAudioSource},
 666     {"setOutputFormat",      "(I)V",                            (void *)android_media_MediaRecorder_setOutputFormat},
 667     {"setVideoEncoder",      "(I)V",                            (void *)android_media_MediaRecorder_setVideoEncoder},
 668     {"setAudioEncoder",      "(I)V",                            (void *)android_media_MediaRecorder_setAudioEncoder},
 669     {"setParameter",         "(Ljava/lang/String;)V",           (void *)android_media_MediaRecorder_setParameter},
 670     {"_setOutputFile",       "(Ljava/io/FileDescriptor;)V",     (void *)android_media_MediaRecorder_setOutputFileFD},
 671     {"_setNextOutputFile",   "(Ljava/io/FileDescriptor;)V",     (void *)android_media_MediaRecorder_setNextOutputFileFD},
 672     {"setVideoSize",         "(II)V",                           (void *)android_media_MediaRecorder_setVideoSize},
 673     {"setVideoFrameRate",    "(I)V",                            (void *)android_media_MediaRecorder_setVideoFrameRate},
 674     {"setMaxDuration",       "(I)V",                            (void *)android_media_MediaRecorder_setMaxDuration},
 675     {"setMaxFileSize",       "(J)V",                            (void *)android_media_MediaRecorder_setMaxFileSize},
 676     {"_prepare",             "()V",                             (void *)android_media_MediaRecorder_prepare},
 677     {"getSurface",           "()Landroid/view/Surface;",        (void *)android_media_MediaRecorder_getSurface},
 678     {"getMaxAmplitude",      "()I",                             (void *)android_media_MediaRecorder_native_getMaxAmplitude},
 679     {"start",                "()V",                             (void *)android_media_MediaRecorder_start},
 680     {"stop",                 "()V",                             (void *)android_media_MediaRecorder_stop},
 681     {"pause",                "()V",                             (void *)android_media_MediaRecorder_pause},
 682     {"resume",               "()V",                             (void *)android_media_MediaRecorder_resume},
 683     {"native_reset",         "()V",                             (void *)android_media_MediaRecorder_native_reset},
 684     {"release",              "()V",                             (void *)android_media_MediaRecorder_release},
 685     {"native_init",          "()V",                             (void *)android_media_MediaRecorder_native_init},
 686     {"native_setup",         "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;)V",
 687                                                                 (void *)android_media_MediaRecorder_native_setup},
 688     {"native_finalize",      "()V",                             (void *)android_media_MediaRecorder_native_finalize},
 689     {"native_setInputSurface", "(Landroid/view/Surface;)V", (void *)android_media_MediaRecorder_setInputSurface },
 690
 691     {"native_getMetrics",    "()Landroid/os/PersistableBundle;", (void *)android_media_MediaRecorder_native_getMetrics},
 692 };
 693
 694 // This function only registers the native methods, and is called from
 695 // JNI_OnLoad in android_media_MediaPlayer.cpp
 696 int register_android_media_MediaRecorder(JNIEnv *env)
 697 {
 698     return AndroidRuntime::registerNativeMethods(env,
 699                 "android/media/MediaRecorder", gMethods, NELEM(gMethods));
 700 }