ImageCapture: support enhanced FocusMode getting/setting

media/capture/video/android/java/src/org/chromium/media/VideoCaptureCamera2.java

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.media;
 
 import android.annotation.TargetApi;
 import android.content.Context;
 import android.graphics.ImageFormat;
 import android.graphics.Rect;
@@ skipping 227 matching lines @@
 
     private final Object mCameraStateLock = new Object();
 
     private CameraDevice mCameraDevice;
     private CameraCaptureSession mPreviewSession;
     private CaptureRequest mPreviewRequest;
 
     private CameraState mCameraState = CameraState.STOPPED;
     private final float mMaxZoom;
     private Rect mCropRect = new Rect();
+    private int mFocusMode = AndroidFocusMode.CONTINUOUS;
+    private int mPhotoWidth = 0;
+    private int mPhotoHeight = 0;
 
     // Service function to grab CameraCharacteristics and handle exceptions.
     private static CameraCharacteristics getCameraCharacteristics(Context appContext, int id) {
         final CameraManager manager =
                 (CameraManager) appContext.getSystemService(Context.CAMERA_SERVICE);
         try {
             return manager.getCameraCharacteristics(Integer.toString(id));
         } catch (CameraAccessException ex) {
             Log.e(TAG, "getCameraCharacteristics: ", ex);
         }
@@ skipping 37 matching lines @@
         // Construct an ImageReader Surface and plug it into our CaptureRequest.Builder.
         previewRequestBuilder.addTarget(imageReader.getSurface());
 
         // A series of configuration options in the PreviewBuilder
         previewRequestBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
         previewRequestBuilder.set(
                 CaptureRequest.NOISE_REDUCTION_MODE, CameraMetadata.NOISE_REDUCTION_MODE_FAST);
         previewRequestBuilder.set(CaptureRequest.EDGE_MODE, CameraMetadata.EDGE_MODE_FAST);
         previewRequestBuilder.set(CaptureRequest.CONTROL_VIDEO_STABILIZATION_MODE,
                 CameraMetadata.CONTROL_VIDEO_STABILIZATION_MODE_ON);
+        if (mFocusMode == AndroidFocusMode.CONTINUOUS) {
+            Log.d(TAG, "Focus: CONTROL_AF_MODE_CONTINUOUS_PICTURE");
+            previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
+                    CameraMetadata.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
+        } else if (mFocusMode == AndroidFocusMode.SINGLE_SHOT) {
+            Log.d(TAG, "Focus: triggering a single shot");
+            previewRequestBuilder.set(
+                    CaptureRequest.CONTROL_AF_MODE, CameraMetadata.CONTROL_AF_MODE_AUTO);
+            previewRequestBuilder.set(
+                    CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_START);
+        }
+
         // SENSOR_EXPOSURE_TIME ?
         if (!mCropRect.isEmpty()) {
             previewRequestBuilder.set(CaptureRequest.SCALER_CROP_REGION, mCropRect);
         }
 
         List<Surface> surfaceList = new ArrayList<Surface>(1);
         surfaceList.add(imageReader.getSurface());
 
         mPreviewRequest = previewRequestBuilder.build();
         final CrPreviewSessionListener captureSessionListener =
@@ skipping 241 matching lines @@
         int minWidth = Integer.MAX_VALUE;
         int minHeight = Integer.MAX_VALUE;
         int maxWidth = 0;
         int maxHeight = 0;
         for (Size size : supportedSizes) {
             if (size.getWidth() < minWidth) minWidth = size.getWidth();
             if (size.getHeight() < minHeight) minHeight = size.getHeight();
             if (size.getWidth() > maxWidth) maxWidth = size.getWidth();
             if (size.getHeight() > maxHeight) maxHeight = size.getHeight();
         }
-        final int currentHeight = mCaptureFormat.getHeight();
-        final int currentWidth = mCaptureFormat.getWidth();
+        final int currentHeight = (mPhotoHeight > 0) ? mPhotoHeight : mCaptureFormat.getHeight();
+        final int currentWidth = (mPhotoWidth > 0) ? mPhotoWidth : mCaptureFormat.getWidth();
 
         // The Min and Max zoom are returned as x100 by the API to avoid using floating point. There
         // is no min-zoom per se, so clamp it to always 100 (TODO(mcasas): make const member).
         final int minZoom = 100;
         final int maxZoom = Math.round(mMaxZoom * 100);
         // Width Ratio x100 is used as measure of current zoom.
-        final int currentZoom = 100 * mPreviewRequest.get(CaptureRequest.SCALER_CROP_REGION).width()
-                / cameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE)
-                          .width();
+        final int currentZoom = 100
+                * cameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE)
+                          .width()
+                / mPreviewRequest.get(CaptureRequest.SCALER_CROP_REGION).width();
 
         final int focusMode = mPreviewRequest.get(CaptureRequest.CONTROL_AF_MODE);
