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
JNIMediaRecorderListener(JNIEnv * env,jobject thiz,jobject weak_thiz)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
~JNIMediaRecorderListener()98 JNIMediaRecorderListener::~JNIMediaRecorderListener()
99 {
100 // remove global references
101 JNIEnv *env = AndroidRuntime::getJNIEnv();
102 env->DeleteGlobalRef(mObject);
103 env->DeleteGlobalRef(mClass);
104 }
105
notify(int msg,int ext1,int ext2)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
get_surface(JNIEnv * env,jobject clazz)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
get_persistentSurface(JNIEnv * env,jobject object)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.
process_media_recorder_call(JNIEnv * env,status_t opStatus,const char * exception,const char * message)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
getMediaRecorder(JNIEnv * env,jobject thiz)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
setMediaRecorder(JNIEnv * env,jobject thiz,const sp<MediaRecorder> & recorder)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
android_media_MediaRecorder_setCamera(JNIEnv * env,jobject thiz,jobject camera)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
android_media_MediaRecorder_setVideoSource(JNIEnv * env,jobject thiz,jint vs)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
android_media_MediaRecorder_setAudioSource(JNIEnv * env,jobject thiz,jint as)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
android_media_MediaRecorder_setOutputFormat(JNIEnv * env,jobject thiz,jint of)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
android_media_MediaRecorder_setVideoEncoder(JNIEnv * env,jobject thiz,jint ve)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
android_media_MediaRecorder_setAudioEncoder(JNIEnv * env,jobject thiz,jint ae)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
android_media_MediaRecorder_setParameter(JNIEnv * env,jobject thiz,jstring params)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
android_media_MediaRecorder_setOutputFileFD(JNIEnv * env,jobject thiz,jobject fileDescriptor)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
android_media_MediaRecorder_setNextOutputFileFD(JNIEnv * env,jobject thiz,jobject fileDescriptor)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
android_media_MediaRecorder_setVideoSize(JNIEnv * env,jobject thiz,jint width,jint height)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
android_media_MediaRecorder_setVideoFrameRate(JNIEnv * env,jobject thiz,jint rate)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
android_media_MediaRecorder_setMaxDuration(JNIEnv * env,jobject thiz,jint max_duration_ms)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
android_media_MediaRecorder_setMaxFileSize(JNIEnv * env,jobject thiz,jlong max_filesize_bytes)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
android_media_MediaRecorder_prepare(JNIEnv * env,jobject thiz)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
android_media_MediaRecorder_native_getMaxAmplitude(JNIEnv * env,jobject thiz)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
android_media_MediaRecorder_getSurface(JNIEnv * env,jobject thiz)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
android_media_MediaRecorder_start(JNIEnv * env,jobject thiz)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
android_media_MediaRecorder_stop(JNIEnv * env,jobject thiz)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
android_media_MediaRecorder_pause(JNIEnv * env,jobject thiz)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
android_media_MediaRecorder_resume(JNIEnv * env,jobject thiz)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
android_media_MediaRecorder_native_reset(JNIEnv * env,jobject thiz)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
android_media_MediaRecorder_release(JNIEnv * env,jobject thiz)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
android_media_MediaRecorder_native_init(JNIEnv * env)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
android_media_MediaRecorder_native_setup(JNIEnv * env,jobject thiz,jobject weak_this,jstring packageName,jstring opPackageName)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
android_media_MediaRecorder_native_finalize(JNIEnv * env,jobject thiz)608 android_media_MediaRecorder_native_finalize(JNIEnv *env, jobject thiz)
609 {
610 ALOGV("finalize");
611 android_media_MediaRecorder_release(env, thiz);
612 }
613
android_media_MediaRecorder_setInputSurface(JNIEnv * env,jobject thiz,jobject object)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
android_media_MediaRecorder_native_getMetrics(JNIEnv * env,jobject thiz)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
register_android_media_MediaRecorder(JNIEnv * env)696 int register_android_media_MediaRecorder(JNIEnv *env)
697 {
698 return AndroidRuntime::registerNativeMethods(env,
699 "android/media/MediaRecorder", gMethods, NELEM(gMethods));
700 }
701