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
47using namespace android;
48
49// ----------------------------------------------------------------------------
50
51// helper function to extract a native Camera object from a Camera Java object
52extern sp<Camera> get_native_camera(JNIEnv *env, jobject thiz, struct JNICameraContext** context);
53extern sp<PersistentSurface>
54android_media_MediaCodec_getPersistentInputSurface(JNIEnv* env, jobject object);
55
56struct fields_t {
57    jfieldID    context;
58    jfieldID    surface;
59
60    jmethodID   post_event;
61};
62static fields_t fields;
63
64static Mutex sLock;
65
66// ----------------------------------------------------------------------------
67// ref-counted object for callbacks
68class JNIMediaRecorderListener: public MediaRecorderListener
69{
70public:
71    JNIMediaRecorderListener(JNIEnv* env, jobject thiz, jobject weak_thiz);
72    ~JNIMediaRecorderListener();
73    void notify(int msg, int ext1, int ext2);
74private:
75    JNIMediaRecorderListener();
76    jclass      mClass;     // Reference to MediaRecorder class
77    jobject     mObject;    // Weak ref to MediaRecorder Java object to call on
78};
79
80JNIMediaRecorderListener::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
98JNIMediaRecorderListener::~JNIMediaRecorderListener()
99{
100    // remove global references
101    JNIEnv *env = AndroidRuntime::getJNIEnv();
102    env->DeleteGlobalRef(mObject);
103    env->DeleteGlobalRef(mClass);
104}
105
106void 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
116static sp<Surface> get_surface(JNIEnv* env, jobject clazz)
117{
118    ALOGV("get_surface");
119    return android_view_Surface_getSurface(env, clazz);
120}
121
122static 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.
129static 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
142static 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
149static 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
164static 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
185static void
186android_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
201static void
202android_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
219static void
220android_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
235static void
236android_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
251static void
252android_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
267static void
268android_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
294static void
295android_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
312static void
313android_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
330static void
331android_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
347static void
348android_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
363static void
364android_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
379static void
380android_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
396static void
397android_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
426static jint
427android_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
440static jobject
441android_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
464static void
465android_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
476static void
477android_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
488static void
489android_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
500static void
501android_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
512static void
513android_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
524static void
525android_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.
538static void
539android_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
571static void
572android_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
607static void
608android_media_MediaRecorder_native_finalize(JNIEnv *env, jobject thiz)
609{
610    ALOGV("finalize");
611    android_media_MediaRecorder_release(env, thiz);
612}
613
614void 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
630static jobject
631android_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
662static 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
696int register_android_media_MediaRecorder(JNIEnv *env)
697{
698    return AndroidRuntime::registerNativeMethods(env,
699                "android/media/MediaRecorder", gMethods, NELEM(gMethods));
700}
701