ImageCapture: support exposure mode configuration

media/capture/video/android/java/src/org/chromium/media/VideoCaptureCamera.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.Rect;
 import android.graphics.SurfaceTexture;
@@ skipping 320 matching lines @@
             maxZoom = parameters.getZoomRatios().get(parameters.getMaxZoom());
             currentZoom = 100 + 100 * parameters.getZoom();
             minZoom = parameters.getZoomRatios().get(0);
         }
 
         Log.d(TAG, "parameters.getFocusMode(): %s", parameters.getFocusMode());
         final String focusMode = parameters.getFocusMode();
 
         // 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;
+        int jniFocusMode = AndroidMeteringMode.UNAVAILABLE;
         if (focusMode.equals(android.hardware.Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)
                 || focusMode.equals(
                            android.hardware.Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)
                 || focusMode.equals(android.hardware.Camera.Parameters.FOCUS_MODE_EDOF)) {
-            jniFocusMode = AndroidFocusMode.CONTINUOUS;
+            jniFocusMode = AndroidMeteringMode.CONTINUOUS;
         } else if (focusMode.equals(android.hardware.Camera.Parameters.FOCUS_MODE_AUTO)
                 || focusMode.equals(android.hardware.Camera.Parameters.FOCUS_MODE_MACRO)) {
-            jniFocusMode = AndroidFocusMode.SINGLE_SHOT;
+            jniFocusMode = AndroidMeteringMode.SINGLE_SHOT;
         } else if (focusMode.equals(android.hardware.Camera.Parameters.FOCUS_MODE_INFINITY)
                 || focusMode.equals(android.hardware.Camera.Parameters.FOCUS_MODE_FIXED)) {
-            jniFocusMode = AndroidFocusMode.FIXED;
+            jniFocusMode = AndroidMeteringMode.FIXED;
         }
 
+        // Exposure is usually continuously updated except it not available at all, or if the
+        // exposure compensation is locked, in which case we consider it as FIXED.
+        int jniExposureMode = parameters.getMaxNumMeteringAreas() == 0
+                ? AndroidMeteringMode.UNAVAILABLE
+                : AndroidMeteringMode.CONTINUOUS;
+        if (parameters.isAutoExposureLockSupported() && parameters.getAutoExposureLock()) {
+            jniExposureMode = AndroidMeteringMode.FIXED;
+        }
+        // TODO(mcasas): https://crbug.com/518807 read the exposure compensation min and max
+        // values using getMinExposureCompensation() and getMaxExposureCompensation().
+
         return new PhotoCapabilities(minIso, maxIso, currentIso, maxHeight, minHeight,
                 currentSize.height, maxWidth, minWidth, currentSize.width, maxZoom, minZoom,
-                currentZoom, jniFocusMode);
+                currentZoom, jniFocusMode, jniExposureMode);
     }
 
     @Override
