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