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