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