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