android_hardware_Camera.cpp revision 31028fa621b0f182f39b1f6d391963e8e6f627fe
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 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 87private: 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 121bool JNICameraContext::isRawImageCallbackBufferAvailable() const 122{ 123 return !mRawImageCallbackBuffers.isEmpty(); 124} 125 126sp<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 144JNICameraContext::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 163void 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 193void 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 218jbyteArray 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 246void 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 299void 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 346void 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 352void 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 410void 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 437void 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 477void JNICameraContext::clearCallbackBuffers_l(JNIEnv *env) 478{ 479 clearCallbackBuffers_l(env, &mCallbackBuffers); 480 clearCallbackBuffers_l(env, &mRawImageCallbackBuffers); 481} 482 483void 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 491static jint android_hardware_Camera_getNumberOfCameras(JNIEnv *env, jobject thiz) 492{ 493 return Camera::getNumberOfCameras(); 494} 495 496static void android_hardware_Camera_getCameraInfo(JNIEnv *env, jobject thiz, 497 jint cameraId, jobject info_obj) 498{ 499 CameraInfo cameraInfo; 500 status_t rc = Camera::getCameraInfo(cameraId, &cameraInfo); 501 if (rc != NO_ERROR) { 502 jniThrowRuntimeException(env, "Fail to get camera info"); 503 return; 504 } 505 env->SetIntField(info_obj, fields.facing, cameraInfo.facing); 506 env->SetIntField(info_obj, fields.orientation, cameraInfo.orientation); 507 508 char value[PROPERTY_VALUE_MAX]; 509 property_get("ro.camera.sound.forced", value, "0"); 510 jboolean canDisableShutterSound = (strncmp(value, "0", 2) == 0); 511 env->SetBooleanField(info_obj, fields.canDisableShutterSound, 512 canDisableShutterSound); 513} 514 515// connect to camera service 516static jint android_hardware_Camera_native_setup(JNIEnv *env, jobject thiz, 517 jobject weak_this, jint cameraId, jint halVersion, jstring clientPackageName) 518{ 519 // Convert jstring to String16 520 const char16_t *rawClientName = reinterpret_cast<const char16_t*>( 521 env->GetStringChars(clientPackageName, NULL)); 522 jsize rawClientNameLen = env->GetStringLength(clientPackageName); 523 String16 clientName(rawClientName, rawClientNameLen); 524 env->ReleaseStringChars(clientPackageName, 525 reinterpret_cast<const jchar*>(rawClientName)); 526 527 sp<Camera> camera; 528 if (halVersion == CAMERA_HAL_API_VERSION_NORMAL_CONNECT) { 529 // Default path: hal version is don't care, do normal camera connect. 530 camera = Camera::connect(cameraId, clientName, 531 Camera::USE_CALLING_UID); 532 } else { 533 jint status = Camera::connectLegacy(cameraId, halVersion, clientName, 534 Camera::USE_CALLING_UID, camera); 535 if (status != NO_ERROR) { 536 return status; 537 } 538 } 539 540 if (camera == NULL) { 541 return -EACCES; 542 } 543 544 // make sure camera hardware is alive 545 if (camera->getStatus() != NO_ERROR) { 546 return NO_INIT; 547 } 548 549 jclass clazz = env->GetObjectClass(thiz); 550 if (clazz == NULL) { 551 // This should never happen 552 jniThrowRuntimeException(env, "Can't find android/hardware/Camera"); 553 return INVALID_OPERATION; 554 } 555 556 // We use a weak reference so the Camera object can be garbage collected. 557 // The reference is only used as a proxy for callbacks. 558 sp<JNICameraContext> context = new JNICameraContext(env, weak_this, clazz, camera); 559 context->incStrong((void*)android_hardware_Camera_native_setup); 560 camera->setListener(context); 561 562 // save context in opaque field 563 env->SetLongField(thiz, fields.context, (jlong)context.get()); 564 return NO_ERROR; 565} 566 567// disconnect from camera service 568// It's okay to call this when the native camera context is already null. 569// This handles the case where the user has called release() and the 570// finalizer is invoked later. 571static void android_hardware_Camera_release(JNIEnv *env, jobject thiz) 572{ 573 ALOGV("release camera"); 574 JNICameraContext* context = NULL; 575 sp<Camera> camera; 576 { 577 Mutex::Autolock _l(sLock); 578 context = reinterpret_cast<JNICameraContext*>(env->GetLongField(thiz, fields.context)); 579 580 // Make sure we do not attempt to callback on a deleted Java object. 581 env->SetLongField(thiz, fields.context, 0); 582 } 583 584 // clean up if release has not been called before 585 if (context != NULL) { 586 camera = context->getCamera(); 587 context->release(); 588 ALOGV("native_release: context=%p camera=%p", context, camera.get()); 589 590 // clear callbacks 591 if (camera != NULL) { 592 camera->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_NOOP); 593 camera->disconnect(); 594 } 595 596 // remove context to prevent further Java access 597 context->decStrong((void*)android_hardware_Camera_native_setup); 598 } 599} 600 601static void android_hardware_Camera_setPreviewSurface(JNIEnv *env, jobject thiz, jobject jSurface) 602{ 603 ALOGV("setPreviewSurface"); 604 sp<Camera> camera = get_native_camera(env, thiz, NULL); 605 if (camera == 0) return; 606 607 sp<IGraphicBufferProducer> gbp; 608 sp<Surface> surface; 609 if (jSurface) { 610 surface = android_view_Surface_getSurface(env, jSurface); 611 if (surface != NULL) { 612 gbp = surface->getIGraphicBufferProducer(); 613 } 614 } 615 616 if (camera->setPreviewTarget(gbp) != NO_ERROR) { 617 jniThrowException(env, "java/io/IOException", "setPreviewTexture failed"); 618 } 619} 620 621static void android_hardware_Camera_setPreviewTexture(JNIEnv *env, 622 jobject thiz, jobject jSurfaceTexture) 623{ 624 ALOGV("setPreviewTexture"); 625 sp<Camera> camera = get_native_camera(env, thiz, NULL); 626 if (camera == 0) return; 627 628 sp<IGraphicBufferProducer> producer = NULL; 629 if (jSurfaceTexture != NULL) { 630 producer = SurfaceTexture_getProducer(env, jSurfaceTexture); 631 if (producer == NULL) { 632 jniThrowException(env, "java/lang/IllegalArgumentException", 633 "SurfaceTexture already released in setPreviewTexture"); 634 return; 635 } 636 637 } 638 639 if (camera->setPreviewTarget(producer) != NO_ERROR) { 640 jniThrowException(env, "java/io/IOException", 641 "setPreviewTexture failed"); 642 } 643} 644 645static void android_hardware_Camera_setPreviewCallbackSurface(JNIEnv *env, 646 jobject thiz, jobject jSurface) 647{ 648 ALOGV("setPreviewCallbackSurface"); 649 JNICameraContext* context; 650 sp<Camera> camera = get_native_camera(env, thiz, &context); 651 if (camera == 0) return; 652 653 sp<IGraphicBufferProducer> gbp; 654 sp<Surface> surface; 655 if (jSurface) { 656 surface = android_view_Surface_getSurface(env, jSurface); 657 if (surface != NULL) { 658 gbp = surface->getIGraphicBufferProducer(); 659 } 660 } 661 // Clear out normal preview callbacks 662 context->setCallbackMode(env, false, false); 663 // Then set up callback surface 664 if (camera->setPreviewCallbackTarget(gbp) != NO_ERROR) { 665 jniThrowException(env, "java/io/IOException", "setPreviewCallbackTarget failed"); 666 } 667} 668 669static void android_hardware_Camera_startPreview(JNIEnv *env, jobject thiz) 670{ 671 ALOGV("startPreview"); 672 sp<Camera> camera = get_native_camera(env, thiz, NULL); 673 if (camera == 0) return; 674 675 if (camera->startPreview() != NO_ERROR) { 676 jniThrowRuntimeException(env, "startPreview failed"); 677 return; 678 } 679} 680 681static void android_hardware_Camera_stopPreview(JNIEnv *env, jobject thiz) 682{ 683 ALOGV("stopPreview"); 684 sp<Camera> c = get_native_camera(env, thiz, NULL); 685 if (c == 0) return; 686 687 c->stopPreview(); 688} 689 690static jboolean android_hardware_Camera_previewEnabled(JNIEnv *env, jobject thiz) 691{ 692 ALOGV("previewEnabled"); 693 sp<Camera> c = get_native_camera(env, thiz, NULL); 694 if (c == 0) return JNI_FALSE; 695 696 return c->previewEnabled() ? JNI_TRUE : JNI_FALSE; 697} 698 699static void android_hardware_Camera_setHasPreviewCallback(JNIEnv *env, jobject thiz, jboolean installed, jboolean manualBuffer) 700{ 701 ALOGV("setHasPreviewCallback: installed:%d, manualBuffer:%d", (int)installed, (int)manualBuffer); 702 // Important: Only install preview_callback if the Java code has called 703 // setPreviewCallback() with a non-null value, otherwise we'd pay to memcpy 704 // each preview frame for nothing. 705 JNICameraContext* context; 706 sp<Camera> camera = get_native_camera(env, thiz, &context); 707 if (camera == 0) return; 708 709 // setCallbackMode will take care of setting the context flags and calling 710 // camera->setPreviewCallbackFlags within a mutex for us. 711 context->setCallbackMode(env, installed, manualBuffer); 712} 713 714static void android_hardware_Camera_addCallbackBuffer(JNIEnv *env, jobject thiz, jbyteArray bytes, jint msgType) { 715 ALOGV("addCallbackBuffer: 0x%x", msgType); 716 717 JNICameraContext* context = reinterpret_cast<JNICameraContext*>(env->GetLongField(thiz, fields.context)); 718 719 if (context != NULL) { 720 context->addCallbackBuffer(env, bytes, msgType); 721 } 722} 723 724static void android_hardware_Camera_autoFocus(JNIEnv *env, jobject thiz) 725{ 726 ALOGV("autoFocus"); 727 JNICameraContext* context; 728 sp<Camera> c = get_native_camera(env, thiz, &context); 729 if (c == 0) return; 730 731 if (c->autoFocus() != NO_ERROR) { 732 jniThrowRuntimeException(env, "autoFocus failed"); 733 } 734} 735 736static void android_hardware_Camera_cancelAutoFocus(JNIEnv *env, jobject thiz) 737{ 738 ALOGV("cancelAutoFocus"); 739 JNICameraContext* context; 740 sp<Camera> c = get_native_camera(env, thiz, &context); 741 if (c == 0) return; 742 743 if (c->cancelAutoFocus() != NO_ERROR) { 744 jniThrowRuntimeException(env, "cancelAutoFocus failed"); 745 } 746} 747 748static void android_hardware_Camera_takePicture(JNIEnv *env, jobject thiz, jint msgType) 749{ 750 ALOGV("takePicture"); 751 JNICameraContext* context; 752 sp<Camera> camera = get_native_camera(env, thiz, &context); 753 if (camera == 0) return; 754 755 /* 756 * When CAMERA_MSG_RAW_IMAGE is requested, if the raw image callback 757 * buffer is available, CAMERA_MSG_RAW_IMAGE is enabled to get the 758 * notification _and_ the data; otherwise, CAMERA_MSG_RAW_IMAGE_NOTIFY 759 * is enabled to receive the callback notification but no data. 760 * 761 * Note that CAMERA_MSG_RAW_IMAGE_NOTIFY is not exposed to the 762 * Java application. 763 */ 764 if (msgType & CAMERA_MSG_RAW_IMAGE) { 765 ALOGV("Enable raw image callback buffer"); 766 if (!context->isRawImageCallbackBufferAvailable()) { 767 ALOGV("Enable raw image notification, since no callback buffer exists"); 768 msgType &= ~CAMERA_MSG_RAW_IMAGE; 769 msgType |= CAMERA_MSG_RAW_IMAGE_NOTIFY; 770 } 771 } 772 773 if (camera->takePicture(msgType) != NO_ERROR) { 774 jniThrowRuntimeException(env, "takePicture failed"); 775 return; 776 } 777} 778 779static void android_hardware_Camera_setParameters(JNIEnv *env, jobject thiz, jstring params) 780{ 781 ALOGV("setParameters"); 782 sp<Camera> camera = get_native_camera(env, thiz, NULL); 783 if (camera == 0) return; 784 785 const jchar* str = env->GetStringCritical(params, 0); 786 String8 params8; 787 if (params) { 788 params8 = String8(reinterpret_cast<const char16_t*>(str), 789 env->GetStringLength(params)); 790 env->ReleaseStringCritical(params, str); 791 } 792 if (camera->setParameters(params8) != NO_ERROR) { 793 jniThrowRuntimeException(env, "setParameters failed"); 794 return; 795 } 796} 797 798static jstring android_hardware_Camera_getParameters(JNIEnv *env, jobject thiz) 799{ 800 ALOGV("getParameters"); 801 sp<Camera> camera = get_native_camera(env, thiz, NULL); 802 if (camera == 0) return 0; 803 804 String8 params8 = camera->getParameters(); 805 if (params8.isEmpty()) { 806 jniThrowRuntimeException(env, "getParameters failed (empty parameters)"); 807 return 0; 808 } 809 return env->NewStringUTF(params8.string()); 810} 811 812static void android_hardware_Camera_reconnect(JNIEnv *env, jobject thiz) 813{ 814 ALOGV("reconnect"); 815 sp<Camera> camera = get_native_camera(env, thiz, NULL); 816 if (camera == 0) return; 817 818 if (camera->reconnect() != NO_ERROR) { 819 jniThrowException(env, "java/io/IOException", "reconnect failed"); 820 return; 821 } 822} 823 824static void android_hardware_Camera_lock(JNIEnv *env, jobject thiz) 825{ 826 ALOGV("lock"); 827 sp<Camera> camera = get_native_camera(env, thiz, NULL); 828 if (camera == 0) return; 829 830 if (camera->lock() != NO_ERROR) { 831 jniThrowRuntimeException(env, "lock failed"); 832 } 833} 834 835static void android_hardware_Camera_unlock(JNIEnv *env, jobject thiz) 836{ 837 ALOGV("unlock"); 838 sp<Camera> camera = get_native_camera(env, thiz, NULL); 839 if (camera == 0) return; 840 841 if (camera->unlock() != NO_ERROR) { 842 jniThrowRuntimeException(env, "unlock failed"); 843 } 844} 845 846static void android_hardware_Camera_startSmoothZoom(JNIEnv *env, jobject thiz, jint value) 847{ 848 ALOGV("startSmoothZoom"); 849 sp<Camera> camera = get_native_camera(env, thiz, NULL); 850 if (camera == 0) return; 851 852 status_t rc = camera->sendCommand(CAMERA_CMD_START_SMOOTH_ZOOM, value, 0); 853 if (rc == BAD_VALUE) { 854 char msg[64]; 855 sprintf(msg, "invalid zoom value=%d", value); 856 jniThrowException(env, "java/lang/IllegalArgumentException", msg); 857 } else if (rc != NO_ERROR) { 858 jniThrowRuntimeException(env, "start smooth zoom failed"); 859 } 860} 861 862static void android_hardware_Camera_stopSmoothZoom(JNIEnv *env, jobject thiz) 863{ 864 ALOGV("stopSmoothZoom"); 865 sp<Camera> camera = get_native_camera(env, thiz, NULL); 866 if (camera == 0) return; 867 868 if (camera->sendCommand(CAMERA_CMD_STOP_SMOOTH_ZOOM, 0, 0) != NO_ERROR) { 869 jniThrowRuntimeException(env, "stop smooth zoom failed"); 870 } 871} 872 873static void android_hardware_Camera_setDisplayOrientation(JNIEnv *env, jobject thiz, 874 jint value) 875{ 876 ALOGV("setDisplayOrientation"); 877 sp<Camera> camera = get_native_camera(env, thiz, NULL); 878 if (camera == 0) return; 879 880 if (camera->sendCommand(CAMERA_CMD_SET_DISPLAY_ORIENTATION, value, 0) != NO_ERROR) { 881 jniThrowRuntimeException(env, "set display orientation failed"); 882 } 883} 884 885static jboolean android_hardware_Camera_enableShutterSound(JNIEnv *env, jobject thiz, 886 jboolean enabled) 887{ 888 ALOGV("enableShutterSound"); 889 sp<Camera> camera = get_native_camera(env, thiz, NULL); 890 if (camera == 0) return JNI_FALSE; 891 892 int32_t value = (enabled == JNI_TRUE) ? 1 : 0; 893 status_t rc = camera->sendCommand(CAMERA_CMD_ENABLE_SHUTTER_SOUND, value, 0); 894 if (rc == NO_ERROR) { 895 return JNI_TRUE; 896 } else if (rc == PERMISSION_DENIED) { 897 return JNI_FALSE; 898 } else { 899 jniThrowRuntimeException(env, "enable shutter sound failed"); 900 return JNI_FALSE; 901 } 902} 903 904static void android_hardware_Camera_startFaceDetection(JNIEnv *env, jobject thiz, 905 jint type) 906{ 907 ALOGV("startFaceDetection"); 908 JNICameraContext* context; 909 sp<Camera> camera = get_native_camera(env, thiz, &context); 910 if (camera == 0) return; 911 912 status_t rc = camera->sendCommand(CAMERA_CMD_START_FACE_DETECTION, type, 0); 913 if (rc == BAD_VALUE) { 914 char msg[64]; 915 snprintf(msg, sizeof(msg), "invalid face detection type=%d", type); 916 jniThrowException(env, "java/lang/IllegalArgumentException", msg); 917 } else if (rc != NO_ERROR) { 918 jniThrowRuntimeException(env, "start face detection failed"); 919 } 920} 921 922static void android_hardware_Camera_stopFaceDetection(JNIEnv *env, jobject thiz) 923{ 924 ALOGV("stopFaceDetection"); 925 sp<Camera> camera = get_native_camera(env, thiz, NULL); 926 if (camera == 0) return; 927 928 if (camera->sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, 0, 0) != NO_ERROR) { 929 jniThrowRuntimeException(env, "stop face detection failed"); 930 } 931} 932 933static void android_hardware_Camera_enableFocusMoveCallback(JNIEnv *env, jobject thiz, jint enable) 934{ 935 ALOGV("enableFocusMoveCallback"); 936 sp<Camera> camera = get_native_camera(env, thiz, NULL); 937 if (camera == 0) return; 938 939 if (camera->sendCommand(CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG, enable, 0) != NO_ERROR) { 940 jniThrowRuntimeException(env, "enable focus move callback failed"); 941 } 942} 943 944//------------------------------------------------- 945 946static JNINativeMethod camMethods[] = { 947 { "getNumberOfCameras", 948 "()I", 949 (void *)android_hardware_Camera_getNumberOfCameras }, 950 { "_getCameraInfo", 951 "(ILandroid/hardware/Camera$CameraInfo;)V", 952 (void*)android_hardware_Camera_getCameraInfo }, 953 { "native_setup", 954 "(Ljava/lang/Object;IILjava/lang/String;)I", 955 (void*)android_hardware_Camera_native_setup }, 956 { "native_release", 957 "()V", 958 (void*)android_hardware_Camera_release }, 959 { "setPreviewSurface", 960 "(Landroid/view/Surface;)V", 961 (void *)android_hardware_Camera_setPreviewSurface }, 962 { "setPreviewTexture", 963 "(Landroid/graphics/SurfaceTexture;)V", 964 (void *)android_hardware_Camera_setPreviewTexture }, 965 { "setPreviewCallbackSurface", 966 "(Landroid/view/Surface;)V", 967 (void *)android_hardware_Camera_setPreviewCallbackSurface }, 968 { "startPreview", 969 "()V", 970 (void *)android_hardware_Camera_startPreview }, 971 { "_stopPreview", 972 "()V", 973 (void *)android_hardware_Camera_stopPreview }, 974 { "previewEnabled", 975 "()Z", 976 (void *)android_hardware_Camera_previewEnabled }, 977 { "setHasPreviewCallback", 978 "(ZZ)V", 979 (void *)android_hardware_Camera_setHasPreviewCallback }, 980 { "_addCallbackBuffer", 981 "([BI)V", 982 (void *)android_hardware_Camera_addCallbackBuffer }, 983 { "native_autoFocus", 984 "()V", 985 (void *)android_hardware_Camera_autoFocus }, 986 { "native_cancelAutoFocus", 987 "()V", 988 (void *)android_hardware_Camera_cancelAutoFocus }, 989 { "native_takePicture", 990 "(I)V", 991 (void *)android_hardware_Camera_takePicture }, 992 { "native_setParameters", 993 "(Ljava/lang/String;)V", 994 (void *)android_hardware_Camera_setParameters }, 995 { "native_getParameters", 996 "()Ljava/lang/String;", 997 (void *)android_hardware_Camera_getParameters }, 998 { "reconnect", 999 "()V", 1000 (void*)android_hardware_Camera_reconnect }, 1001 { "lock", 1002 "()V", 1003 (void*)android_hardware_Camera_lock }, 1004 { "unlock", 1005 "()V", 1006 (void*)android_hardware_Camera_unlock }, 1007 { "startSmoothZoom", 1008 "(I)V", 1009 (void *)android_hardware_Camera_startSmoothZoom }, 1010 { "stopSmoothZoom", 1011 "()V", 1012 (void *)android_hardware_Camera_stopSmoothZoom }, 1013 { "setDisplayOrientation", 1014 "(I)V", 1015 (void *)android_hardware_Camera_setDisplayOrientation }, 1016 { "_enableShutterSound", 1017 "(Z)Z", 1018 (void *)android_hardware_Camera_enableShutterSound }, 1019 { "_startFaceDetection", 1020 "(I)V", 1021 (void *)android_hardware_Camera_startFaceDetection }, 1022 { "_stopFaceDetection", 1023 "()V", 1024 (void *)android_hardware_Camera_stopFaceDetection}, 1025 { "enableFocusMoveCallback", 1026 "(I)V", 1027 (void *)android_hardware_Camera_enableFocusMoveCallback}, 1028}; 1029 1030struct field { 1031 const char *class_name; 1032 const char *field_name; 1033 const char *field_type; 1034 jfieldID *jfield; 1035}; 1036 1037static void find_fields(JNIEnv *env, field *fields, int count) 1038{ 1039 for (int i = 0; i < count; i++) { 1040 field *f = &fields[i]; 1041 jclass clazz = FindClassOrDie(env, f->class_name); 1042 jfieldID field = GetFieldIDOrDie(env, clazz, f->field_name, f->field_type); 1043 *(f->jfield) = field; 1044 } 1045} 1046 1047// Get all the required offsets in java class and register native functions 1048int register_android_hardware_Camera(JNIEnv *env) 1049{ 1050 field fields_to_find[] = { 1051 { "android/hardware/Camera", "mNativeContext", "J", &fields.context }, 1052 { "android/hardware/Camera$CameraInfo", "facing", "I", &fields.facing }, 1053 { "android/hardware/Camera$CameraInfo", "orientation", "I", &fields.orientation }, 1054 { "android/hardware/Camera$CameraInfo", "canDisableShutterSound", "Z", 1055 &fields.canDisableShutterSound }, 1056 { "android/hardware/Camera$Face", "rect", "Landroid/graphics/Rect;", &fields.face_rect }, 1057 { "android/hardware/Camera$Face", "leftEye", "Landroid/graphics/Point;", &fields.face_left_eye}, 1058 { "android/hardware/Camera$Face", "rightEye", "Landroid/graphics/Point;", &fields.face_right_eye}, 1059 { "android/hardware/Camera$Face", "mouth", "Landroid/graphics/Point;", &fields.face_mouth}, 1060 { "android/hardware/Camera$Face", "score", "I", &fields.face_score }, 1061 { "android/hardware/Camera$Face", "id", "I", &fields.face_id}, 1062 { "android/graphics/Rect", "left", "I", &fields.rect_left }, 1063 { "android/graphics/Rect", "top", "I", &fields.rect_top }, 1064 { "android/graphics/Rect", "right", "I", &fields.rect_right }, 1065 { "android/graphics/Rect", "bottom", "I", &fields.rect_bottom }, 1066 { "android/graphics/Point", "x", "I", &fields.point_x}, 1067 { "android/graphics/Point", "y", "I", &fields.point_y}, 1068 }; 1069 1070 find_fields(env, fields_to_find, NELEM(fields_to_find)); 1071 1072 jclass clazz = FindClassOrDie(env, "android/hardware/Camera"); 1073 fields.post_event = GetStaticMethodIDOrDie(env, clazz, "postEventFromNative", 1074 "(Ljava/lang/Object;IIILjava/lang/Object;)V"); 1075 1076 clazz = FindClassOrDie(env, "android/graphics/Rect"); 1077 fields.rect_constructor = GetMethodIDOrDie(env, clazz, "<init>", "()V"); 1078 1079 clazz = FindClassOrDie(env, "android/hardware/Camera$Face"); 1080 fields.face_constructor = GetMethodIDOrDie(env, clazz, "<init>", "()V"); 1081 1082 clazz = env->FindClass("android/graphics/Point"); 1083 fields.point_constructor = env->GetMethodID(clazz, "<init>", "()V"); 1084 if (fields.point_constructor == NULL) { 1085 ALOGE("Can't find android/graphics/Point()"); 1086 return -1; 1087 } 1088 1089 // Register native functions 1090 return RegisterMethodsOrDie(env, "android/hardware/Camera", camMethods, NELEM(camMethods)); 1091} 1092