android_hardware_Camera.cpp revision e25cc656392d8866e163f78b60c7791455d0fb44 
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 <surfaceflinger/Surface.h>
29#include <camera/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                    LOGV("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
291static jint android_hardware_Camera_getNumberOfCameras(JNIEnv *env, jobject thiz)
292{
293    return Camera::getNumberOfCameras();
294}
295
296// connect to camera service
297static void android_hardware_Camera_native_setup(JNIEnv *env, jobject thiz,
298    jobject weak_this, jint cameraId)
299{
300    sp<Camera> camera = Camera::connect(cameraId);
301
302    if (camera == NULL) {
303        jniThrowException(env, "java/lang/RuntimeException",
304                          "Fail to connect to camera service");
305        return;
306    }
307
308    // make sure camera hardware is alive
309    if (camera->getStatus() != NO_ERROR) {
310        jniThrowException(env, "java/lang/RuntimeException", "Camera initialization failed");
311        return;
312    }
313
314    jclass clazz = env->GetObjectClass(thiz);
315    if (clazz == NULL) {
316        jniThrowException(env, "java/lang/RuntimeException", "Can't find android/hardware/Camera");
317        return;
318    }
319
320    // We use a weak reference so the Camera object can be garbage collected.
321    // The reference is only used as a proxy for callbacks.
322    sp<JNICameraContext> context = new JNICameraContext(env, weak_this, clazz, camera);
323    context->incStrong(thiz);
324    camera->setListener(context);
325
326    // save context in opaque field
327    env->SetIntField(thiz, fields.context, (int)context.get());
328}
329
330// disconnect from camera service
331// It's okay to call this when the native camera context is already null.
332// This handles the case where the user has called release() and the
333// finalizer is invoked later.
334static void android_hardware_Camera_release(JNIEnv *env, jobject thiz)
335{
336    // TODO: Change to LOGV
337    LOGV("release camera");
338    JNICameraContext* context = NULL;
339    sp<Camera> camera;
340    {
341        Mutex::Autolock _l(sLock);
342        context = reinterpret_cast<JNICameraContext*>(env->GetIntField(thiz, fields.context));
343
344        // Make sure we do not attempt to callback on a deleted Java object.
345        env->SetIntField(thiz, fields.context, 0);
346    }
347
348    // clean up if release has not been called before
349    if (context != NULL) {
350        camera = context->getCamera();
351        context->release();
352        LOGV("native_release: context=%p camera=%p", context, camera.get());
353
354        // clear callbacks
355        if (camera != NULL) {
356            camera->setPreviewCallbackFlags(FRAME_CALLBACK_FLAG_NOOP);
357            camera->disconnect();
358        }
359
360        // remove context to prevent further Java access
361        context->decStrong(thiz);
362    }
363}
364
365static void android_hardware_Camera_setPreviewDisplay(JNIEnv *env, jobject thiz, jobject jSurface)
366{
367    LOGV("setPreviewDisplay");
368    sp<Camera> camera = get_native_camera(env, thiz, NULL);
369    if (camera == 0) return;
370
371    sp<Surface> surface = NULL;
372    if (jSurface != NULL) {
373        surface = reinterpret_cast<Surface*>(env->GetIntField(jSurface, fields.surface));
374    }
375    if (camera->setPreviewDisplay(surface) != NO_ERROR) {
376        jniThrowException(env, "java/io/IOException", "setPreviewDisplay failed");
377    }
378}
379
380static void android_hardware_Camera_startPreview(JNIEnv *env, jobject thiz)
381{
382    LOGV("startPreview");
383    sp<Camera> camera = get_native_camera(env, thiz, NULL);
384    if (camera == 0) return;
385
386    if (camera->startPreview() != NO_ERROR) {
387        jniThrowException(env, "java/lang/RuntimeException", "startPreview failed");
388        return;
389    }
390}
391
392static void android_hardware_Camera_stopPreview(JNIEnv *env, jobject thiz)
393{
394    LOGV("stopPreview");
395    sp<Camera> c = get_native_camera(env, thiz, NULL);
396    if (c == 0) return;
397
398    c->stopPreview();
399}
400
401static bool android_hardware_Camera_previewEnabled(JNIEnv *env, jobject thiz)
402{
403    LOGV("previewEnabled");
404    sp<Camera> c = get_native_camera(env, thiz, NULL);
405    if (c == 0) return false;
406
407    return c->previewEnabled();
408}
409
410static void android_hardware_Camera_setHasPreviewCallback(JNIEnv *env, jobject thiz, jboolean installed, jboolean manualBuffer)
411{
412    LOGV("setHasPreviewCallback: installed:%d, manualBuffer:%d", (int)installed, (int)manualBuffer);
413    // Important: Only install preview_callback if the Java code has called
414    // setPreviewCallback() with a non-null value, otherwise we'd pay to memcpy
415    // each preview frame for nothing.
416    JNICameraContext* context;
417    sp<Camera> camera = get_native_camera(env, thiz, &context);
418    if (camera == 0) return;
419
420    // setCallbackMode will take care of setting the context flags and calling
421    // camera->setPreviewCallbackFlags within a mutex for us.
422    context->setCallbackMode(env, installed, manualBuffer);
423}
424
425static void android_hardware_Camera_addCallbackBuffer(JNIEnv *env, jobject thiz, jbyteArray bytes) {
426    LOGV("addCallbackBuffer");
427
428    JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetIntField(thiz, fields.context));
429
430    if (context != NULL) {
431        context->addCallbackBuffer(env, bytes);
432    }
433}
434
435static void android_hardware_Camera_autoFocus(JNIEnv *env, jobject thiz)
436{
437    LOGV("autoFocus");
438    JNICameraContext* context;
439    sp<Camera> c = get_native_camera(env, thiz, &context);
440    if (c == 0) return;
441
442    if (c->autoFocus() != NO_ERROR) {
443        jniThrowException(env, "java/lang/RuntimeException", "autoFocus failed");
444    }
445}
446
447static void android_hardware_Camera_cancelAutoFocus(JNIEnv *env, jobject thiz)
448{
449    LOGV("cancelAutoFocus");
450    JNICameraContext* context;
451    sp<Camera> c = get_native_camera(env, thiz, &context);
452    if (c == 0) return;
453
454    if (c->cancelAutoFocus() != NO_ERROR) {
455        jniThrowException(env, "java/lang/RuntimeException", "cancelAutoFocus failed");
456    }
457}
458
459static void android_hardware_Camera_takePicture(JNIEnv *env, jobject thiz)
460{
461    LOGV("takePicture");
462    JNICameraContext* context;
463    sp<Camera> camera = get_native_camera(env, thiz, &context);
464    if (camera == 0) return;
465
466    if (camera->takePicture() != NO_ERROR) {
467        jniThrowException(env, "java/lang/RuntimeException", "takePicture failed");
468        return;
469    }
470}
471
472static void android_hardware_Camera_setParameters(JNIEnv *env, jobject thiz, jstring params)
473{
474    LOGV("setParameters");
475    sp<Camera> camera = get_native_camera(env, thiz, NULL);
476    if (camera == 0) return;
477
478    const jchar* str = env->GetStringCritical(params, 0);
479    String8 params8;
480    if (params) {
481        params8 = String8(str, env->GetStringLength(params));
482        env->ReleaseStringCritical(params, str);
483    }
484    if (camera->setParameters(params8) != NO_ERROR) {
485        jniThrowException(env, "java/lang/RuntimeException", "setParameters failed");
486        return;
487    }
488}
489
490static jstring android_hardware_Camera_getParameters(JNIEnv *env, jobject thiz)
491{
492    LOGV("getParameters");
493    sp<Camera> camera = get_native_camera(env, thiz, NULL);
494    if (camera == 0) return 0;
495
496    return env->NewStringUTF(camera->getParameters().string());
497}
498
499static void android_hardware_Camera_reconnect(JNIEnv *env, jobject thiz)
500{
501    LOGV("reconnect");
502    sp<Camera> camera = get_native_camera(env, thiz, NULL);
503    if (camera == 0) return;
504
505    if (camera->reconnect() != NO_ERROR) {
506        jniThrowException(env, "java/io/IOException", "reconnect failed");
507        return;
508    }
509}
510
511static void android_hardware_Camera_lock(JNIEnv *env, jobject thiz)
512{
513    LOGV("lock");
514    sp<Camera> camera = get_native_camera(env, thiz, NULL);
515    if (camera == 0) return;
516
517    if (camera->lock() != NO_ERROR) {
518        jniThrowException(env, "java/lang/RuntimeException", "lock failed");
519    }
520}
521
522static void android_hardware_Camera_unlock(JNIEnv *env, jobject thiz)
523{
524    LOGV("unlock");
525    sp<Camera> camera = get_native_camera(env, thiz, NULL);
526    if (camera == 0) return;
527
528    if (camera->unlock() != NO_ERROR) {
529        jniThrowException(env, "java/lang/RuntimeException", "unlock failed");
530    }
531}
532
533static void android_hardware_Camera_startSmoothZoom(JNIEnv *env, jobject thiz, jint value)
534{
535    LOGV("startSmoothZoom");
536    sp<Camera> camera = get_native_camera(env, thiz, NULL);
537    if (camera == 0) return;
538
539    status_t rc = camera->sendCommand(CAMERA_CMD_START_SMOOTH_ZOOM, value, 0);
540    if (rc == BAD_VALUE) {
541        char msg[64];
542        sprintf(msg, "invalid zoom value=%d", value);
543        jniThrowException(env, "java/lang/IllegalArgumentException", msg);
544    } else if (rc != NO_ERROR) {
545        jniThrowException(env, "java/lang/RuntimeException", "start smooth zoom failed");
546    }
547}
548
549static void android_hardware_Camera_stopSmoothZoom(JNIEnv *env, jobject thiz)
550{
551    LOGV("stopSmoothZoom");
552    sp<Camera> camera = get_native_camera(env, thiz, NULL);
553    if (camera == 0) return;
554
555    if (camera->sendCommand(CAMERA_CMD_STOP_SMOOTH_ZOOM, 0, 0) != NO_ERROR) {
556        jniThrowException(env, "java/lang/RuntimeException", "stop smooth zoom failed");
557    }
558}
559
560static void android_hardware_Camera_setDisplayOrientation(JNIEnv *env, jobject thiz,
561        jint value)
562{
563    LOGV("setDisplayOrientation");
564    sp<Camera> camera = get_native_camera(env, thiz, NULL);
565    if (camera == 0) return;
566
567    if (camera->sendCommand(CAMERA_CMD_SET_DISPLAY_ORIENTATION, value, 0) != NO_ERROR) {
568        jniThrowException(env, "java/lang/RuntimeException", "set display orientation failed");
569    }
570}
571
572//-------------------------------------------------
573
574static JNINativeMethod camMethods[] = {
575  { "getNumberOfCameras",
576    "()I",
577    (void *)android_hardware_Camera_getNumberOfCameras },
578  { "native_setup",
579    "(Ljava/lang/Object;I)V",
580    (void*)android_hardware_Camera_native_setup },
581  { "native_release",
582    "()V",
583    (void*)android_hardware_Camera_release },
584  { "setPreviewDisplay",
585    "(Landroid/view/Surface;)V",
586    (void *)android_hardware_Camera_setPreviewDisplay },
587  { "startPreview",
588    "()V",
589    (void *)android_hardware_Camera_startPreview },
590  { "stopPreview",
591    "()V",
592    (void *)android_hardware_Camera_stopPreview },
593  { "previewEnabled",
594    "()Z",
595    (void *)android_hardware_Camera_previewEnabled },
596  { "setHasPreviewCallback",
597    "(ZZ)V",
598    (void *)android_hardware_Camera_setHasPreviewCallback },
599  { "addCallbackBuffer",
600    "([B)V",
601    (void *)android_hardware_Camera_addCallbackBuffer },
602  { "native_autoFocus",
603    "()V",
604    (void *)android_hardware_Camera_autoFocus },
605  { "native_cancelAutoFocus",
606    "()V",
607    (void *)android_hardware_Camera_cancelAutoFocus },
608  { "native_takePicture",
609    "()V",
610    (void *)android_hardware_Camera_takePicture },
611  { "native_setParameters",
612    "(Ljava/lang/String;)V",
613    (void *)android_hardware_Camera_setParameters },
614  { "native_getParameters",
615    "()Ljava/lang/String;",
616    (void *)android_hardware_Camera_getParameters },
617  { "reconnect",
618    "()V",
619    (void*)android_hardware_Camera_reconnect },
620  { "lock",
621    "()V",
622    (void*)android_hardware_Camera_lock },
623  { "unlock",
624    "()V",
625    (void*)android_hardware_Camera_unlock },
626  { "startSmoothZoom",
627    "(I)V",
628    (void *)android_hardware_Camera_startSmoothZoom },
629  { "stopSmoothZoom",
630    "()V",
631    (void *)android_hardware_Camera_stopSmoothZoom },
632  { "setDisplayOrientation",
633    "(I)V",
634    (void *)android_hardware_Camera_setDisplayOrientation },
635};
636
637struct field {
638    const char *class_name;
639    const char *field_name;
640    const char *field_type;
641    jfieldID   *jfield;
642};
643
644static int find_fields(JNIEnv *env, field *fields, int count)
645{
646    for (int i = 0; i < count; i++) {
647        field *f = &fields[i];
648        jclass clazz = env->FindClass(f->class_name);
649        if (clazz == NULL) {
650            LOGE("Can't find %s", f->class_name);
651            return -1;
652        }
653
654        jfieldID field = env->GetFieldID(clazz, f->field_name, f->field_type);
655        if (field == NULL) {
656            LOGE("Can't find %s.%s", f->class_name, f->field_name);
657            return -1;
658        }
659
660        *(f->jfield) = field;
661    }
662
663    return 0;
664}
665
666// Get all the required offsets in java class and register native functions
667int register_android_hardware_Camera(JNIEnv *env)
668{
669    field fields_to_find[] = {
670        { "android/hardware/Camera", "mNativeContext",   "I", &fields.context },
671        { "android/view/Surface",    ANDROID_VIEW_SURFACE_JNI_ID, "I", &fields.surface }
672    };
673
674    if (find_fields(env, fields_to_find, NELEM(fields_to_find)) < 0)
675        return -1;
676
677    jclass clazz = env->FindClass("android/hardware/Camera");
678    fields.post_event = env->GetStaticMethodID(clazz, "postEventFromNative",
679                                               "(Ljava/lang/Object;IIILjava/lang/Object;)V");
680    if (fields.post_event == NULL) {
681        LOGE("Can't find android/hardware/Camera.postEventFromNative");
682        return -1;
683    }
684
685
686    // Register native functions
687    return AndroidRuntime::registerNativeMethods(env, "android/hardware/Camera",
688                                              camMethods, NELEM(camMethods));
689}
690
691