core/jni/android_hardware_Camera.cpp

   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 }