Preview FPS docs + Camera1 implementation (#661)

natario1 · web-flow · commit 218aa9d1088f · 2019-10-23T22:46:04.000+02:00
* Small changes

* Camera1 options

* Complete Camera1 integration

* Add to demo app

* Complete docs
diff --git a/README.md b/README.md
@@ -122,6 +122,7 @@ Using CameraView is extremely simple:
     app:cameraGestureScrollVertical="none|zoom|exposureCorrection|filterControl1|filterControl2"
     app:cameraEngine="camera1|camera2"
     app:cameraPreview="glSurface|surface|texture"
+    app:cameraPreviewFrameRate="@integer/preview_frame_rate"
     app:cameraFacing="back|front"
     app:cameraHdr="on|off"
     app:cameraFlash="on|auto|torch|off"
diff --git a/cameraview/src/androidTest/java/com/otaliastudios/cameraview/CameraOptions1Test.java b/cameraview/src/androidTest/java/com/otaliastudios/cameraview/CameraOptions1Test.java
@@ -22,6 +22,7 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
@@ -345,4 +346,17 @@ public void testExposureCorrection() {
         assertEquals(o.getExposureCorrectionMaxValue(), 10f * 0.5f, 0f);
     }
 
+    @Test
+    public void testPreviewFrameRate() {
+        Camera.Parameters params = mock(Camera.Parameters.class);
+        List<int[]> result = Arrays.asList(
+                new int[]{20000, 30000},
+                new int[]{30000, 60000},
+                new int[]{60000, 120000}
+        );
+        when(params.getSupportedPreviewFpsRange()).thenReturn(result);
+        CameraOptions o = new CameraOptions(params, 0, false);
+        assertEquals(20F, o.getPreviewFrameRateMinValue(), 0.001F);
+        assertEquals(120F, o.getPreviewFrameRateMaxValue(), 0.001F);
+    }
 }
diff --git a/cameraview/src/main/java/com/otaliastudios/cameraview/CameraOptions.java b/cameraview/src/main/java/com/otaliastudios/cameraview/CameraOptions.java
@@ -60,8 +60,8 @@ public class CameraOptions {
     private float exposureCorrectionMinValue;
     private float exposureCorrectionMaxValue;
     private boolean autoFocusSupported;
-    private float fpsRangeMinValue;
-    private float fpsRangeMaxValue;
+    private float previewFrameRateMinValue;
+    private float previewFrameRateMaxValue;
 
 
     public CameraOptions(@NonNull Camera.Parameters params, int cameraId, boolean flipSizes) {
@@ -159,9 +159,16 @@ public CameraOptions(@NonNull Camera.Parameters params, int cameraId, boolean fl
             }
         }
 
-        //fps range
-        fpsRangeMinValue = 0F;
-        fpsRangeMaxValue = 0F;
+        // Preview FPS
+        previewFrameRateMinValue = Float.MAX_VALUE;
+        previewFrameRateMaxValue = -Float.MAX_VALUE;
+        List<int[]> fpsRanges = params.getSupportedPreviewFpsRange();
+        for (int[] fpsRange : fpsRanges) {
+            float lower = (float) fpsRange[0] / 1000F;
+            float upper = (float) fpsRange[1] / 1000F;
+            previewFrameRateMinValue = Math.min(previewFrameRateMinValue, lower);
+            previewFrameRateMaxValue = Math.max(previewFrameRateMaxValue, upper);
+        }
     }
 
     // Camera2Engine constructor.
@@ -279,22 +286,19 @@ public CameraOptions(@NonNull CameraManager manager,
             }
         }
 
