android_hardware_Camera.cpp revision f0d6a48c6ad852b84687127f14b1ffde02416dc4 
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 <gui/SurfaceTexture.h>
29#include <surfaceflinger/Surface.h>
30#include <camera/Camera.h>
31#include <binder/IMemory.h>
32
33using namespace android;
34
35struct fields_t {
36    jfieldID    context;
37    jfieldID    surface;
38    jfieldID    surfaceTexture;
39    jfieldID    facing;
40    jfieldID    orientation;
41    jfieldID    face_rect;
42    jfieldID    face_score;
43    jfieldID    rect_left;
44    jfieldID    rect_top;
45    jfieldID    rect_right;
46    jfieldID    rect_bottom;
47    jmethodID   post_event;
48};
49
50static fields_t fields;
51static Mutex sLock;
52
53// provides persistent context for calls from native code to Java
54class JNICameraContext: public CameraListener
55{
56public:
57    JNICameraContext(JNIEnv* env, jobject weak_this, jclass clazz, const sp<Camera>& camera);
58    ~JNICameraContext() { release(); }
59    virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2);
60    virtual void postData(int32_t msgType, const sp<IMemory>& dataPtr);
61    virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr);
62    void addCallbackBuffer(JNIEnv *env, jbyteArray cbb, int msgType);
63    void setCallbackMode(JNIEnv *env, bool installed, bool manualMode);
64    sp<Camera> getCamera() { Mutex::Autolock _l(mLock); return mCamera; }
65    bool isRawImageCallbackBufferAvailable() const;
66    void release();
67
68private:
69    void copyAndPost(JNIEnv* env, const sp<IMemory>& dataPtr, int msgType);
70    void clearCallbackBuffers_l(JNIEnv *env, Vector<jbyteArray> *buffers);
71    void clearCallbackBuffers_l(JNIEnv *env);
72    jbyteArray getCallbackBuffer(JNIEnv *env, Vector<jbyteArray> *buffers, size_t bufferSize);
73
74    jobject     mCameraJObjectWeak;     // weak reference to java object
75    jclass      mCameraJClass;          // strong reference to java class
76    sp<Camera>  mCamera;                // strong reference to native object
77    Mutex       mLock;
78
79    /*
80     * Global reference application-managed raw image buffer queue.
81     *
82     * Manual-only mode is supported for raw image callbacks, which is
83     * set whenever method addCallbackBuffer() with msgType =
84     * CAMERA_MSG_RAW_IMAGE is called; otherwise, null is returned
85     * with raw image callbacks.
86     */
87    Vector<jbyteArray> mRawImageCallbackBuffers;
88
89    /*
90     * Application-managed preview buffer queue and the flags
91     * associated with the usage of the preview buffer callback.
92     */
93    Vector<jbyteArray> mCallbackBuffers; // Global reference application managed byte[]
94    bool mManualBufferMode;              // Whether to use application managed buffers.
95    bool mManualCameraCallbackSet;       // Whether the callback has been set, used to
96                                         // reduce unnecessary calls to set the callback.
97};
98
99bool JNICameraContext::isRawImageCallbackBufferAvailable() const
100{
101    return !mRawImageCallbackBuffers.isEmpty();
102}
103
104sp<Camera> get_native_camera(JNIEnv *env, jobject thiz, JNICameraContext** pContext)
105{
106    sp<Camera> camera;
107    Mutex::Autolock _l(sLock);
108    JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetIntField(thiz, fields.context));
109    if (context != NULL) {
110        camera = context->getCamera();
111    }
112    LOGV("get_native_camera: context=%p, camera=%p", context, camera.get());
113    if (camera == 0) {
114        jniThrowRuntimeException(env, "Method called after release()");
115    }
116
117    if (pContext != NULL) *pContext = context;
118    return camera;
119}
120
121JNICameraContext::JNICameraContext(JNIEnv* env, jobject weak_this, jclass clazz, const sp<Camera>& camera)
122{
123    mCameraJObjectWeak = env->NewGlobalRef(weak_this);
124    mCameraJClass = (jclass)env->NewGlobalRef(clazz);
125    mCamera = camera;
126
127    mManualBufferMode = false;
128    mManualCameraCallbackSet = false;
129}
130
131void JNICameraContext::release()
132{
133    LOGV("release");
134    Mutex::Autolock _l(mLock);
135    JNIEnv *env = AndroidRuntime::getJNIEnv();
136
137    if (mCameraJObjectWeak != NULL) {
138        env->DeleteGlobalRef(mCameraJObjectWeak);
139        mCameraJObjectWeak = NULL;
140    }
141    if (mCameraJClass != NULL) {
142        env->DeleteGlobalRef(mCameraJClass);
143        mCameraJClass = NULL;
144    }
145    clearCallbackBuffers_l(env);
146    mCamera.clear();
147}
148
149void JNICameraContext::notify(int32_t msgType, int32_t ext1, int32_t ext2)
150{
151    LOGV("notify");
152
153    // VM pointer will be NULL if object is released
154    Mutex::Autolock _l(mLock);
155    if (mCameraJObjectWeak == NULL) {
156        LOGW("callback on dead camera object");
157        return;
158    }
159    JNIEnv *env = AndroidRuntime::getJNIEnv();
160
161    /*
162     * If the notification or msgType is CAMERA_MSG_RAW_IMAGE_NOTIFY, change it
163     * to CAMERA_MSG_RAW_IMAGE since CAMERA_MSG_RAW_IMAGE_NOTIFY is not exposed
164     * to the Java app.
165     */
166    if (msgType == CAMERA_MSG_RAW_IMAGE_NOTIFY) {
167        msgType = CAMERA_MSG_RAW_IMAGE;
168    }
169
170    env->CallStaticVoidMethod(mCameraJClass, fields.post_event,
171            mCameraJObjectWeak, msgType, ext1, ext2, NULL);
172}
173
174jbyteArray JNICameraContext::getCallbackBuffer(
175        JNIEnv* env, Vector<jbyteArray>* buffers, size_t bufferSize)
176{
177    jbyteArray obj = NULL;
178
179    // Vector access should be protected by lock in postData()
180    if (!buffers->isEmpty()) {
181        LOGV("Using callback buffer from queue of length %d", buffers->size());
182        jbyteArray globalBuffer = buffers->itemAt(0);
183        buffers->removeAt(0);
184
185        obj = (jbyteArray)env->NewLocalRef(globalBuffer);
186        env->DeleteGlobalRef(globalBuffer);
187
188        if (obj != NULL) {
189            jsize bufferLength = env->GetArrayLength(obj);
190            if ((int)bufferLength < (int)bufferSize) {
191                LOGE("Callback buffer was too small! Expected %d bytes, but got %d bytes!",
192                    bufferSize, bufferLength);
193                env->DeleteLocalRef(obj);
194                return NULL;
195            }
196        }
197    }
198
199    return obj;
200}
201
202void JNICameraContext::copyAndPost(JNIEnv* env, const sp<IMemory>& dataPtr, int msgType)
203{
204    jbyteArray obj = NULL;
205
206    // allocate Java byte array and copy data
207    if (dataPtr != NULL) {
208        ssize_t offset;
209        size_t size;
210        sp<IMemoryHeap> heap = dataPtr->getMemory(&offset, &size);
211        LOGV("copyAndPost: off=%ld, size=%d", offset, size);
212        uint8_t *heapBase = (uint8_t*)heap->base();
213
214        if (heapBase != NULL) {
215            const jbyte* data = reinterpret_cast<const jbyte*>(heapBase + offset);
216
217            if (!mManualBufferMode) {
218                LOGV("Allocating callback buffer");
219                obj = env->NewByteArray(size);
220            } else {
221                switch (msgType) {
222                    case CAMERA_MSG_PREVIEW_FRAME: {
223                        obj = getCallbackBuffer(env, &mCallbackBuffers, size);
224
225                        if (mCallbackBuffers.isEmpty()) {
226                            LOGV("Out of buffers, clearing callback!");
227                            mCamera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_NOOP);
228                            mManualCameraCallbackSet = false;
229
230                            if (obj == NULL) {
231                                return;
232                            }
233                        }
234                        break;
235                    }
236                    case CAMERA_MSG_RAW_IMAGE: {
237                        obj = getCallbackBuffer(env, &mRawImageCallbackBuffers, size);
238                        break;
239                    }
240                    default: {
241                        jniThrowRuntimeException(env, "Unsupported message type");
242                        return;
243                    }
244                }
245            }
246
247            if (obj == NULL) {
248                LOGE("Couldn't allocate byte array for JPEG data");
249                env->ExceptionClear();
250            } else {
251                env->SetByteArrayRegion(obj, 0, size, data);
252            }
253        } else {
254            LOGE("image heap is NULL");
255        }
256    }
257
258    // post image data to Java
259    env->CallStaticVoidMethod(mCameraJClass, fields.post_event,
260            mCameraJObjectWeak, msgType, 0, 0, obj);
261    if (obj) {
262        env->DeleteLocalRef(obj);
263    }
264}
265
266void JNICameraContext::postData(int32_t msgType, const sp<IMemory>& dataPtr)
267{
268    // VM pointer will be NULL if object is released
269    Mutex::Autolock _l(mLock);
270    JNIEnv *env = AndroidRuntime::getJNIEnv();
271    if (mCameraJObjectWeak == NULL) {
272        LOGW("callback on dead camera object");
273        return;
274    }
275
276    // return data based on callback type
277    switch (msgType) {
278        case CAMERA_MSG_VIDEO_FRAME:
279            // should never happen
280            break;
281
282        // For backward-compatibility purpose, if there is no callback
283        // buffer for raw image, the callback returns null.
284        case CAMERA_MSG_RAW_IMAGE:
285            LOGV("rawCallback");
286            if (mRawImageCallbackBuffers.isEmpty()) {
287                env->CallStaticVoidMethod(mCameraJClass, fields.post_event,
288                        mCameraJObjectWeak, msgType, 0, 0, NULL);
289            } else {
290                copyAndPost(env, dataPtr, msgType);
291            }
292            break;
293
294        default:
295            LOGV("dataCallback(%d, %p)", msgType, dataPtr.get());
296            copyAndPost(env, dataPtr, msgType);
297            break;
298    }
299}
300
301void JNICameraContext::postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr)
302{
303    // TODO: plumb up to Java. For now, just drop the timestamp
304    postData(msgType, dataPtr);
305}
306
307void JNICameraContext::setCallbackMode(JNIEnv *env, bool installed, bool manualMode)
308{
309    Mutex::Autolock _l(mLock);
310    mManualBufferMode = manualMode;
311    mManualCameraCallbackSet = false;
312
313    // In order to limit the over usage of binder threads, all non-manual buffer
314    // callbacks use CAMERA_FRAME_CALLBACK_FLAG_BARCODE_SCANNER mode now.
315    //
316    // Continuous callbacks will have the callback re-registered from handleMessage.
317    // Manual buffer mode will operate as fast as possible, relying on the finite supply
318    // of buffers for throttling.
319
320    if (!installed) {
321        mCamera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_NOOP);
322        clearCallbackBuffers_l(env, &mCallbackBuffers);
323    } else if (mManualBufferMode) {
324        if (!mCallbackBuffers.isEmpty()) {
325            mCamera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_CAMERA);
326            mManualCameraCallbackSet = true;
327        }
328    } else {
329        mCamera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_BARCODE_SCANNER);
330        clearCallbackBuffers_l(env, &mCallbackBuffers);
331    }
332}
333
334void JNICameraContext::addCallbackBuffer(
335        JNIEnv *env, jbyteArray cbb, int msgType)
336{
337    LOGV("addCallbackBuffer: 0x%x", msgType);
338    if (cbb != NULL) {
339        Mutex::Autolock _l(mLock);
340        switch (msgType) {
341            case CAMERA_MSG_PREVIEW_FRAME: {
342                jbyteArray callbackBuffer = (jbyteArray)env->NewGlobalRef(cbb);
343                mCallbackBuffers.push(callbackBuffer);
344
345                LOGV("Adding callback buffer to queue, %d total",
346                        mCallbackBuffers.size());
347
348                // We want to make sure the camera knows we're ready for the
349                // next frame. This may have come unset had we not had a
350                // callbackbuffer ready for it last time.
351                if (mManualBufferMode && !mManualCameraCallbackSet) {
352                    mCamera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_CAMERA);
353                    mManualCameraCallbackSet = true;
354                }
355                break;
356            }
357            case CAMERA_MSG_RAW_IMAGE: {
358                jbyteArray callbackBuffer = (jbyteArray)env->NewGlobalRef(cbb);
359                mRawImageCallbackBuffers.push(callbackBuffer);
360                break;
361            }
362            default: {
363                jniThrowException(env,
364                        "java/lang/IllegalArgumentException",
365                        "Unsupported message type");
366                return;
367            }
368        }
369    } else {
370       LOGE("Null byte array!");
371    }
372}
373
374void JNICameraContext::clearCallbackBuffers_l(JNIEnv *env)
375{
376    clearCallbackBuffers_l(env, &mCallbackBuffers);
377    clearCallbackBuffers_l(env, &mRawImageCallbackBuffers);
378}
379
380void JNICameraContext::clearCallbackBuffers_l(JNIEnv *env, Vector<jbyteArray> *buffers) {
381    LOGV("Clearing callback buffers, %d remained", buffers->size());
382    while (!buffers->isEmpty()) {
383        env->DeleteGlobalRef(buffers->top());
384        buffers->pop();
385    }
386}
387
388static jint android_hardware_Camera_getNumberOfCameras(JNIEnv *env, jobject thiz)
389{
390    return Camera::getNumberOfCameras();
391}
392
393static void android_hardware_Camera_getCameraInfo(JNIEnv *env, jobject thiz,
394    jint cameraId, jobject info_obj)
395{
396    CameraInfo cameraInfo;
397    status_t rc = Camera::getCameraInfo(cameraId, &cameraInfo);
398    if (rc != NO_ERROR) {
399        jniThrowRuntimeException(env, "Fail to get camera info");
400        return;
401    }
402    env->SetIntField(info_obj, fields.facing, cameraInfo.facing);
403    env->SetIntField(info_obj, fields.orientation, cameraInfo.orientation);
404}
405
406// connect to camera service
407static void android_hardware_Camera_native_setup(JNIEnv *env, jobject thiz,
408    jobject weak_this, jint cameraId)
409{
410    sp<Camera> camera = Camera::connect(cameraId);
411
412    if (camera == NULL) {
413        jniThrowRuntimeException(env, "Fail to connect to camera service");
414        return;
415    }
416
417    // make sure camera hardware is alive
418    if (camera->getStatus() != NO_ERROR) {
419        jniThrowRuntimeException(env, "Camera initialization failed");
420        return;
421    }
422
423    jclass clazz = env->GetObjectClass(thiz);
424    if (clazz == NULL) {
425        jniThrowRuntimeException(env, "Can't find android/hardware/Camera");
426        return;
427    }
428
429    // We use a weak reference so the Camera object can be garbage collected.
430    // The reference is only used as a proxy for callbacks.
431    sp<JNICameraContext> context = new JNICameraContext(env, weak_this, clazz, camera);
432    context->incStrong(thiz);
433    camera->setListener(context);
434
435    // save context in opaque field
436    env->SetIntField(thiz, fields.context, (int)context.get());
437}
438
439// disconnect from camera service
440// It's okay to call this when the native camera context is already null.
441// This handles the case where the user has called release() and the
442// finalizer is invoked later.
443static void android_hardware_Camera_release(JNIEnv *env, jobject thiz)
444{
445    // TODO: Change to LOGV
446    LOGV("release camera");
447    JNICameraContext* context = NULL;
448    sp<Camera> camera;
449    {
450        Mutex::Autolock _l(sLock);
451        context = reinterpret_cast<JNICameraContext*>(env->GetIntField(thiz, fields.context));
452
453        // Make sure we do not attempt to callback on a deleted Java object.
454        env->SetIntField(thiz, fields.context, 0);
455    }
456
457    // clean up if release has not been called before
458    if (context != NULL) {
459        camera = context->getCamera();
460        context->release();
461        LOGV("native_release: context=%p camera=%p", context, camera.get());
462
463        // clear callbacks
464        if (camera != NULL) {
465            camera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_NOOP);
466            camera->disconnect();
467        }
468
469        // remove context to prevent further Java access
470        context->decStrong(thiz);
471    }
472}
473
474static void android_hardware_Camera_setPreviewDisplay(JNIEnv *env, jobject thiz, jobject jSurface)
475{
476    LOGV("setPreviewDisplay");
477    sp<Camera> camera = get_native_camera(env, thiz, NULL);
478    if (camera == 0) return;
479
480    sp<Surface> surface = NULL;
481    if (jSurface != NULL) {
482        surface = reinterpret_cast<Surface*>(env->GetIntField(jSurface, fields.surface));
483    }
484    if (camera->setPreviewDisplay(surface) != NO_ERROR) {
485        jniThrowException(env, "java/io/IOException", "setPreviewDisplay failed");
486    }
487}
488
489static void android_hardware_Camera_setPreviewTexture(JNIEnv *env,
490        jobject thiz, jobject jSurfaceTexture)
491{
492    LOGV("setPreviewTexture");
493    sp<Camera> camera = get_native_camera(env, thiz, NULL);
494    if (camera == 0) return;
495
496    sp<SurfaceTexture> surfaceTexture = NULL;
497    if (jSurfaceTexture != NULL) {
498        surfaceTexture = reinterpret_cast<SurfaceTexture*>(env->GetIntField(
499                jSurfaceTexture, fields.surfaceTexture));
500    }
501    if (camera->setPreviewTexture(surfaceTexture) != NO_ERROR) {
502        jniThrowException(env, "java/io/IOException",
503                "setPreviewTexture failed");
504    }
505}
506
507static void android_hardware_Camera_startPreview(JNIEnv *env, jobject thiz)
508{
509    LOGV("startPreview");
510    sp<Camera> camera = get_native_camera(env, thiz, NULL);
511    if (camera == 0) return;
512
513    if (camera->startPreview() != NO_ERROR) {
514        jniThrowRuntimeException(env, "startPreview failed");
515        return;
516    }
517}
518
519static void android_hardware_Camera_stopPreview(JNIEnv *env, jobject thiz)
520{
521    LOGV("stopPreview");
522    sp<Camera> c = get_native_camera(env, thiz, NULL);
523    if (c == 0) return;
524
525    c->stopPreview();
526}
527
528static bool android_hardware_Camera_previewEnabled(JNIEnv *env, jobject thiz)
529{
530    LOGV("previewEnabled");
531    sp<Camera> c = get_native_camera(env, thiz, NULL);
532    if (c == 0) return false;
533
534    return c->previewEnabled();
535}
536
537static void android_hardware_Camera_setHasPreviewCallback(JNIEnv *env, jobject thiz, jboolean installed, jboolean manualBuffer)
538{
539    LOGV("setHasPreviewCallback: installed:%d, manualBuffer:%d", (int)installed, (int)manualBuffer);
540    // Important: Only install preview_callback if the Java code has called
541    // setPreviewCallback() with a non-null value, otherwise we'd pay to memcpy
542    // each preview frame for nothing.
543    JNICameraContext* context;
544    sp<Camera> camera = get_native_camera(env, thiz, &context);
545    if (camera == 0) return;
546
547    // setCallbackMode will take care of setting the context flags and calling
548    // camera->setPreviewCallbackFlags within a mutex for us.
549    context->setCallbackMode(env, installed, manualBuffer);
550}
551
552static void android_hardware_Camera_addCallbackBuffer(JNIEnv *env, jobject thiz, jbyteArray bytes, int msgType) {
553    LOGV("addCallbackBuffer: 0x%x", msgType);
554
555    JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetIntField(thiz, fields.context));
556
557    if (context != NULL) {
558        context->addCallbackBuffer(env, bytes, msgType);
559    }
560}
561
562static void android_hardware_Camera_autoFocus(JNIEnv *env, jobject thiz)
563{
564    LOGV("autoFocus");
565    JNICameraContext* context;
566    sp<Camera> c = get_native_camera(env, thiz, &context);
567    if (c == 0) return;
568
569    if (c->autoFocus() != NO_ERROR) {
570        jniThrowRuntimeException(env, "autoFocus failed");
571    }
572}
573
574static void android_hardware_Camera_cancelAutoFocus(JNIEnv *env, jobject thiz)
575{
576    LOGV("cancelAutoFocus");
577    JNICameraContext* context;
578    sp<Camera> c = get_native_camera(env, thiz, &context);
579    if (c == 0) return;
580
581    if (c->cancelAutoFocus() != NO_ERROR) {
582        jniThrowRuntimeException(env, "cancelAutoFocus failed");
583    }
584}
585
586static void android_hardware_Camera_takePicture(JNIEnv *env, jobject thiz, int msgType)
587{
588    LOGV("takePicture");
589    JNICameraContext* context;
590    sp<Camera> camera = get_native_camera(env, thiz, &context);
591    if (camera == 0) return;
592
593    /*
594     * When CAMERA_MSG_RAW_IMAGE is requested, if the raw image callback
595     * buffer is available, CAMERA_MSG_RAW_IMAGE is enabled to get the
596     * notification _and_ the data; otherwise, CAMERA_MSG_RAW_IMAGE_NOTIFY
597     * is enabled to receive the callback notification but no data.
598     *
599     * Note that CAMERA_MSG_RAW_IMAGE_NOTIFY is not exposed to the
600     * Java application.
601     */
602    if (msgType & CAMERA_MSG_RAW_IMAGE) {
603        LOGV("Enable raw image callback buffer");
604        if (!context->isRawImageCallbackBufferAvailable()) {
605            LOGV("Enable raw image notification, since no callback buffer exists");
606            msgType &= ~CAMERA_MSG_RAW_IMAGE;
607            msgType |= CAMERA_MSG_RAW_IMAGE_NOTIFY;
608        }
609    }
610
611    if (camera->takePicture(msgType) != NO_ERROR) {
612        jniThrowRuntimeException(env, "takePicture failed");
613        return;
614    }
615}
616
617static void android_hardware_Camera_setParameters(JNIEnv *env, jobject thiz, jstring params)
618{
619    LOGV("setParameters");
620    sp<Camera> camera = get_native_camera(env, thiz, NULL);
621    if (camera == 0) return;
622
623    const jchar* str = env->GetStringCritical(params, 0);
624    String8 params8;
625    if (params) {
626        params8 = String8(str, env->GetStringLength(params));
627        env->ReleaseStringCritical(params, str);
628    }
629    if (camera->setParameters(params8) != NO_ERROR) {
630        jniThrowRuntimeException(env, "setParameters failed");
631        return;
632    }
633}
634
635static jstring android_hardware_Camera_getParameters(JNIEnv *env, jobject thiz)
636{
637    LOGV("getParameters");
638    sp<Camera> camera = get_native_camera(env, thiz, NULL);
639    if (camera == 0) return 0;
640
641    return env->NewStringUTF(camera->getParameters().string());
642}
643
644static void android_hardware_Camera_reconnect(JNIEnv *env, jobject thiz)
645{
646    LOGV("reconnect");
647    sp<Camera> camera = get_native_camera(env, thiz, NULL);
648    if (camera == 0) return;
649
650    if (camera->reconnect() != NO_ERROR) {
651        jniThrowException(env, "java/io/IOException", "reconnect failed");
652        return;
653    }
654}
655
656static void android_hardware_Camera_lock(JNIEnv *env, jobject thiz)
657{
658    LOGV("lock");
659    sp<Camera> camera = get_native_camera(env, thiz, NULL);
660    if (camera == 0) return;
661
662    if (camera->lock() != NO_ERROR) {
663        jniThrowRuntimeException(env, "lock failed");
664    }
665}
666
667static void android_hardware_Camera_unlock(JNIEnv *env, jobject thiz)
668{
669    LOGV("unlock");
670    sp<Camera> camera = get_native_camera(env, thiz, NULL);
671    if (camera == 0) return;
672
673    if (camera->unlock() != NO_ERROR) {
674        jniThrowRuntimeException(env, "unlock failed");
675    }
676}
677
678static void android_hardware_Camera_startSmoothZoom(JNIEnv *env, jobject thiz, jint value)
679{
680    LOGV("startSmoothZoom");
681    sp<Camera> camera = get_native_camera(env, thiz, NULL);
682    if (camera == 0) return;
683
684    status_t rc = camera->sendCommand(CAMERA_CMD_START_SMOOTH_ZOOM, value, 0);
685    if (rc == BAD_VALUE) {
686        char msg[64];
687        sprintf(msg, "invalid zoom value=%d", value);
688        jniThrowException(env, "java/lang/IllegalArgumentException", msg);
689    } else if (rc != NO_ERROR) {
690        jniThrowRuntimeException(env, "start smooth zoom failed");
691    }
692}
693
694static void android_hardware_Camera_stopSmoothZoom(JNIEnv *env, jobject thiz)
695{
696    LOGV("stopSmoothZoom");
697    sp<Camera> camera = get_native_camera(env, thiz, NULL);
698    if (camera == 0) return;
699
700    if (camera->sendCommand(CAMERA_CMD_STOP_SMOOTH_ZOOM, 0, 0) != NO_ERROR) {
701        jniThrowRuntimeException(env, "stop smooth zoom failed");
702    }
703}
704
705static void android_hardware_Camera_setDisplayOrientation(JNIEnv *env, jobject thiz,
706        jint value)
707{
708    LOGV("setDisplayOrientation");
709    sp<Camera> camera = get_native_camera(env, thiz, NULL);
710    if (camera == 0) return;
711
712    if (camera->sendCommand(CAMERA_CMD_SET_DISPLAY_ORIENTATION, value, 0) != NO_ERROR) {
713        jniThrowRuntimeException(env, "set display orientation failed");
714    }
715}
716
717static void android_hardware_Camera_startFaceDetection(JNIEnv *env, jobject thiz,
718        jint type, jobjectArray face)
719{
720    LOGV("startFaceDetection");
721    JNICameraContext* context;
722    sp<Camera> camera = get_native_camera(env, thiz, &context);
723    if (camera == 0) return;
724
725    status_t rc = camera->sendCommand(CAMERA_CMD_START_FACE_DETECTION, type, 0);
726    if (rc == BAD_VALUE) {
727        char msg[64];
728        snprintf(msg, sizeof(msg), "invalid face detection type=%d", type);
729        jniThrowException(env, "java/lang/IllegalArgumentException", msg);
730    } else if (rc != NO_ERROR) {
731        jniThrowRuntimeException(env, "start face detection failed");
732    }
733}
734
735static void android_hardware_Camera_stopFaceDetection(JNIEnv *env, jobject thiz)
736{
737    LOGV("stopFaceDetection");
738    sp<Camera> camera = get_native_camera(env, thiz, NULL);
739    if (camera == 0) return;
740
741    if (camera->sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, 0, 0) != NO_ERROR) {
742        jniThrowRuntimeException(env, "stop face detection failed");
743    }
744}
745
746//-------------------------------------------------
747
748static JNINativeMethod camMethods[] = {
749  { "getNumberOfCameras",
750    "()I",
751    (void *)android_hardware_Camera_getNumberOfCameras },
752  { "getCameraInfo",
753    "(ILandroid/hardware/Camera$CameraInfo;)V",
754    (void*)android_hardware_Camera_getCameraInfo },
755  { "native_setup",
756    "(Ljava/lang/Object;I)V",
757    (void*)android_hardware_Camera_native_setup },
758  { "native_release",
759    "()V",
760    (void*)android_hardware_Camera_release },
761  { "setPreviewDisplay",
762    "(Landroid/view/Surface;)V",
763    (void *)android_hardware_Camera_setPreviewDisplay },
764  { "setPreviewTexture",
765    "(Landroid/graphics/SurfaceTexture;)V",
766    (void *)android_hardware_Camera_setPreviewTexture },
767  { "startPreview",
768    "()V",
769    (void *)android_hardware_Camera_startPreview },
770  { "_stopPreview",
771    "()V",
772    (void *)android_hardware_Camera_stopPreview },
773  { "previewEnabled",
774    "()Z",
775    (void *)android_hardware_Camera_previewEnabled },
776  { "setHasPreviewCallback",
777    "(ZZ)V",
778    (void *)android_hardware_Camera_setHasPreviewCallback },
779  { "_addCallbackBuffer",
780    "([BI)V",
781    (void *)android_hardware_Camera_addCallbackBuffer },
782  { "native_autoFocus",
783    "()V",
784    (void *)android_hardware_Camera_autoFocus },
785  { "native_cancelAutoFocus",
786    "()V",
787    (void *)android_hardware_Camera_cancelAutoFocus },
788  { "native_takePicture",
789    "(I)V",
790    (void *)android_hardware_Camera_takePicture },
791  { "native_setParameters",
792    "(Ljava/lang/String;)V",
793    (void *)android_hardware_Camera_setParameters },
794  { "native_getParameters",
795    "()Ljava/lang/String;",
796    (void *)android_hardware_Camera_getParameters },
797  { "reconnect",
798    "()V",
799    (void*)android_hardware_Camera_reconnect },
800  { "lock",
801    "()V",
802    (void*)android_hardware_Camera_lock },
803  { "unlock",
804    "()V",
805    (void*)android_hardware_Camera_unlock },
806  { "startSmoothZoom",
807    "(I)V",
808    (void *)android_hardware_Camera_startSmoothZoom },
809  { "stopSmoothZoom",
810    "()V",
811    (void *)android_hardware_Camera_stopSmoothZoom },
812  { "setDisplayOrientation",
813    "(I)V",
814    (void *)android_hardware_Camera_setDisplayOrientation },
815  { "_startFaceDetection",
816    "(I)V",
817    (void *)android_hardware_Camera_startFaceDetection },
818  { "_stopFaceDetection",
819    "()V",
820    (void *)android_hardware_Camera_stopFaceDetection},
821};
822
823struct field {
824    const char *class_name;
825    const char *field_name;
826    const char *field_type;
827    jfieldID   *jfield;
828};
829
830static int find_fields(JNIEnv *env, field *fields, int count)
831{
832    for (int i = 0; i < count; i++) {
833        field *f = &fields[i];
834        jclass clazz = env->FindClass(f->class_name);
835        if (clazz == NULL) {
836            LOGE("Can't find %s", f->class_name);
837            return -1;
838        }
839
840        jfieldID field = env->GetFieldID(clazz, f->field_name, f->field_type);
841        if (field == NULL) {
842            LOGE("Can't find %s.%s", f->class_name, f->field_name);
843            return -1;
844        }
845
846        *(f->jfield) = field;
847    }
848
849    return 0;
850}
851
852// Get all the required offsets in java class and register native functions
853int register_android_hardware_Camera(JNIEnv *env)
854{
855    field fields_to_find[] = {
856        { "android/hardware/Camera", "mNativeContext",   "I", &fields.context },
857        { "android/view/Surface",    ANDROID_VIEW_SURFACE_JNI_ID, "I", &fields.surface },
858        { "android/graphics/SurfaceTexture",
859          ANDROID_GRAPHICS_SURFACETEXTURE_JNI_ID, "I", &fields.surfaceTexture },
860        { "android/hardware/Camera$CameraInfo", "facing",   "I", &fields.facing },
861        { "android/hardware/Camera$CameraInfo", "orientation",   "I", &fields.orientation },
862        { "android/hardware/Camera$Face", "rect", "Landroid/graphics/Rect;", &fields.face_rect },
863        { "android/hardware/Camera$Face", "score", "I", &fields.face_score },
864        { "android/graphics/Rect", "left", "I", &fields.rect_left },
865        { "android/graphics/Rect", "top", "I", &fields.rect_top },
866        { "android/graphics/Rect", "right", "I", &fields.rect_right },
867        { "android/graphics/Rect", "bottom", "I", &fields.rect_bottom },
868    };
869
870    if (find_fields(env, fields_to_find, NELEM(fields_to_find)) < 0)
871        return -1;
872
873    jclass clazz = env->FindClass("android/hardware/Camera");
874    fields.post_event = env->GetStaticMethodID(clazz, "postEventFromNative",
875                                               "(Ljava/lang/Object;IIILjava/lang/Object;)V");
876    if (fields.post_event == NULL) {
877        LOGE("Can't find android/hardware/Camera.postEventFromNative");
878        return -1;
879    }
880
881
882    // Register native functions
883    return AndroidRuntime::registerNativeMethods(env, "android/hardware/Camera",
884                                              camMethods, NELEM(camMethods));
885}
886