android_hardware_Camera.cpp revision 0795272aa226f4e965968a03daddc53ce30b7cda 
1/*
2**
3** Copyright 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 "Camera-JNI"
20#include <utils/Log.h>
21
22#include "jni.h"
23#include "JNIHelp.h"
24#include "android_runtime/AndroidRuntime.h"
25
26#include <ui/Surface.h>
27#include <ui/Camera.h>
28#include <binder/IMemory.h>
29
30using namespace android;
31
32enum CallbackMessageID {
33    kShutterCallback = 0,
34    kRawCallback = 1,
35    kJpegCallback = 2,
36    kPreviewCallback = 3,
37    kAutoFocusCallback = 4,
38    kErrorCallback = 5
39};
40
41enum CameraError {
42    kCameraErrorUnknown = 1,
43    kCameraErrorMediaServer = 100
44};
45
46
47struct fields_t {
48    jfieldID    context;
49    jfieldID    surface;
50    jmethodID   post_event;
51};
52
53static fields_t fields;
54static Mutex sLock;
55
56struct camera_context_t {
57    jobject     mCameraJObjectWeak;     // weak reference to java object
58    jclass      mCameraJClass;          // strong reference to java class
59    sp<Camera>  mCamera;                // strong reference to native object
60};
61
62sp<Camera> get_native_camera(JNIEnv *env, jobject thiz, camera_context_t** pContext)
63{
64    sp<Camera> camera;
65    Mutex::Autolock _l(sLock);
66    camera_context_t* context = reinterpret_cast<camera_context_t*>(env->GetIntField(thiz, fields.context));
67    if (context != NULL) {
68        camera = context->mCamera;
69    }
70    LOGV("get_native_camera: context=%p, camera=%p", context, camera.get());
71    if (camera == 0) {
72        jniThrowException(env, "java/lang/RuntimeException", "Method called after release()");
73    }
74
75    if (pContext != NULL) *pContext = context;
76    return camera;
77}
78
79static void err_callback(status_t err, void *cookie)
80{
81    camera_context_t* context = reinterpret_cast<camera_context_t*>(cookie);
82    if ((context == NULL) || (context->mCamera == 0)) return;
83
84    LOGV("err_callback: context=%p, camera=%p", context, context->mCamera.get());
85
86    int error;
87    switch (err) {
88    case DEAD_OBJECT:
89        error = kCameraErrorMediaServer;
90        break;
91    default:
92        error = kCameraErrorUnknown;
93        break;
94    }
95
96    JNIEnv *env = AndroidRuntime::getJNIEnv();
97    if (env == NULL) {
98        LOGE("err_callback on dead VM");
99        return;
100    }
101    env->CallStaticVoidMethod(context->mCameraJClass, fields.post_event,
102            context->mCameraJObjectWeak, kErrorCallback, error, 0, NULL);
103}
104
105// connect to camera service
106static void android_hardware_Camera_native_setup(JNIEnv *env, jobject thiz, jobject weak_this)
107{
108    sp<Camera> camera = Camera::connect();
109
110    if (camera == NULL) {
111        jniThrowException(env, "java/lang/RuntimeException",
112                          "Fail to connect to camera service");
113        return;
114    }
115
116    // make sure camera hardware is alive
117    if (camera->getStatus() != NO_ERROR) {
118        jniThrowException(env, "java/io/IOException", "Camera initialization failed");
119        return;
120    }
121
122    jclass clazz = env->GetObjectClass(thiz);
123    if (clazz == NULL) {
124        LOGE("Can't find android/hardware/Camera");
125        // XXX no idea what to throw here, can this even happen?
126        jniThrowException(env, "java/lang/Exception", NULL);
127        return;
128    }
129
130    // We use a weak reference so the Camera object can be garbage collected.
131    // The reference is only used as a proxy for callbacks.
132    camera_context_t* context = new camera_context_t;
133    context->mCameraJObjectWeak = env->NewGlobalRef(weak_this);
134    context->mCameraJClass = (jclass)env->NewGlobalRef(clazz);
135    context->mCamera = camera;
136
137    // save context in opaque field
138    env->SetIntField(thiz, fields.context, (int)context);
139
140    LOGV("native_setup: mCameraJObjectWeak=%x, camera_obj=%x, context=%p",
141            (int)context->mCameraJObjectWeak, (int)thiz, context);
142
143    // set error callback
144    camera->setErrorCallback(err_callback, context);
145}
146
147// disconnect from camera service
148// It's okay to call this when the native camera context is already null.
149// This handles the case where the user has called release() and the
150// finalizer is invoked later.
151static void android_hardware_Camera_release(JNIEnv *env, jobject thiz)
152{
153    camera_context_t* context = NULL;
154    sp<Camera> camera;
155    {
156        Mutex::Autolock _l(sLock);
157        context = reinterpret_cast<camera_context_t*>(env->GetIntField(thiz, fields.context));
158
159        // Make sure we do not attempt to callback on a deleted Java object.
160        env->SetIntField(thiz, fields.context, 0);
161    }
162
163    // clean up if release has not been called before
164    if (context != NULL) {
165        camera = context->mCamera;
166        context->mCamera.clear();
167        LOGV("native_release: context=%p camera=%p", context, camera.get());
168
169        // clear callbacks
170        if (camera != NULL) {
171            camera->setPreviewCallback(NULL, NULL, FRAME_CALLBACK_FLAG_NOOP);
172            camera->setErrorCallback(NULL, NULL);
173            camera->disconnect();
174            env->DeleteGlobalRef(context->mCameraJObjectWeak);
175            env->DeleteGlobalRef(context->mCameraJClass);
176        }
177
178        // remove context to prevent further Java access
179        delete context;
180    }
181}
182
183static void android_hardware_Camera_setPreviewDisplay(JNIEnv *env, jobject thiz, jobject jSurface)
184{
185    LOGV("setPreviewDisplay");
186    sp<Camera> camera = get_native_camera(env, thiz, NULL);
187    if (camera == 0) return;
188
189    sp<Surface> surface = reinterpret_cast<Surface*>(env->GetIntField(jSurface, fields.surface));
190    if (camera->setPreviewDisplay(surface) != NO_ERROR) {
191        jniThrowException(env, "java/io/IOException", "setPreviewDisplay failed");
192    }
193}
194
195static void preview_callback(const sp<IMemory>& mem, void *cookie)
196{
197    LOGV("preview_callback");
198    JNIEnv *env = AndroidRuntime::getJNIEnv();
199    if (env == NULL) {
200        LOGE("preview_callback on dead VM");
201        return;
202    }
203    camera_context_t* context = reinterpret_cast<camera_context_t*>(cookie);
204    if ((context == NULL) || (context->mCamera == 0)) {
205        LOGW("context or camera is NULL in preview_callback");
206        return;
207    }
208    LOGV("native_release: context=%p camera=%p", context, context->mCamera.get());
209
210    int arg1 = 0, arg2 = 0;
211    jobject obj = NULL;
212
213    ssize_t offset;
214    size_t size;
215    sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
216
217    uint8_t *data = ((uint8_t *)heap->base()) + offset;
218
219    jbyteArray array = env->NewByteArray(size);
220    if (array == NULL) {
221        LOGE("Couldn't allocate byte array for YUV data");
222        env->ExceptionClear();
223        return;
224    }
225
226    jbyte *bytes = env->GetByteArrayElements(array, NULL);
227    memcpy(bytes, data, size);
228    env->ReleaseByteArrayElements(array, bytes, 0);
229
230    obj = array;
231
232    env->CallStaticVoidMethod(context->mCameraJClass, fields.post_event,
233            context->mCameraJObjectWeak, kPreviewCallback, arg1, arg2, obj);
234    env->DeleteLocalRef(array);
235}
236
237static void android_hardware_Camera_startPreview(JNIEnv *env, jobject thiz)
238{
239    LOGV("startPreview");
240    sp<Camera> camera = get_native_camera(env, thiz, NULL);
241    if (camera == 0) return;
242
243    if (camera->startPreview() != NO_ERROR) {
244        jniThrowException(env, "java/io/IOException", "startPreview failed");
245        return;
246    }
247}
248
249static void android_hardware_Camera_stopPreview(JNIEnv *env, jobject thiz)
250{
251    LOGV("stopPreview");
252    sp<Camera> c = get_native_camera(env, thiz, NULL);
253    if (c == 0) return;
254
255    c->stopPreview();
256}
257
258static bool android_hardware_Camera_previewEnabled(JNIEnv *env, jobject thiz)
259{
260    LOGV("previewEnabled");
261    sp<Camera> c = get_native_camera(env, thiz, NULL);
262    if (c == 0) return false;
263
264    return c->previewEnabled();
265}
266
267static void android_hardware_Camera_setHasPreviewCallback(JNIEnv *env, jobject thiz, jboolean installed, jboolean oneshot)
268{
269    // Important: Only install preview_callback if the Java code has called
270    // setPreviewCallback() with a non-null value, otherwise we'd pay to memcpy
271    // each preview frame for nothing.
272    camera_context_t* context;
273    sp<Camera> camera = get_native_camera(env, thiz, &context);
274    if (camera == 0) return;
275
276    int callback_flag;
277    if (installed) {
278        callback_flag = oneshot ? FRAME_CALLBACK_FLAG_BARCODE_SCANNER : FRAME_CALLBACK_FLAG_CAMERA;
279    } else {
280        callback_flag = FRAME_CALLBACK_FLAG_NOOP;
281    }
282    camera->setPreviewCallback(installed ? preview_callback : NULL, context, callback_flag);
283}
284
285static void autofocus_callback_impl(bool success, void *cookie)
286{
287    LOGV("autoFocusCallback");
288    camera_context_t* context = reinterpret_cast<camera_context_t*>(cookie);
289
290    JNIEnv *env = AndroidRuntime::getJNIEnv();
291    if (env == NULL) {
292        LOGE("autofocus_callback on dead VM");
293        return;
294    }
295    env->CallStaticVoidMethod(context->mCameraJClass, fields.post_event,
296            context->mCameraJObjectWeak, kAutoFocusCallback, success, 0, NULL);
297}
298
299static void android_hardware_Camera_autoFocus(JNIEnv *env, jobject thiz)
300{
301    LOGV("autoFocus");
302    camera_context_t* context;
303    sp<Camera> c = get_native_camera(env, thiz, &context);
304    if (c == 0) return;
305
306    c->setAutoFocusCallback(autofocus_callback_impl, context);
307    if (c->autoFocus() != NO_ERROR) {
308        jniThrowException(env, "java/io/IOException", "autoFocus failed");
309    }
310}
311
312static void jpeg_callback(const sp<IMemory>& mem, void *cookie)
313{
314    LOGV("jpegCallback");
315    camera_context_t* context = reinterpret_cast<camera_context_t*>(cookie);
316
317    JNIEnv *env = AndroidRuntime::getJNIEnv();
318    if (env == NULL) {
319        LOGE("jpeg`_callback on dead VM");
320        return;
321    }
322    int arg1 = 0, arg2 = 0;
323    jobject obj = NULL;
324
325    if (mem == NULL) {
326        env->CallStaticVoidMethod(context->mCameraJClass, fields.post_event,
327                                  context->mCameraJObjectWeak, kJpegCallback, arg1, arg2, NULL);
328        return;
329    }
330    ssize_t offset;
331    size_t size;
332    sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
333    LOGV("jpeg_callback: mem off=%d, size=%d", offset, size);
334
335    uint8_t *heap_base = (uint8_t *)heap->base();
336    if (heap_base == NULL) {
337        LOGE("YUV heap is NULL");
338        return;
339    }
340
341    uint8_t *data = heap_base + offset;
342
343    jbyteArray array = env->NewByteArray(size);
344    if (array == NULL) {
345        LOGE("Couldn't allocate byte array for JPEG data");
346        env->ExceptionClear();
347        return;
348    }
349
350    jbyte *bytes = env->GetByteArrayElements(array, NULL);
351    memcpy(bytes, data, size);
352    env->ReleaseByteArrayElements(array, bytes, 0);
353
354    obj = array;
355
356    env->CallStaticVoidMethod(context->mCameraJClass, fields.post_event,
357                              context->mCameraJObjectWeak, kJpegCallback, arg1, arg2, obj);
358    env->DeleteLocalRef(array);
359}
360
361static void shutter_callback_impl(void *cookie)
362{
363    LOGV("shutterCallback");
364    camera_context_t* context = reinterpret_cast<camera_context_t*>(cookie);
365
366    JNIEnv *env = AndroidRuntime::getJNIEnv();
367    if (env == NULL) {
368        LOGE("shutter_callback on dead VM");
369        return;
370    }
371    env->CallStaticVoidMethod(context->mCameraJClass, fields.post_event,
372                              context->mCameraJObjectWeak, kShutterCallback, 0, 0, NULL);
373}
374
375static void raw_callback(const sp<IMemory>& mem __attribute__((unused)),
376                         void *cookie)
377{
378    LOGV("rawCallback");
379    camera_context_t* context = reinterpret_cast<camera_context_t*>(cookie);
380
381    JNIEnv *env = AndroidRuntime::getJNIEnv();
382    if (env == NULL) {
383        LOGE("raw_callback on dead VM");
384        return;
385    }
386    env->CallStaticVoidMethod(context->mCameraJClass, fields.post_event,
387                              context->mCameraJObjectWeak, kRawCallback, 0, 0, NULL);
388}
389
390static void android_hardware_Camera_takePicture(JNIEnv *env, jobject thiz)
391{
392    LOGV("takePicture");
393    camera_context_t* context;
394    sp<Camera> camera = get_native_camera(env, thiz, &context);
395    if (camera == 0) return;
396
397    camera->setShutterCallback(shutter_callback_impl, context);
398    camera->setRawCallback(raw_callback, context);
399    camera->setJpegCallback(jpeg_callback, context);
400    if (camera->takePicture() != NO_ERROR) {
401        jniThrowException(env, "java/io/IOException", "takePicture failed");
402        return;
403    }
404
405    return;
406}
407
408static void android_hardware_Camera_setParameters(JNIEnv *env, jobject thiz, jstring params)
409{
410    LOGV("setParameters");
411    sp<Camera> camera = get_native_camera(env, thiz, NULL);
412    if (camera == 0) return;
413
414    const jchar* str = env->GetStringCritical(params, 0);
415    String8 params8;
416    if (params) {
417        params8 = String8(str, env->GetStringLength(params));
418        env->ReleaseStringCritical(params, str);
419    }
420    if (camera->setParameters(params8) != NO_ERROR) {
421        jniThrowException(env, "java/lang/IllegalArgumentException", "setParameters failed");
422        return;
423    }
424}
425
426static jstring android_hardware_Camera_getParameters(JNIEnv *env, jobject thiz)
427{
428    LOGV("getParameters");
429    sp<Camera> camera = get_native_camera(env, thiz, NULL);
430    if (camera == 0) return 0;
431
432    return env->NewStringUTF(camera->getParameters().string());
433}
434
435static void android_hardware_Camera_reconnect(JNIEnv *env, jobject thiz)
436{
437    LOGV("reconnect");
438    sp<Camera> camera = get_native_camera(env, thiz, NULL);
439    if (camera == 0) return;
440
441    if (camera->reconnect() != NO_ERROR) {
442        jniThrowException(env, "java/io/IOException", "reconnect failed");
443        return;
444    }
445}
446
447static jint android_hardware_Camera_lock(JNIEnv *env, jobject thiz)
448{
449    LOGV("lock");
450    sp<Camera> camera = get_native_camera(env, thiz, NULL);
451    if (camera == 0) return INVALID_OPERATION;
452    return (jint) camera->lock();
453}
454
455static jint android_hardware_Camera_unlock(JNIEnv *env, jobject thiz)
456{
457    LOGV("unlock");
458    sp<Camera> camera = get_native_camera(env, thiz, NULL);
459    if (camera == 0) return INVALID_OPERATION;
460    return (jint) camera->unlock();
461}
462
463//-------------------------------------------------
464
465static JNINativeMethod camMethods[] = {
466  { "native_setup",
467    "(Ljava/lang/Object;)V",
468    (void*)android_hardware_Camera_native_setup },
469  { "native_release",
470    "()V",
471    (void*)android_hardware_Camera_release },
472  { "setPreviewDisplay",
473    "(Landroid/view/Surface;)V",
474    (void *)android_hardware_Camera_setPreviewDisplay },
475  { "startPreview",
476    "()V",
477    (void *)android_hardware_Camera_startPreview },
478  { "stopPreview",
479    "()V",
480    (void *)android_hardware_Camera_stopPreview },
481  { "previewEnabled",
482    "()Z",
483    (void *)android_hardware_Camera_previewEnabled },
484  { "setHasPreviewCallback",
485    "(ZZ)V",
486    (void *)android_hardware_Camera_setHasPreviewCallback },
487  { "native_autoFocus",
488    "()V",
489    (void *)android_hardware_Camera_autoFocus },
490  { "native_takePicture",
491    "()V",
492    (void *)android_hardware_Camera_takePicture },
493  { "native_setParameters",
494    "(Ljava/lang/String;)V",
495    (void *)android_hardware_Camera_setParameters },
496  { "native_getParameters",
497    "()Ljava/lang/String;",
498    (void *)android_hardware_Camera_getParameters },
499  { "reconnect",
500    "()V",
501    (void*)android_hardware_Camera_reconnect },
502  { "lock",
503    "()I",
504    (void*)android_hardware_Camera_lock },
505  { "unlock",
506    "()I",
507    (void*)android_hardware_Camera_unlock },
508};
509
510struct field {
511    const char *class_name;
512    const char *field_name;
513    const char *field_type;
514    jfieldID   *jfield;
515};
516
517static int find_fields(JNIEnv *env, field *fields, int count)
518{
519    for (int i = 0; i < count; i++) {
520        field *f = &fields[i];
521        jclass clazz = env->FindClass(f->class_name);
522        if (clazz == NULL) {
523            LOGE("Can't find %s", f->class_name);
524            return -1;
525        }
526
527        jfieldID field = env->GetFieldID(clazz, f->field_name, f->field_type);
528        if (field == NULL) {
529            LOGE("Can't find %s.%s", f->class_name, f->field_name);
530            return -1;
531        }
532
533        *(f->jfield) = field;
534    }
535
536    return 0;
537}
538
539// Get all the required offsets in java class and register native functions
540int register_android_hardware_Camera(JNIEnv *env)
541{
542    field fields_to_find[] = {
543        { "android/hardware/Camera", "mNativeContext",   "I", &fields.context },
544        { "android/view/Surface",    "mSurface",         "I", &fields.surface }
545    };
546
547    if (find_fields(env, fields_to_find, NELEM(fields_to_find)) < 0)
548        return -1;
549
550    jclass clazz = env->FindClass("android/hardware/Camera");
551    fields.post_event = env->GetStaticMethodID(clazz, "postEventFromNative",
552                                               "(Ljava/lang/Object;IIILjava/lang/Object;)V");
553    if (fields.post_event == NULL) {
554        LOGE("Can't find android/hardware/Camera.postEventFromNative");
555        return -1;
556    }
557
558
559    // Register native functions
560    return AndroidRuntime::registerNativeMethods(env, "android/hardware/Camera",
561                                              camMethods, NELEM(camMethods));
562}
563
564