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