-        //fps Range
-        fpsRangeMinValue = Float.MAX_VALUE;
-        fpsRangeMaxValue = Float.MIN_VALUE;
-        Range<Integer>[] range = cameraCharacteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
+        // Preview FPS
+        Range<Integer>[] range = cameraCharacteristics.get(
+                CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
         if (range != null) {
+            previewFrameRateMinValue = Float.MAX_VALUE;
+            previewFrameRateMaxValue = -Float.MAX_VALUE;
             for (Range<Integer> fpsRange : range) {
-                if (fpsRange.getLower() <= fpsRangeMinValue) {
-                    fpsRangeMinValue = fpsRange.getLower();
-                }
-                if (fpsRange.getUpper() >= fpsRangeMaxValue) {
-                    fpsRangeMaxValue = fpsRange.getUpper();
-                }
+                previewFrameRateMinValue = Math.min(previewFrameRateMinValue, fpsRange.getLower());
+                previewFrameRateMaxValue = Math.max(previewFrameRateMaxValue, fpsRange.getUpper());
             }
         } else {
-            fpsRangeMinValue = 0F;
-            fpsRangeMaxValue = 0F;
+            previewFrameRateMinValue = 0F;
+            previewFrameRateMaxValue = 0F;
         }
     }
 
@@ -308,7 +312,6 @@ public boolean supports(@NonNull Control control) {
         return getSupportedControls(control.getClass()).contains(control);
     }
 
-
     /**
      * Shorthand for other methods in this class,
      * e.g. supports(GestureAction.ZOOM) == isZoomSupported().
@@ -333,7 +336,6 @@ public boolean supports(@NonNull GestureAction action) {
         return false;
     }
 
-
     @SuppressWarnings("unchecked")
     @NonNull
     public <T extends Control> Collection<T> getSupportedControls(@NonNull Class<T> controlClass) {
@@ -362,7 +364,6 @@ public <T extends Control> Collection<T> getSupportedControls(@NonNull Class<T>
         return Collections.emptyList();
     }
 
-
     /**
      * Set of supported picture sizes for the currently opened camera.
      *
@@ -373,7 +374,6 @@ public Collection<Size> getSupportedPictureSizes() {
         return Collections.unmodifiableSet(supportedPictureSizes);
     }
 
-
     /**
      * Set of supported picture aspect ratios for the currently opened camera.
      *
@@ -385,7 +385,6 @@ public Collection<AspectRatio> getSupportedPictureAspectRatios() {
         return Collections.unmodifiableSet(supportedPictureAspectRatio);
     }
 
-
     /**
      * Set of supported video sizes for the currently opened camera.
      *
@@ -396,7 +395,6 @@ public Collection<Size> getSupportedVideoSizes() {
         return Collections.unmodifiableSet(supportedVideoSizes);
     }
 
-
     /**
      * Set of supported picture aspect ratios for the currently opened camera.
      *
@@ -408,7 +406,6 @@ public Collection<AspectRatio> getSupportedVideoAspectRatios() {
         return Collections.unmodifiableSet(supportedVideoAspectRatio);
     }
 
-
     /**
      * Set of supported facing values.
      *
@@ -421,7 +418,6 @@ public Collection<Facing> getSupportedFacing() {
         return Collections.unmodifiableSet(supportedFacing);
     }
 
-
     /**
      * Set of supported flash values.
      *
@@ -436,7 +432,6 @@ public Collection<Flash> getSupportedFlash() {
         return Collections.unmodifiableSet(supportedFlash);
     }
 
-
     /**
      * Set of supported white balance values.
      *
@@ -452,7 +447,6 @@ public Collection<WhiteBalance> getSupportedWhiteBalance() {
         return Collections.unmodifiableSet(supportedWhiteBalance);
     }
 
-
     /**
      * Set of supported hdr values.
      *
@@ -488,7 +482,6 @@ public boolean isAutoFocusSupported() {
         return autoFocusSupported;
     }
 
-
     /**
      * Whether exposure correction is supported. If this is false, calling
      * {@link CameraView#setExposureCorrection(float)} has no effect.
@@ -501,7 +494,6 @@ public boolean isExposureCorrectionSupported() {
         return exposureCorrectionSupported;
     }
 
-
     /**
      * The minimum value of negative exposure correction, in EV stops.
      * This is presumably negative or 0 if not supported.
@@ -524,18 +516,20 @@ public float getExposureCorrectionMaxValue() {
     }
 
     /**
-     * The minimum value for FPS
+     * The minimum value for the preview frame rate, in frames per second (FPS).
+     *
      * @return the min value
      */
