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