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