Image Capture: wire supported exposure/focus/white balance modes Android

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.ImageFormat;
 import android.graphics.Rect;
@@ skipping 468 matching lines @@
             maxZoom = parameters.getZoomRatios().get(parameters.getMaxZoom());
             currentZoom = parameters.getZoomRatios().get(parameters.getZoom());
             minZoom = parameters.getZoomRatios().get(0);
             if (parameters.getZoomRatios().size() > 1) {
                 stepZoom = parameters.getZoomRatios().get(1) - parameters.getZoomRatios().get(0);
             }
         }
         builder.setMinZoom(minZoom).setMaxZoom(maxZoom);
         builder.setCurrentZoom(currentZoom).setStepZoom(stepZoom);
 
-        Log.d(TAG, "parameters.getFocusMode(): %s", parameters.getFocusMode());
+        // Classify the Focus capabilities and state. In CONTINUOUS and SINGLE_SHOT, we can call
+        // autoFocus(AutoFocusCallback) to configure region(s) to focus onto.
+        final List<String> focusModes = parameters.getSupportedFocusModes();
+        assert focusModes != null : "getSupportedFocusModes() should never return null";
+        ArrayList<Integer> jniFocusModes = new ArrayList<Integer>(3);
+        if (focusModes.contains(android.hardware.Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)
+                || focusModes.contains(
+                           android.hardware.Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)
+                || focusModes.contains(android.hardware.Camera.Parameters.FOCUS_MODE_EDOF)) {
+            jniFocusModes.add(Integer.valueOf(AndroidMeteringMode.CONTINUOUS));
+        }
+        // FOCUS_MODE_{AUTO,MACRO} do not imply continuously focusing: need autoFocus() trigger.
+        if (focusModes.contains(android.hardware.Camera.Parameters.FOCUS_MODE_AUTO)
+                || focusModes.contains(android.hardware.Camera.Parameters.FOCUS_MODE_MACRO)) {
+            jniFocusModes.add(Integer.valueOf(AndroidMeteringMode.SINGLE_SHOT));
+        }
+        if (focusModes.contains(android.hardware.Camera.Parameters.FOCUS_MODE_INFINITY)
+                || focusModes.contains(android.hardware.Camera.Parameters.FOCUS_MODE_FIXED)) {
+            jniFocusModes.add(Integer.valueOf(AndroidMeteringMode.FIXED));
+        }
+        builder.setFocusModes(integerArrayListToArray(jniFocusModes));
+
         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 = AndroidMeteringMode.NONE;
         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 = AndroidMeteringMode.CONTINUOUS;
         } else if (focusMode.equals(android.hardware.Camera.Parameters.FOCUS_MODE_AUTO)
                 || focusMode.equals(android.hardware.Camera.Parameters.FOCUS_MODE_MACRO)) {
             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 = AndroidMeteringMode.FIXED;
         }
         builder.setFocusMode(jniFocusMode);
 
-        // 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.NONE
-                : AndroidMeteringMode.CONTINUOUS;
+        // Auto Exposure is the usual capability and state, unless AE is not available at all, which
+        // is signalled by the absence of Metering Areas. Exposure Compensation can also support or
+        // be locked, this is equivalent to AndroidMeteringMode.FIXED.
+        ArrayList<Integer> jniExposureModes = new ArrayList<Integer>(2);
+        if (parameters.getMaxNumMeteringAreas() > 0) {
+            jniExposureModes.add(AndroidMeteringMode.CONTINUOUS);
+        }
+        if (parameters.isAutoExposureLockSupported()) {
+            jniExposureModes.add(AndroidMeteringMode.FIXED);
+        }
+        builder.setExposureModes(integerArrayListToArray(jniExposureModes));
+
+        int jniExposureMode = AndroidMeteringMode.CONTINUOUS;
         if (parameters.isAutoExposureLockSupported() && parameters.getAutoExposureLock()) {
             jniExposureMode = AndroidMeteringMode.FIXED;
         }
         builder.setExposureMode(jniExposureMode);
 
         final float step = parameters.getExposureCompensationStep();
         builder.setStepExposureCompensation(step);
         builder.setMinExposureCompensation(parameters.getMinExposureCompensation() * step);
         builder.setMaxExposureCompensation(parameters.getMaxExposureCompensation() * step);
         builder.setCurrentExposureCompensation(parameters.getExposureCompensation() * step);
 