-    public void setPhotoOptions(
-            int zoom, int focusMode, int width, int height, float[] pointsOfInterest2D) {
+    public void setPhotoOptions(int zoom, int focusMode, int exposureMode, int width, int height,
+            float[] pointsOfInterest2D) {
         android.hardware.Camera.Parameters parameters = getCameraParameters(mCamera);
 
         if (parameters.isZoomSupported() && zoom > 0) {
             // |zoomRatios| is an ordered list; need the closest zoom index for parameters.setZoom()
             final List<Integer> zoomRatios = parameters.getZoomRatios();
             int i = 1;
             for (; i < zoomRatios.size(); ++i) {
                 if (zoom < zoomRatios.get(i)) {
                     break;
                 }
             }
             parameters.setZoom(i - 1);
         }
 
-        if (focusMode == AndroidFocusMode.FIXED) {
+        if (focusMode == AndroidMeteringMode.FIXED) {
             parameters.setFocusMode(android.hardware.Camera.Parameters.FOCUS_MODE_FIXED);
-        } else if (focusMode == AndroidFocusMode.SINGLE_SHOT) {
+        } else if (focusMode == AndroidMeteringMode.SINGLE_SHOT) {
             parameters.setFocusMode(android.hardware.Camera.Parameters.FOCUS_MODE_AUTO);
-        } else if (focusMode == AndroidFocusMode.CONTINUOUS) {
+        } else if (focusMode == AndroidMeteringMode.CONTINUOUS) {
             parameters.setFocusMode(
                     android.hardware.Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
         }
+
+        if (parameters.isAutoExposureLockSupported()) {
+            if (exposureMode == AndroidMeteringMode.FIXED) {
+                parameters.setAutoExposureLock(true);
+            } else if (exposureMode != AndroidMeteringMode.UNAVAILABLE) {
+                parameters.setAutoExposureLock(false);
+            }
+        }
+        // TODO(mcasas): https://crbug.com/518807 set the exposure compensation.
+
         if (width > 0) mPhotoWidth = width;
         if (height > 0) mPhotoHeight = height;
 
         // Upon new |zoom| configuration, clear up the previous |mAreaOfInterest| if any.
         if (mAreaOfInterest != null && !mAreaOfInterest.rect.isEmpty() && zoom > 0) {
             mAreaOfInterest = null;
         }
+        // Also clear |mAreaOfInterest| if the user sets it as UNAVAILABLE.
+        if (focusMode == AndroidMeteringMode.UNAVAILABLE
+                || exposureMode == AndroidMeteringMode.UNAVAILABLE) {
+            mAreaOfInterest = null;
+        }
 
         // Update |mAreaOfInterest| if the camera supports and there are |pointsOfInterest2D|.
         if (parameters.getMaxNumMeteringAreas() > 0 && pointsOfInterest2D.length > 0) {
             assert pointsOfInterest2D.length == 1 : "Only 1 point of interest supported";
             assert pointsOfInterest2D[0] <= 1.0 && pointsOfInterest2D[0] >= 0.0;
             assert pointsOfInterest2D[1] <= 1.0 && pointsOfInterest2D[1] >= 0.0;
             // Calculate a Rect of 1/8 the canvas, which is fixed to Rect(-1000, -1000, 1000, 1000),
             // see https://developer.android.com/reference/android/hardware/Camera.Area.html
             final int centerX = Math.round(pointsOfInterest2D[0] * 2000) - 1000;
             final int centerY = Math.round(pointsOfInterest2D[1] * 2000) - 1000;
             final int regionWidth = 2000 / 8;
             final int regionHeight = 2000 / 8;
             final int weight = 1000;
 
             mAreaOfInterest = new android.hardware.Camera.Area(
                     new Rect(Math.max(-1000, centerX - regionWidth / 2),
                             Math.max(-1000, centerY - regionHeight / 2),
                             Math.min(1000, centerX + regionWidth / 2),
                             Math.min(1000, centerY + regionHeight / 2)),
                     weight);
 
             Log.d(TAG, "Area of interest %s", mAreaOfInterest.rect.toString());
         }
         if (mAreaOfInterest != null) {
             parameters.setFocusAreas(Arrays.asList(mAreaOfInterest));
+            parameters.setMeteringAreas(Arrays.asList(mAreaOfInterest));
         }
 
         mCamera.setParameters(parameters);
 
-        if (focusMode != AndroidFocusMode.SINGLE_SHOT) return;
+        if (focusMode != AndroidMeteringMode.SINGLE_SHOT) return;
         mCamera.autoFocus(new android.hardware.Camera.AutoFocusCallback() {
             @Override
             public void onAutoFocus(boolean success, android.hardware.Camera camera) {
                 Log.d(TAG, "onAutoFocus() finished: %s ", success ? "success" : "failed");
             }
         });
     }
 
     @Override
     public boolean takePhoto(final long callbackId) {
@@ skipping 71 matching lines @@
 
     // Local hook to allow derived classes to fill capture format and modify
     // camera parameters as they see fit.
     abstract void setCaptureParameters(int width, int height, int frameRate,
             android.hardware.Camera.Parameters cameraParameters);
 
     // Local method to be overriden with the particular setPreviewCallback to be
     // used in the implementations.
     abstract void setPreviewCallback(android.hardware.Camera.PreviewCallback cb);
 }