-    public float getFpsRangeMinValue() {
-        return fpsRangeMinValue;
+    public float getPreviewFrameRateMinValue() {
+        return previewFrameRateMinValue;
     }
 
     /**
-     * The maximum value for FPS
+     * The maximum value for the preview frame rate, in frames per second (FPS).
+     *
      * @return the max value
      */
-    public float getFpsRangeMaxValue() {
-        return fpsRangeMaxValue;
+    public float getPreviewFrameRateMaxValue() {
+        return previewFrameRateMaxValue;
     }
 }
diff --git a/cameraview/src/main/java/com/otaliastudios/cameraview/CameraView.java b/cameraview/src/main/java/com/otaliastudios/cameraview/CameraView.java
@@ -1450,16 +1450,23 @@ public int getVideoBitRate() {
     }
 
     /**
-     * Sets the frame rate for the video
-     * Will be used by {@link #takeVideoSnapshot(File)}.
+     * Sets the preview frame rate in frames per second.
+     * This rate will be used, for example, by the frame processor and in video
+     * snapshot taken through {@link #takeVideo(File)}.
+     *
+     * A value of 0F will restore the rate to a default value.
+     *
      * @param frameRate desired frame rate
      */
     public void setPreviewFrameRate(float frameRate) {
         mCameraEngine.setPreviewFrameRate(frameRate);
     }
 
     /**
-     * Returns the current frame rate.
+     * Returns the current preview frame rate.
+     * This can return 0F if no frame rate was set.
+     *
+     * @see #setPreviewFrameRate(float)
      * @return current frame rate
      */
     public float getPreviewFrameRate() {
diff --git a/cameraview/src/main/java/com/otaliastudios/cameraview/engine/Camera1Engine.java b/cameraview/src/main/java/com/otaliastudios/cameraview/engine/Camera1Engine.java
@@ -12,8 +12,8 @@
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
-import androidx.annotation.WorkerThread;
 
+import android.util.Range;
 import android.view.SurfaceHolder;
 
 import com.google.android.gms.tasks.Task;
@@ -392,6 +392,7 @@ protected void onTakeVideoSnapshot(@NonNull VideoResult.Stub stub,
         // The correct formula seems to be deviceOrientation+displayOffset,
         // which means offset(Reference.VIEW, Reference.OUTPUT, Axis.ABSOLUTE).
         stub.rotation = getAngles().offset(Reference.VIEW, Reference.OUTPUT, Axis.ABSOLUTE);
+        stub.videoFrameRate = Math.round(mPreviewFrameRate);
         LOG.i("onTakeVideoSnapshot", "rotation:", stub.rotation, "size:", stub.size);
 
         // Start.
@@ -423,6 +424,7 @@ private void applyAllParameters(@NonNull Camera.Parameters params) {
         applyZoom(params, 0F);
         applyExposureCorrection(params, 0F);
         applyPlaySounds(mPlaySounds);
+        applyPreviewFrameRate(params, 0F);
     }
 
     private void applyDefaultFocus(@NonNull Camera.Parameters params) {
@@ -666,8 +668,53 @@ private boolean applyPlaySounds(boolean oldPlaySound) {
         return false;
     }
 
-    @Override public void setPreviewFrameRate(float previewFrameRate) {
-        // This method does nothing
+    @Override
+    public void setPreviewFrameRate(float previewFrameRate) {
+        final float old = previewFrameRate;
+        mPreviewFrameRate = previewFrameRate;
+        mHandler.run(new Runnable() {
+            @Override
+            public void run() {
+                if (getEngineState() == STATE_STARTED) {
+                    Camera.Parameters params = mCamera.getParameters();
+                    if (applyPreviewFrameRate(params, old)) mCamera.setParameters(params);
+                }
+                mPreviewFrameRateOp.end(null);
+            }
+        });
+    }
+
+    private boolean applyPreviewFrameRate(@NonNull Camera.Parameters params,
+                                          float oldPreviewFrameRate) {
+        List<int[]> fpsRanges = params.getSupportedPreviewFpsRange();
+        if (mPreviewFrameRate == 0F) {
+            // 0F is a special value. Fallback to a reasonable default.
+            for (int[] fpsRange : fpsRanges) {
+                float lower = (float) fpsRange[0] / 1000F;
+                float upper = (float) fpsRange[1] / 1000F;
+                if ((lower <= 30F && 30F <= upper) || (lower <= 24F && 24F <= upper)) {
+                    params.setPreviewFpsRange(fpsRange[0], fpsRange[1]);
+                    return true;
+                }
+            }
+        } else {
+            // If out of boundaries, adjust it.
+            mPreviewFrameRate = Math.min(mPreviewFrameRate,
+                    mCameraOptions.getPreviewFrameRateMaxValue());
+            mPreviewFrameRate = Math.max(mPreviewFrameRate,
+                    mCameraOptions.getPreviewFrameRateMinValue());
+            for (int[] fpsRange : fpsRanges) {
+                float lower = (float) fpsRange[0] / 1000F;
+                float upper = (float) fpsRange[1] / 1000F;
+                float rate = Math.round(mPreviewFrameRate);
+                if (lower <= rate && rate <= upper) {
+                    params.setPreviewFpsRange(fpsRange[0], fpsRange[1]);
+                    return true;
+                }
+            }
+        }
+        mPreviewFrameRate = oldPreviewFrameRate;
+        return false;
     }
 
     //endregion
diff --git a/cameraview/src/main/java/com/otaliastudios/cameraview/engine/Camera2Engine.java b/cameraview/src/main/java/com/otaliastudios/cameraview/engine/Camera2Engine.java
@@ -83,7 +83,6 @@ public class Camera2Engine extends CameraEngine implements ImageReader.OnImageAv
 
     private static final int FRAME_PROCESSING_FORMAT = ImageFormat.NV21;
     private static final int FRAME_PROCESSING_INPUT_FORMAT = ImageFormat.YUV_420_888;
-    private static final int DEFAULT_FRAME_RATE = 30;
     @VisibleForTesting static final long METER_TIMEOUT = 2500;
 
     private final CameraManager mManager;
@@ -815,7 +814,6 @@ protected void onTakeVideoSnapshot(@NonNull VideoResult.Stub stub,
         if (!(mPreview instanceof GlCameraPreview)) {
             throw new IllegalStateException("Video snapshots are only supported with GL_SURFACE.");
         }
-        stub.videoFrameRate = (int) mPreviewFrameRate;
         GlCameraPreview glPreview = (GlCameraPreview) mPreview;
         Size outputSize = getUncroppedSnapshotSize(Reference.OUTPUT);
         if (outputSize == null) {
@@ -834,6 +832,7 @@ protected void onTakeVideoSnapshot(@NonNull VideoResult.Stub stub,
         // Unlike Camera1, the correct formula seems to be deviceOrientation,
         // which means offset(Reference.BASE, Reference.OUTPUT, Axis.ABSOLUTE).
         stub.rotation = getAngles().offset(Reference.BASE, Reference.OUTPUT, Axis.ABSOLUTE);
+        stub.videoFrameRate = Math.round(mPreviewFrameRate);
         LOG.i("onTakeVideoSnapshot", "rotation:", stub.rotation, "size:", stub.size);
 
         // Start.
@@ -1273,22 +1272,31 @@ public void run() {
     }
 
     @SuppressWarnings("WeakerAccess")
-    protected boolean applyPreviewFrameRate(@NonNull CaptureRequest.Builder builder, float oldPreviewFrameRate) {
-        Range<Integer>[] fpsRanges = mCameraCharacteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
-        if (fpsRanges != null) {
-            if (mPreviewFrameRate != 0f) {
-                for (Range<Integer> fpsRange : fpsRanges) {
-                    if (fpsRange.contains((int) mPreviewFrameRate)) {
-                        builder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, fpsRange);
-                        return true;
-                    }
+    protected boolean applyPreviewFrameRate(@NonNull CaptureRequest.Builder builder,
+                                            float oldPreviewFrameRate) {
+        //noinspection unchecked
+        Range<Integer>[] fallback = new Range[]{};
+        Range<Integer>[] fpsRanges = readCharacteristic(
+                CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
+                fallback);
+        if (mPreviewFrameRate == 0F) {
+            // 0F is a special value. Fallback to a reasonable default.
+            for (Range<Integer> fpsRange : fpsRanges) {
+                if (fpsRange.contains(30) || fpsRange.contains(24)) {
+                    builder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, fpsRange);
+                    return true;
                 }
-            } else {
-                for (Range<Integer> fpsRange : fpsRanges) {
-                    if (fpsRange.contains(DEFAULT_FRAME_RATE)) {
-                        builder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, fpsRange);
-                        return true;
-                    }
+            }
+        } else {
+            // If out of boundaries, adjust it.
+            mPreviewFrameRate = Math.min(mPreviewFrameRate,
+                    mCameraOptions.getPreviewFrameRateMaxValue());
+            mPreviewFrameRate = Math.max(mPreviewFrameRate,
+                    mCameraOptions.getPreviewFrameRateMinValue());
+            for (Range<Integer> fpsRange : fpsRanges) {
+                if (fpsRange.contains(Math.round(mPreviewFrameRate))) {
+                    builder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, fpsRange);
+                    return true;
                 }
             }
         }
diff --git a/demo/src/main/java/com/otaliastudios/cameraview/demo/CameraActivity.java b/demo/src/main/java/com/otaliastudios/cameraview/demo/CameraActivity.java
diff --git a/demo/src/main/java/com/otaliastudios/cameraview/demo/Option.java b/demo/src/main/java/com/otaliastudios/cameraview/demo/Option.java
diff --git a/docs/_posts/2018-12-20-controls.md b/docs/_posts/2018-12-20-controls.md

Original file line number	Diff line number	Diff line change
`@@ -60,8 +60,8 @@ public class CameraOptions {`
`60`	`60`	`private float exposureCorrectionMinValue;`
`61`	`61`	`private float exposureCorrectionMaxValue;`
`62`	`62`	`private boolean autoFocusSupported;`
`63`		`- private float fpsRangeMinValue;`
`64`		`- private float fpsRangeMaxValue;`
	`63`	`+ private float previewFrameRateMinValue;`
	`64`	`+ private float previewFrameRateMaxValue;`
`65`	`65`
`66`	`66`
`67`	`67`	`public CameraOptions(@NonNull Camera.Parameters params, int cameraId, boolean flipSizes) {`
`@@ -159,9 +159,16 @@ public CameraOptions(@NonNull Camera.Parameters params, int cameraId, boolean fl`
`159`	`159`	`}`
`160`	`160`	`}`
`161`	`161`
`162`		`- //fps range`
`163`		`- fpsRangeMinValue = 0F;`
`164`		`- fpsRangeMaxValue = 0F;`
	`162`	`+ // Preview FPS`
	`163`	`+ previewFrameRateMinValue = Float.MAX_VALUE;`
	`164`	`+ previewFrameRateMaxValue = -Float.MAX_VALUE;`
	`165`	`+ List<int[]> fpsRanges = params.getSupportedPreviewFpsRange();`
	`166`	`+ for (int[] fpsRange : fpsRanges) {`
	`167`	`+ float lower = (float) fpsRange[0] / 1000F;`
	`168`	`+ float upper = (float) fpsRange[1] / 1000F;`
	`169`	`+ previewFrameRateMinValue = Math.min(previewFrameRateMinValue, lower);`
	`170`	`+ previewFrameRateMaxValue = Math.max(previewFrameRateMaxValue, upper);`
	`171`	`+ }`
`165`	`172`	`}`
`166`	`173`
`167`	`174`	`// Camera2Engine constructor.`
`@@ -279,22 +286,19 @@ public CameraOptions(@NonNull CameraManager manager,`
`279`	`286`	`}`
`280`	`287`	`}`
`281`	`288`
`282`		`- //fps Range`
`283`		`- fpsRangeMinValue = Float.MAX_VALUE;`
`284`		`- fpsRangeMaxValue = Float.MIN_VALUE;`
`285`		`- Range<Integer>[] range = cameraCharacteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);`
	`289`	`+ // Preview FPS`
	`290`	`+ Range<Integer>[] range = cameraCharacteristics.get(`
	`291`	`+ CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);`
`286`	`292`	`if (range != null) {`
	`293`	`+ previewFrameRateMinValue = Float.MAX_VALUE;`
	`294`	`+ previewFrameRateMaxValue = -Float.MAX_VALUE;`
`287`	`295`	`for (Range<Integer> fpsRange : range) {`
`288`		`- if (fpsRange.getLower() <= fpsRangeMinValue) {`
`289`		`- fpsRangeMinValue = fpsRange.getLower();`
`290`		`- }`
`291`		`- if (fpsRange.getUpper() >= fpsRangeMaxValue) {`
`292`		`- fpsRangeMaxValue = fpsRange.getUpper();`
`293`		`- }`
	`296`	`+ previewFrameRateMinValue = Math.min(previewFrameRateMinValue, fpsRange.getLower());`
	`297`	`+ previewFrameRateMaxValue = Math.max(previewFrameRateMaxValue, fpsRange.getUpper());`
`294`	`298`	`}`
`295`	`299`	`} else {`
`296`		`- fpsRangeMinValue = 0F;`
`297`		`- fpsRangeMaxValue = 0F;`
	`300`	`+ previewFrameRateMinValue = 0F;`
	`301`	`+ previewFrameRateMaxValue = 0F;`
`298`	`302`	`}`
`299`	`303`	`}`
`300`	`304`
`@@ -308,7 +312,6 @@ public boolean supports(@NonNull Control control) {`
`308`	`312`	`return getSupportedControls(control.getClass()).contains(control);`
`309`	`313`	`}`
`310`	`314`
`311`		`-`
`312`	`315`	`/**`
`313`	`316`	`* Shorthand for other methods in this class,`
`314`	`317`	`* e.g. supports(GestureAction.ZOOM) == isZoomSupported().`
`@@ -333,7 +336,6 @@ public boolean supports(@NonNull GestureAction action) {`
`333`	`336`	`return false;`
`334`	`337`	`}`
`335`	`338`
`336`		`-`
`337`	`339`	`@SuppressWarnings("unchecked")`
`338`	`340`	`@NonNull`
`339`	`341`	`public <T extends Control> Collection<T> getSupportedControls(@NonNull Class<T> controlClass) {`
`@@ -362,7 +364,6 @@ public <T extends Control> Collection<T> getSupportedControls(@NonNull Class<T>`
`362`	`364`	`return Collections.emptyList();`
`363`	`365`	`}`
`364`	`366`
`365`		`-`
`366`	`367`	`/**`
`367`	`368`	`* Set of supported picture sizes for the currently opened camera.`
`368`	`369`	`*`
`@@ -373,7 +374,6 @@ public Collection<Size> getSupportedPictureSizes() {`
`373`	`374`	`return Collections.unmodifiableSet(supportedPictureSizes);`
`374`	`375`	`}`
`375`	`376`
`376`		`-`
`377`	`377`	`/**`
`378`	`378`	`* Set of supported picture aspect ratios for the currently opened camera.`
`379`	`379`	`*`
`@@ -385,7 +385,6 @@ public Collection<AspectRatio> getSupportedPictureAspectRatios() {`
`385`	`385`	`return Collections.unmodifiableSet(supportedPictureAspectRatio);`
`386`	`386`	`}`
`387`	`387`
`388`		`-`
`389`	`388`	`/**`
`390`	`389`	`* Set of supported video sizes for the currently opened camera.`
`391`	`390`	`*`
`@@ -396,7 +395,6 @@ public Collection<Size> getSupportedVideoSizes() {`
`396`	`395`	`return Collections.unmodifiableSet(supportedVideoSizes);`
`397`	`396`	`}`
`398`	`397`
`399`		`-`
`400`	`398`	`/**`
`401`	`399`	`* Set of supported picture aspect ratios for the currently opened camera.`
`402`	`400`	`*`
`@@ -408,7 +406,6 @@ public Collection<AspectRatio> getSupportedVideoAspectRatios() {`
`408`	`406`	`return Collections.unmodifiableSet(supportedVideoAspectRatio);`
`409`	`407`	`}`
`410`	`408`
`411`		`-`
`412`	`409`	`/**`
`413`	`410`	`* Set of supported facing values.`
`414`	`411`	`*`
`@@ -421,7 +418,6 @@ public Collection<Facing> getSupportedFacing() {`
`421`	`418`	`return Collections.unmodifiableSet(supportedFacing);`
`422`	`419`	`}`
`423`	`420`
`424`		`-`
`425`	`421`	`/**`
`426`	`422`	`* Set of supported flash values.`
`427`	`423`	`*`
`@@ -436,7 +432,6 @@ public Collection<Flash> getSupportedFlash() {`
`436`	`432`	`return Collections.unmodifiableSet(supportedFlash);`
`437`	`433`	`}`
`438`	`434`
`439`		`-`
`440`	`435`	`/**`
`441`	`436`	`* Set of supported white balance values.`
`442`	`437`	`*`
`@@ -452,7 +447,6 @@ public Collection<WhiteBalance> getSupportedWhiteBalance() {`
`452`	`447`	`return Collections.unmodifiableSet(supportedWhiteBalance);`
`453`	`448`	`}`
`454`	`449`
`455`		`-`
`456`	`450`	`/**`
`457`	`451`	`* Set of supported hdr values.`
`458`	`452`	`*`
`@@ -488,7 +482,6 @@ public boolean isAutoFocusSupported() {`
`488`	`482`	`return autoFocusSupported;`
`489`	`483`	`}`
`490`	`484`
`491`		`-`
`492`	`485`	`/**`
`493`	`486`	`* Whether exposure correction is supported. If this is false, calling`
`494`	`487`	`* {@link CameraView#setExposureCorrection(float)} has no effect.`
`@@ -501,7 +494,6 @@ public boolean isExposureCorrectionSupported() {`
`501`	`494`	`return exposureCorrectionSupported;`
`502`	`495`	`}`
`503`	`496`
`504`		`-`
`505`	`497`	`/**`
`506`	`498`	`* The minimum value of negative exposure correction, in EV stops.`
`507`	`499`	`* This is presumably negative or 0 if not supported.`
`@@ -524,18 +516,20 @@ public float getExposureCorrectionMaxValue() {`
`524`	`516`	`}`
`525`	`517`
`526`	`518`	`/**`
`527`		`- * The minimum value for FPS`
	`519`	`+ * The minimum value for the preview frame rate, in frames per second (FPS).`
	`520`	`+ *`
`528`	`521`	`* @return the min value`
`529`	`522`	`*/`
`530`		`- public float getFpsRangeMinValue() {`
`531`		`- return fpsRangeMinValue;`
	`523`	`+ public float getPreviewFrameRateMinValue() {`
	`524`	`+ return previewFrameRateMinValue;`
`532`	`525`	`}`
`533`	`526`
`534`	`527`	`/**`
`535`		`- * The maximum value for FPS`
	`528`	`+ * The maximum value for the preview frame rate, in frames per second (FPS).`
	`529`	`+ *`
`536`	`530`	`* @return the max value`
`537`	`531`	`*/`
`538`		`- public float getFpsRangeMaxValue() {`
`539`		`- return fpsRangeMaxValue;`
	`532`	`+ public float getPreviewFrameRateMaxValue() {`
	`533`	`+ return previewFrameRateMaxValue;`
`540`	`534`	`}`
`541`	`535`	`}`