-        int jniWhiteBalanceMode = AndroidMeteringMode.NONE;
-        if (parameters.isAutoWhiteBalanceLockSupported()
-                && parameters.getSupportedWhiteBalance() != null) {
-            jniWhiteBalanceMode = parameters.getWhiteBalance()
-                            == android.hardware.Camera.Parameters.WHITE_BALANCE_AUTO
-                    ? AndroidMeteringMode.CONTINUOUS
-                    : AndroidMeteringMode.FIXED;
+        ArrayList<Integer> jniWhiteBalanceModes = new ArrayList<Integer>(2);
+        List<String> whiteBalanceModes = parameters.getSupportedWhiteBalance();
+        if (whiteBalanceModes != null) {
+            if (!whiteBalanceModes.isEmpty()) {
+                // |whiteBalanceModes| can have WHITE_BALANCE_AUTO and any value in
+                // |COLOR_TEMPERATURES_MAP|; they are all considered CONTINUOUS metering mode.
+                jniWhiteBalanceModes.add(AndroidMeteringMode.CONTINUOUS);
+            }
+            if (parameters.isAutoWhiteBalanceLockSupported()) {
+                jniWhiteBalanceModes.add(AndroidMeteringMode.FIXED);
+            }
+        }
+        builder.setWhiteBalanceModes(integerArrayListToArray(jniWhiteBalanceModes));
+
+        int jniWhiteBalanceMode = AndroidMeteringMode.CONTINUOUS;
+        if (parameters.isAutoWhiteBalanceLockSupported() && parameters.getAutoWhiteBalanceLock()) {
+            jniWhiteBalanceMode = AndroidMeteringMode.FIXED;
         }
         builder.setWhiteBalanceMode(jniWhiteBalanceMode);
 
         builder.setMinColorTemperature(COLOR_TEMPERATURES_MAP.keyAt(0));
         builder.setMaxColorTemperature(
                 COLOR_TEMPERATURES_MAP.keyAt(COLOR_TEMPERATURES_MAP.size() - 1));
         if (jniWhiteBalanceMode == AndroidMeteringMode.FIXED) {
             final int index = COLOR_TEMPERATURES_MAP.indexOfValue(parameters.getWhiteBalance());
             if (index >= 0) builder.setCurrentColorTemperature(COLOR_TEMPERATURES_MAP.keyAt(index));
         }
@@ skipping 12 matching lines @@
             if (flashModes.contains(android.hardware.Camera.Parameters.FLASH_MODE_OFF)) {
                 modes.add(Integer.valueOf(AndroidFillLightMode.OFF));
             }
             if (flashModes.contains(android.hardware.Camera.Parameters.FLASH_MODE_AUTO)) {
                 modes.add(Integer.valueOf(AndroidFillLightMode.AUTO));
             }
             if (flashModes.contains(android.hardware.Camera.Parameters.FLASH_MODE_ON)) {
                 modes.add(Integer.valueOf(AndroidFillLightMode.FLASH));
             }
 
-            int[] modesAsIntArray = new int[modes.size()];
-            for (int i = 0; i < modes.size(); i++) modesAsIntArray[i] = modes.get(i).intValue();
-            builder.setFillLightModes(modesAsIntArray);
+            builder.setFillLightModes(integerArrayListToArray(modes));
         }
 
         return builder.build();
     }
 
     @Override
     public void setPhotoOptions(double zoom, int focusMode, int exposureMode, double width,
             double height, float[] pointsOfInterest2D, boolean hasExposureCompensation,
             double exposureCompensation, int whiteBalanceMode, double iso,
             boolean hasRedEyeReduction, boolean redEyeReduction, int fillLightMode,
@@ skipping 37 matching lines @@
         }
         // Also clear |mAreaOfInterest| if the user sets it as NONE.
         if (focusMode == AndroidMeteringMode.NONE || exposureMode == AndroidMeteringMode.NONE) {
             mAreaOfInterest = null;
         }
 
         // Update |mAreaOfInterest| if the camera supports and there are |pointsOfInterest2D|.
         final boolean pointsOfInterestSupported =
                 parameters.getMaxNumMeteringAreas() > 0 || parameters.getMaxNumFocusAreas() > 0;
         if (pointsOfInterestSupported && pointsOfInterest2D.length > 0) {
-            assert pointsOfInterest2D.length == 1 : "Only 1 point of interest supported";
+            assert pointsOfInterest2D.length == 2 : "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;
 
@@ skipping 156 matching lines @@
                         getCameraRotation());
             }
         } finally {
             mPreviewBufferLock.unlock();
             if (camera != null) {
                 camera.addCallbackBuffer(data);
             }
         }
     }
 }