-        Log.d(TAG, "focusMode " + focusMode);
-        final boolean isFocusManual = (focusMode == CameraMetadata.CONTROL_AF_MODE_OFF)
-                || (focusMode == CameraMetadata.CONTROL_AF_MODE_EDOF);
+        Log.d(TAG, "focusMode: %s", focusMode);
+        // Classify the Focus capabilities. In CONTINUOUS and SINGLE_SHOT, we can call
+        // autoFocus(AutoFocusCallback) to configure region(s) to focus onto.
+        int jniFocusMode = AndroidFocusMode.UNAVAILABLE;
+        if (focusMode == CameraMetadata.CONTROL_AF_MODE_CONTINUOUS_VIDEO
+                || focusMode == CameraMetadata.CONTROL_AF_MODE_CONTINUOUS_PICTURE) {
+            jniFocusMode = AndroidFocusMode.CONTINUOUS;
+        } else if (focusMode == CameraMetadata.CONTROL_AF_MODE_AUTO
+                || focusMode == CameraMetadata.CONTROL_AF_MODE_MACRO) {
+            jniFocusMode = AndroidFocusMode.SINGLE_SHOT;
+        } else if (focusMode == CameraMetadata.CONTROL_AF_MODE_OFF) {
+            jniFocusMode = AndroidFocusMode.FIXED;
+        } else {
+            assert jniFocusMode == CameraMetadata.CONTROL_AF_MODE_EDOF;
+        }
 
         return new PhotoCapabilities(minIso, maxIso, currentIso, maxHeight, minHeight,
                 currentHeight, maxWidth, minWidth, currentWidth, maxZoom, minZoom, currentZoom,
-                !isFocusManual);
+                jniFocusMode);
     }
 
     @Override
-    public void setZoom(int zoom) {
+    public void setPhotoOptions(int zoom, int focusMode, int width, int height) {
         final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(mContext, mId);
         final Rect canvas =
                 cameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
 
-        final float normalizedZoom = Math.max(100, Math.min(zoom, mMaxZoom * 100)) / 100;
-        final float cropFactor = (normalizedZoom - 1) / (2 * normalizedZoom);
+        if (zoom != 0) {
+            final float normalizedZoom = Math.max(100, Math.min(zoom, mMaxZoom * 100)) / 100;
+            final float cropFactor = (normalizedZoom - 1) / (2 * normalizedZoom);
 
-        mCropRect = new Rect(Math.round(canvas.width() * cropFactor),
-                Math.round(canvas.height() * cropFactor),
-                Math.round(canvas.width() * (1 - cropFactor)),
-                Math.round(canvas.height() * (1 - cropFactor)));
-        Log.d(TAG, "zoom level " + normalizedZoom + ", rectangle: " + mCropRect.toString());
+            mCropRect = new Rect(Math.round(canvas.width() * cropFactor),
+                    Math.round(canvas.height() * cropFactor),
+                    Math.round(canvas.width() * (1 - cropFactor)),
+                    Math.round(canvas.height() * (1 - cropFactor)));
+            Log.d(TAG, "zoom level %f, rectangle: %s", normalizedZoom, mCropRect.toString());
+        }
+
+        mFocusMode = focusMode;
+
+        if (width > 0) mPhotoWidth = width;
+        if (height > 0) mPhotoHeight = height;
 
         final Handler mainHandler = new Handler(mContext.getMainLooper());
         mainHandler.removeCallbacks(mRestartCapture);
         mainHandler.post(mRestartCapture);
     }
 
     @Override
-    public boolean takePhoto(final long callbackId, int width, int height) {
+    public boolean takePhoto(final long callbackId) {
         Log.d(TAG, "takePhoto " + callbackId);
         if (mCameraDevice == null || mCameraState != CameraState.STARTED) return false;
 
         final CameraCharacteristics cameraCharacteristics = getCameraCharacteristics(mContext, mId);
         final StreamConfigurationMap streamMap =
                 cameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
         final Size[] supportedSizes = streamMap.getOutputSizes(ImageFormat.JPEG);
-        final Size closestSize = findClosestSizeInArray(supportedSizes, width, height);
+        final Size closestSize = findClosestSizeInArray(supportedSizes, mPhotoWidth, mPhotoHeight);
 
-        Log.d(TAG, "requested resolution: (%dx%d)", width, height);
+        Log.d(TAG, "requested resolution: (%dx%d)", mPhotoWidth, mPhotoHeight);
         if (closestSize != null) {
             Log.d(TAG, " matched (%dx%d)", closestSize.getWidth(), closestSize.getHeight());
         }
         final ImageReader imageReader = ImageReader.newInstance(
                 (closestSize != null) ? closestSize.getWidth() : mCaptureFormat.getWidth(),
                 (closestSize != null) ? closestSize.getHeight() : mCaptureFormat.getHeight(),
                 ImageFormat.JPEG, 1 /* maxImages */);
 
         HandlerThread thread = new HandlerThread("CameraPicture");
         thread.start();
@@ skipping 16 matching lines @@
         if (photoRequestBuilder == null) {
             Log.e(TAG, "photoRequestBuilder error");
             return false;
         }
         photoRequestBuilder.addTarget(imageReader.getSurface());
         photoRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION, getCameraRotation());
         if (!mCropRect.isEmpty()) {
             photoRequestBuilder.set(CaptureRequest.SCALER_CROP_REGION, mCropRect);
         }
 
+        if (mFocusMode == AndroidFocusMode.CONTINUOUS) {
+            photoRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
+                    CameraMetadata.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
+        } else if (mFocusMode == AndroidFocusMode.SINGLE_SHOT) {
+            Log.d(TAG, "triggering auto focus (maybe?)");
+            photoRequestBuilder.set(
+                    CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_START);
+        }
+
         final CaptureRequest photoRequest = photoRequestBuilder.build();
         final CrPhotoSessionListener sessionListener =
                 new CrPhotoSessionListener(photoRequest, callbackId);
         try {
             mCameraDevice.createCaptureSession(surfaceList, sessionListener, backgroundHandler);
         } catch (CameraAccessException | IllegalArgumentException | SecurityException ex) {
             Log.e(TAG, "createCaptureSession: " + ex);
             return false;
         }
         return true;
     }
 
     @Override
     public void deallocate() {
         Log.d(TAG, "deallocate");
     }
 }