android_hardware_Camera.cpp revision c95a176d6f0aa48314d98f5c1f50821ac86137a7 
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 <utils/Vector.h>
27
28#include <ui/Surface.h>
29#include <ui/Camera.h>
30#include <binder/IMemory.h>
31
32using namespace android;
33
34struct fields_t {
35    jfieldID    context;
36    jfieldID    surface;
37    jmethodID   post_event;
38};
39
40static fields_t fields;
41static Mutex sLock;
42
43// provides persistent context for calls from native code to Java
44class JNICameraContext: public CameraListener
45{
46public:
47    JNICameraContext(JNIEnv* env, jobject weak_this, jclass clazz, const sp<Camera>& camera);
48    ~JNICameraContext() { release(); }
49    virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2);
50    virtual void postData(int32_t msgType, const sp<IMemory>& dataPtr);
51    virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr);
52    void addCallbackBuffer(JNIEnv *env, jbyteArray cbb);
53    void setCallbackMode(JNIEnv *env, bool installed, bool manualMode);
54    sp<Camera> getCamera() { Mutex::Autolock _l(mLock); return mCamera; }
55    void release();
56
57private:
58    void copyAndPost(JNIEnv* env, const sp<IMemory>& dataPtr, int msgType);
59    void clearCallbackBuffers_l(JNIEnv *env);
60
61    jobject     mCameraJObjectWeak;     // weak reference to java object
62    jclass      mCameraJClass;          // strong reference to java class
63    sp<Camera>  mCamera;                // strong reference to native object
64    Mutex       mLock;
65
66    Vector<jbyteArray> mCallbackBuffers; // Global reference application managed byte[]
67    bool mManualBufferMode;              // Whether to use application managed buffers.
68    bool mManualCameraCallbackSet;       // Whether the callback has been set, used to reduce unnecessary calls to set the callback.
69};
70
71sp<Camera> get_native_camera(JNIEnv *env, jobject thiz, JNICameraContext** pContext)
72{
73    sp<Camera> camera;
74    Mutex::Autolock _l(sLock);
75    JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetIntField(thiz, fields.context));
76    if (context != NULL) {
77        camera = context->getCamera();
78    }
79    LOGV("get_native_camera: context=%p, camera=%p", context, camera.get());
80    if (camera == 0) {
81        jniThrowException(env, "java/lang/RuntimeException", "Method called after release()");
82    }
83
84    if (pContext != NULL) *pContext = context;
85    return camera;
86}
87
88JNICameraContext::JNICameraContext(JNIEnv* env, jobject weak_this, jclass clazz, const sp<Camera>& camera)
89{
90    mCameraJObjectWeak = env->NewGlobalRef(weak_this);
91    mCameraJClass = (jclass)env->NewGlobalRef(clazz);
92    mCamera = camera;
93
94    mManualBufferMode = false;
95    mManualCameraCallbackSet = false;
96}
97
98void JNICameraContext::release()
99{
100    LOGV("release");
101    Mutex::Autolock _l(mLock);
102    JNIEnv *env = AndroidRuntime::getJNIEnv();
103
104    if (mCameraJObjectWeak != NULL) {
105        env->DeleteGlobalRef(mCameraJObjectWeak);
106        mCameraJObjectWeak = NULL;
107    }
108    if (mCameraJClass != NULL) {
109        env->DeleteGlobalRef(mCameraJClass);
110        mCameraJClass = NULL;
111    }
112    clearCallbackBuffers_l(env);
113    mCamera.clear();
114}
115
116void JNICameraContext::notify(int32_t msgType, int32_t ext1, int32_t ext2)
117{
118    LOGV("notify");
119
120    // VM pointer will be NULL if object is released
121    Mutex::Autolock _l(mLock);
122    if (mCameraJObjectWeak == NULL) {
123        LOGW("callback on dead camera object");
124        return;
125    }
126    JNIEnv *env = AndroidRuntime::getJNIEnv();
127    env->CallStaticVoidMethod(mCameraJClass, fields.post_event,
128            mCameraJObjectWeak, msgType, ext1, ext2, NULL);
129}
130
131void JNICameraContext::copyAndPost(JNIEnv* env, const sp<IMemory>& dataPtr, int msgType)
132{
133    jbyteArray obj = NULL;
134
135    // allocate Java byte array and copy data
136    if (dataPtr != NULL) {
137        ssize_t offset;
138        size_t size;
139        sp<IMemoryHeap> heap = dataPtr->getMemory(&offset, &size);
140        LOGV("postData: off=%d, size=%d", offset, size);
141        uint8_t *heapBase = (uint8_t*)heap->base();
142
143        if (heapBase != NULL) {
144            const jbyte* data = reinterpret_cast<const jbyte*>(heapBase + offset);
145
146            if (!mManualBufferMode) {
147                LOGV("Allocating callback buffer");
148                obj = env->NewByteArray(size);
149            } else {
150                // Vector access should be protected by lock in postData()
151                if(!mCallbackBuffers.isEmpty()) {
152                    LOGV("Using callback buffer from queue of length %d", mCallbackBuffers.size());
153                    jbyteArray globalBuffer = mCallbackBuffers.itemAt(0);
154                    mCallbackBuffers.removeAt(0);
155
156                    obj = (jbyteArray)env->NewLocalRef(globalBuffer);
157                    env->DeleteGlobalRef(globalBuffer);
158
159                    if (obj != NULL) {
160                        jsize bufferLength = env->GetArrayLength(obj);
161                        if ((int)bufferLength < (int)size) {
162                            LOGE("Manually set buffer was too small! Expected %d bytes, but got %d!",
163                                 size, bufferLength);
164                            env->DeleteLocalRef(obj);
165                            return;
166                        }
167                    }
168                }
169
170                if(mCallbackBuffers.isEmpty()) {
171                    LOGW("Out of buffers, clearing callback!");
172                    mCamera->setPreviewCallbackFlags(FRAME_CALLBACK_FLAG_NOOP);
173                    mManualCameraCallbackSet = false;
174
175                    if (obj == NULL) {
176                        return;
177                    }
178                }
179            }
180
181            if (obj == NULL) {
182                LOGE("Couldn't allocate byte array for JPEG data");
183                env->ExceptionClear();
184            } else {
185                env->SetByteArrayRegion(obj, 0, size, data);
186            }
187        } else {
188            LOGE("image heap is NULL");
189        }
190    }
191
192    // post image data to Java
193    env->CallStaticVoidMethod(mCameraJClass, fields.post_event,
194            mCameraJObjectWeak, msgType, 0, 0, obj);
195    if (obj) {
196        env->DeleteLocalRef(obj);
197    }
198}
199
200void JNICameraContext::postData(int32_t msgType, const sp<IMemory>& dataPtr)
201{
202    // VM pointer will be NULL if object is released
203    Mutex::Autolock _l(mLock);
204    JNIEnv *env = AndroidRuntime::getJNIEnv();
205    if (mCameraJObjectWeak == NULL) {
206        LOGW("callback on dead camera object");
207        return;
208    }
209
210    // return data based on callback type
211    switch(msgType) {
212    case CAMERA_MSG_VIDEO_FRAME:
213        // should never happen
214        break;
215    // don't return raw data to Java
216    case CAMERA_MSG_RAW_IMAGE:
217        LOGV("rawCallback");
218        env->CallStaticVoidMethod(mCameraJClass, fields.post_event,
219                mCameraJObjectWeak, msgType, 0, 0, NULL);
220        break;
221    default:
222        // TODO: Change to LOGV
223        LOGV("dataCallback(%d, %p)", msgType, dataPtr.get());
224        copyAndPost(env, dataPtr, msgType);
225        break;
226    }
227}
228
229void JNICameraContext::postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr)
230{
231    // TODO: plumb up to Java. For now, just drop the timestamp
232    postData(msgType, dataPtr);
233}
234
235void JNICameraContext::setCallbackMode(JNIEnv *env, bool installed, bool manualMode)
236{
237    Mutex::Autolock _l(mLock);
238    mManualBufferMode = manualMode;
239    mManualCameraCallbackSet = false;
240
241    // In order to limit the over usage of binder threads, all non-manual buffer
242    // callbacks use FRAME_CALLBACK_FLAG_BARCODE_SCANNER mode now.
243    //
244    // Continuous callbacks will have the callback re-registered from handleMessage.
245    // Manual buffer mode will operate as fast as possible, relying on the finite supply
246    // of buffers for throttling.
247
248    if (!installed) {
249        mCamera->setPreviewCallbackFlags(FRAME_CALLBACK_FLAG_NOOP);
250        clearCallbackBuffers_l(env);
251    } else if (mManualBufferMode) {
252        if (!mCallbackBuffers.isEmpty()) {
253            mCamera->setPreviewCallbackFlags(FRAME_CALLBACK_FLAG_CAMERA);
254            mManualCameraCallbackSet = true;
255        }
256    } else {
257        mCamera->setPreviewCallbackFlags(FRAME_CALLBACK_FLAG_BARCODE_SCANNER);
258        clearCallbackBuffers_l(env);
259    }
260}
261
262void JNICameraContext::addCallbackBuffer(JNIEnv *env, jbyteArray cbb)
263{
264    if (cbb != NULL) {
265        Mutex::Autolock _l(mLock);
266        jbyteArray callbackBuffer = (jbyteArray)env->NewGlobalRef(cbb);
267        mCallbackBuffers.push(cbb);
268
269        LOGV("Adding callback buffer to queue, %d total", mCallbackBuffers.size());
270
271        // We want to make sure the camera knows we're ready for the next frame.
272        // This may have come unset had we not had a callbackbuffer ready for it last time.
273        if (mManualBufferMode && !mManualCameraCallbackSet) {
274            mCamera->setPreviewCallbackFlags(FRAME_CALLBACK_FLAG_CAMERA);
275            mManualCameraCallbackSet = true;
276        }
277    } else {
278       LOGE("Null byte array!");
279    }
280}
281
282void JNICameraContext::clearCallbackBuffers_l(JNIEnv *env)
283{
284    LOGV("Clearing callback buffers, %d remained", mCallbackBuffers.size());
285    while(!mCallbackBuffers.isEmpty()) {
286        env->DeleteGlobalRef(mCallbackBuffers.top());
287        mCallbackBuffers.pop();
288    }
289}
290
291// connect to camera service
292static void android_hardware_Camera_native_setup(JNIEnv *env, jobject thiz, jobject weak_this)
293{
294    sp<Camera> camera = Camera::connect();
295
296    if (camera == NULL) {
297        jniThrowException(env, "java/lang/RuntimeException",
298                          "Fail to connect to camera service");
299        return;
300    }
301
302    // make sure camera hardware is alive
303    if (camera->getStatus() != NO_ERROR) {
304        jniThrowException(env, "java/lang/RuntimeException", "Camera initialization failed");
305        return;
306    }
307
308    jclass clazz = env->GetObjectClass(thiz);
309    if (clazz == NULL) {
310        jniThrowException(env, "java/lang/RuntimeException", "Can't find android/hardware/Camera");
311        return;
312    }
313
314    // We use a weak reference so the Camera object can be garbage collected.
315    // The reference is only used as a proxy for callbacks.
316    sp<JNICameraContext> context = new JNICameraContext(env, weak_this, clazz, camera);
317    context->incStrong(thiz);
318    camera->setListener(context);
319
320    // save context in opaque field
321    env->SetIntField(thiz, fields.context, (int)context.get());
322}
323
324// disconnect from camera service
325// It's okay to call this when the native camera context is already null.
326// This handles the case where the user has called release() and the
327// finalizer is invoked later.
328static void android_hardware_Camera_release(JNIEnv *env, jobject thiz)
329{
330    // TODO: Change to LOGV
331    LOGD("release camera");
332    JNICameraContext* context = NULL;
333    sp<Camera> camera;
334    {
335        Mutex::Autolock _l(sLock);
336        context = reinterpret_cast<JNICameraContext*>(env->GetIntField(thiz, fields.context));
337
338        // Make sure we do not attempt to callback on a deleted Java object.
339        env->SetIntField(thiz, fields.context, 0);
340    }
341
342    // clean up if release has not been called before
343    if (context != NULL) {
344        camera = context->getCamera();
345        context->release();
346        LOGV("native_release: context=%p camera=%p", context, camera.get());
347
348        // clear callbacks
349        if (camera != NULL) {
350            camera->setPreviewCallbackFlags(FRAME_CALLBACK_FLAG_NOOP);
351            camera->disconnect();
352        }
353
354        // remove context to prevent further Java access
355        context->decStrong(thiz);
356    }
357}
358
359static void android_hardware_Camera_setPreviewDisplay(JNIEnv *env, jobject thiz, jobject jSurface)
360{
361    LOGV("setPreviewDisplay");
362    sp<Camera> camera = get_native_camera(env, thiz, NULL);
363    if (camera == 0) return;
364
365    sp<Surface> surface = NULL;
366    if (jSurface != NULL) {
367        surface = reinterpret_cast<Surface*>(env->GetIntField(jSurface, fields.surface));
368    }
369    if (camera->setPreviewDisplay(surface) != NO_ERROR) {
370        jniThrowException(env, "java/io/IOException", "setPreviewDisplay failed");
371    }
372}
373
374static void android_hardware_Camera_startPreview(JNIEnv *env, jobject thiz)
375{
376    LOGV("startPreview");
377    sp<Camera> camera = get_native_camera(env, thiz, NULL);
378    if (camera == 0) return;
379
380    if (camera->startPreview() != NO_ERROR) {
381        jniThrowException(env, "java/lang/RuntimeException", "startPreview failed");
382        return;
383    }
384}
385
386static void android_hardware_Camera_stopPreview(JNIEnv *env, jobject thiz)
387{
388    LOGV("stopPreview");
389    sp<Camera> c = get_native_camera(env, thiz, NULL);
390    if (c == 0) return;
391
392    c->stopPreview();
393}
394
395static bool android_hardware_Camera_previewEnabled(JNIEnv *env, jobject thiz)
396{
397    LOGV("previewEnabled");
398    sp<Camera> c = get_native_camera(env, thiz, NULL);
399    if (c == 0) return false;
400
401    return c->previewEnabled();
402}
403
404static void android_hardware_Camera_setHasPreviewCallback(JNIEnv *env, jobject thiz, jboolean installed, jboolean manualBuffer)
405{
406    LOGV("setHasPreviewCallback: installed:%d, manualBuffer:%d", (int)installed, (int)manualBuffer);
407    // Important: Only install preview_callback if the Java code has called
408    // setPreviewCallback() with a non-null value, otherwise we'd pay to memcpy
409    // each preview frame for nothing.
410    JNICameraContext* context;
411    sp<Camera> camera = get_native_camera(env, thiz, &context);
412    if (camera == 0) return;
413
414    // setCallbackMode will take care of setting the context flags and calling
415    // camera->setPreviewCallbackFlags within a mutex for us.
416    context->setCallbackMode(env, installed, manualBuffer);
417}
418
419static void android_hardware_Camera_addCallbackBuffer(JNIEnv *env, jobject thiz, jbyteArray bytes) {
420    LOGV("addCallbackBuffer");
421
422    JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetIntField(thiz, fields.context));
423
424    if (context != NULL) {
425        context->addCallbackBuffer(env, bytes);
426    }
427}
428
429static void android_hardware_Camera_autoFocus(JNIEnv *env, jobject thiz)
430{
431    LOGV("autoFocus");
432    JNICameraContext* context;
433    sp<Camera> c = get_native_camera(env, thiz, &context);
434    if (c == 0) return;
435
436    if (c->autoFocus() != NO_ERROR) {
437        jniThrowException(env, "java/lang/RuntimeException", "autoFocus failed");
438    }
439}
440
441static void android_hardware_Camera_cancelAutoFocus(JNIEnv *env, jobject thiz)
442{
443    LOGV("cancelAutoFocus");
444    JNICameraContext* context;
445    sp<Camera> c = get_native_camera(env, thiz, &context);
446    if (c == 0) return;
447
448    if (c->cancelAutoFocus() != NO_ERROR) {
449        jniThrowException(env, "java/lang/RuntimeException", "cancelAutoFocus failed");
450    }
451}
452
453static void android_hardware_Camera_takePicture(JNIEnv *env, jobject thiz)
454{
455    LOGV("takePicture");
456    JNICameraContext* context;
457    sp<Camera> camera = get_native_camera(env, thiz, &context);
458    if (camera == 0) return;
459
460    if (camera->takePicture() != NO_ERROR) {
461        jniThrowException(env, "java/lang/RuntimeException", "takePicture failed");
462        return;
463    }
464}
465
466static void android_hardware_Camera_setParameters(JNIEnv *env, jobject thiz, jstring params)
467{
468    LOGV("setParameters");
469    sp<Camera> camera = get_native_camera(env, thiz, NULL);
470    if (camera == 0) return;
471
472    const jchar* str = env->GetStringCritical(params, 0);
473    String8 params8;
474    if (params) {
475        params8 = String8(str, env->GetStringLength(params));
476        env->ReleaseStringCritical(params, str);
477    }
478    if (camera->setParameters(params8) != NO_ERROR) {
479        jniThrowException(env, "java/lang/RuntimeException", "setParameters failed");
480        return;
481    }
482}
483
484static jstring android_hardware_Camera_getParameters(JNIEnv *env, jobject thiz)
485{
486    LOGV("getParameters");
487    sp<Camera> camera = get_native_camera(env, thiz, NULL);
488    if (camera == 0) return 0;
489
490    return env->NewStringUTF(camera->getParameters().string());
491}
492
493static void android_hardware_Camera_reconnect(JNIEnv *env, jobject thiz)
494{
495    LOGV("reconnect");
496    sp<Camera> camera = get_native_camera(env, thiz, NULL);
497    if (camera == 0) return;
498
499    if (camera->reconnect() != NO_ERROR) {
500        jniThrowException(env, "java/io/IOException", "reconnect failed");
501        return;
502    }
503}
504
505static void android_hardware_Camera_lock(JNIEnv *env, jobject thiz)
506{
507    LOGV("lock");
508    sp<Camera> camera = get_native_camera(env, thiz, NULL);
509    if (camera == 0) return;
510
511    if (camera->lock() != NO_ERROR) {
512        jniThrowException(env, "java/lang/RuntimeException", "lock failed");
513    }
514}
515
516static void android_hardware_Camera_unlock(JNIEnv *env, jobject thiz)
517{
518    LOGV("unlock");
519    sp<Camera> camera = get_native_camera(env, thiz, NULL);
520    if (camera == 0) return;
521
522    if (camera->unlock() != NO_ERROR) {
523        jniThrowException(env, "java/lang/RuntimeException", "unlock failed");
524    }
525}
526
527static void android_hardware_Camera_startSmoothZoom(JNIEnv *env, jobject thiz, jint value)
528{
529    LOGD("startSmoothZoom");
530    sp<Camera> camera = get_native_camera(env, thiz, NULL);
531    if (camera == 0) return;
532
533    if (camera->sendCommand(CAMERA_CMD_START_SMOOTH_ZOOM, value, 0) != NO_ERROR) {
534        jniThrowException(env, "java/lang/RuntimeException", "start smooth zoom failed");
535    }
536}
537
538static void android_hardware_Camera_stopSmoothZoom(JNIEnv *env, jobject thiz)
539{
540    LOGD("stopSmoothZoom");
541    sp<Camera> camera = get_native_camera(env, thiz, NULL);
542    if (camera == 0) return;
543
544    if (camera->sendCommand(CAMERA_CMD_STOP_SMOOTH_ZOOM, 0, 0) != NO_ERROR) {
545        jniThrowException(env, "java/lang/RuntimeException", "stop smooth zoom failed");
546    }
547}
548
549//-------------------------------------------------
550
551static JNINativeMethod camMethods[] = {
552  { "native_setup",
553    "(Ljava/lang/Object;)V",
554    (void*)android_hardware_Camera_native_setup },
555  { "native_release",
556    "()V",
557    (void*)android_hardware_Camera_release },
558  { "setPreviewDisplay",
559    "(Landroid/view/Surface;)V",
560    (void *)android_hardware_Camera_setPreviewDisplay },
561  { "startPreview",
562    "()V",
563    (void *)android_hardware_Camera_startPreview },
564  { "stopPreview",
565    "()V",
566    (void *)android_hardware_Camera_stopPreview },
567  { "previewEnabled",
568    "()Z",
569    (void *)android_hardware_Camera_previewEnabled },
570  { "setHasPreviewCallback",
571    "(ZZ)V",
572    (void *)android_hardware_Camera_setHasPreviewCallback },
573  { "addCallbackBuffer",
574    "([B)V",
575    (void *)android_hardware_Camera_addCallbackBuffer },
576  { "native_autoFocus",
577    "()V",
578    (void *)android_hardware_Camera_autoFocus },
579  { "native_cancelAutoFocus",
580    "()V",
581    (void *)android_hardware_Camera_cancelAutoFocus },
582  { "native_takePicture",
583    "()V",
584    (void *)android_hardware_Camera_takePicture },
585  { "native_setParameters",
586    "(Ljava/lang/String;)V",
587    (void *)android_hardware_Camera_setParameters },
588  { "native_getParameters",
589    "()Ljava/lang/String;",
590    (void *)android_hardware_Camera_getParameters },
591  { "reconnect",
592    "()V",
593    (void*)android_hardware_Camera_reconnect },
594  { "lock",
595    "()V",
596    (void*)android_hardware_Camera_lock },
597  { "unlock",
598    "()V",
599    (void*)android_hardware_Camera_unlock },
600  { "startSmoothZoom",
601    "(I)V",
602    (void *)android_hardware_Camera_startSmoothZoom },
603  { "stopSmoothZoom",
604    "()V",
605    (void *)android_hardware_Camera_stopSmoothZoom },
606};
607
608struct field {
609    const char *class_name;
610    const char *field_name;
611    const char *field_type;
612    jfieldID   *jfield;
613};
614
615static int find_fields(JNIEnv *env, field *fields, int count)
616{
617    for (int i = 0; i < count; i++) {
618        field *f = &fields[i];
619        jclass clazz = env->FindClass(f->class_name);
620        if (clazz == NULL) {
621            LOGE("Can't find %s", f->class_name);
622            return -1;
623        }
624
625        jfieldID field = env->GetFieldID(clazz, f->field_name, f->field_type);
626        if (field == NULL) {
627            LOGE("Can't find %s.%s", f->class_name, f->field_name);
628            return -1;
629        }
630
631        *(f->jfield) = field;
632    }
633
634    return 0;
635}
636
637// Get all the required offsets in java class and register native functions
638int register_android_hardware_Camera(JNIEnv *env)
639{
640    field fields_to_find[] = {
641        { "android/hardware/Camera", "mNativeContext",   "I", &fields.context },
642        { "android/view/Surface",    "mSurface",         "I", &fields.surface }
643    };
644
645    if (find_fields(env, fields_to_find, NELEM(fields_to_find)) < 0)
646        return -1;
647
648    jclass clazz = env->FindClass("android/hardware/Camera");
649    fields.post_event = env->GetStaticMethodID(clazz, "postEventFromNative",
650                                               "(Ljava/lang/Object;IIILjava/lang/Object;)V");
651    if (fields.post_event == NULL) {
652        LOGE("Can't find android/hardware/Camera.postEventFromNative");
653        return -1;
654    }
655
656
657    // Register native functions
658    return AndroidRuntime::registerNativeMethods(env, "android/hardware/Camera",
659                                              camMethods, NELEM(camMethods));
660}
661
662