| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.ex.camera2.portability; |
| |
| import com.android.ex.camera2.portability.debug.Log; |
| |
| import java.util.ArrayList; |
| import java.util.EnumSet; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Set; |
| import java.util.TreeSet; |
| |
| /** |
| * This class holds all the static information of a camera's capabilities. |
| * <p> |
| * The design of this class is thread-safe and can be passed around regardless |
| * of which thread using it. |
| * </p> |
| */ |
| public class CameraCapabilities { |
| |
| private static Log.Tag TAG = new Log.Tag("CamCapabs"); |
| |
| /** Zoom ratio used for seeing sensor's full field of view. */ |
| protected static final float ZOOM_RATIO_UNZOOMED = 1.0f; |
| |
| /* All internal states are declared final and should be thread-safe. */ |
| |
| protected final ArrayList<int[]> mSupportedPreviewFpsRange = new ArrayList<int[]>(); |
| protected final ArrayList<Size> mSupportedPreviewSizes = new ArrayList<Size>(); |
| protected final TreeSet<Integer> mSupportedPreviewFormats = new TreeSet<Integer>(); |
| protected final ArrayList<Size> mSupportedVideoSizes = new ArrayList<Size>(); |
| protected final ArrayList<Size> mSupportedPhotoSizes = new ArrayList<Size>(); |
| protected final TreeSet<Integer> mSupportedPhotoFormats = new TreeSet<Integer>(); |
| protected final EnumSet<SceneMode> mSupportedSceneModes = EnumSet.noneOf(SceneMode.class); |
| protected final EnumSet<FlashMode> mSupportedFlashModes = EnumSet.noneOf(FlashMode.class); |
| protected final EnumSet<FocusMode> mSupportedFocusModes = EnumSet.noneOf(FocusMode.class); |
| protected final EnumSet<WhiteBalance> mSupportedWhiteBalances = |
| EnumSet.noneOf(WhiteBalance.class); |
| protected final EnumSet<Feature> mSupportedFeatures = EnumSet.noneOf(Feature.class); |
| protected Size mPreferredPreviewSizeForVideo; |
| protected int mMinExposureCompensation; |
| protected int mMaxExposureCompensation; |
| protected float mExposureCompensationStep; |
| protected int mMaxNumOfFacesSupported; |
| protected int mMaxNumOfFocusAreas; |
| protected int mMaxNumOfMeteringArea; |
| protected float mMaxZoomRatio; |
| protected float mHorizontalViewAngle; |
| protected float mVerticalViewAngle; |
| private final Stringifier mStringifier; |
| |
| /** |
| * Focus modes. |
| */ |
| public enum FocusMode { |
| /** |
| * Continuous auto focus mode intended for taking pictures. |
| * @see {@link android.hardware.Camera.Parameters#FOCUS_MODE_AUTO}. |
| */ |
| AUTO, |
| /** |
| * Continuous auto focus mode intended for taking pictures. |
| * @see {@link android.hardware.Camera.Parameters#FOCUS_MODE_CONTINUOUS_PICTURE}. |
| */ |
| CONTINUOUS_PICTURE, |
| /** |
| * Continuous auto focus mode intended for video recording. |
| * @see {@link android.hardware.Camera.Parameters#FOCUS_MODE_CONTINUOUS_VIDEO}. |
| */ |
| CONTINUOUS_VIDEO, |
| /** |
| * Extended depth of field (EDOF). |
| * @see {@link android.hardware.Camera.Parameters#FOCUS_MODE_EDOF}. |
| */ |
| EXTENDED_DOF, |
| /** |
| * Focus is fixed. |
| * @see {@link android.hardware.Camera.Parameters#FOCUS_MODE_FIXED}. |
| */ |
| FIXED, |
| /** |
| * Focus is set at infinity. |
| * @see {@link android.hardware.Camera.Parameters#FOCUS_MODE_INFINITY}. |
| */ |
| // TODO: Unsupported on API 2 |
| INFINITY, |
| /** |
| * Macro (close-up) focus mode. |
| * @see {@link android.hardware.Camera.Parameters#FOCUS_MODE_MACRO}. |
| */ |
| MACRO, |
| } |
| |
| /** |
| * Flash modes. |
| */ |
| public enum FlashMode { |
| /** |
| * No flash. |
| */ |
| NO_FLASH, |
| /** |
| * Flash will be fired automatically when required. |
| * @see {@link android.hardware.Camera.Parameters#FLASH_MODE_OFF}. |
| */ |
| AUTO, |
| /** |
| * Flash will not be fired. |
| * @see {@link android.hardware.Camera.Parameters#FLASH_MODE_OFF}. |
| */ |
| OFF, |
| /** |
| * Flash will always be fired during snapshot. |
| * @see {@link android.hardware.Camera.Parameters#FLASH_MODE_ON}. |
| */ |
| ON, |
| /** |
| * Constant emission of light during preview, auto-focus and snapshot. |
| * @see {@link android.hardware.Camera.Parameters#FLASH_MODE_TORCH}. |
| */ |
| TORCH, |
| /** |
| * Flash will be fired in red-eye reduction mode. |
| * @see {@link android.hardware.Camera.Parameters#FLASH_MODE_RED_EYE}. |
| */ |
| RED_EYE, |
| } |
| |
| /** |
| * Scene modes. |
| */ |
| public enum SceneMode { |
| /** |
| * No supported scene mode. |
| */ |
| NO_SCENE_MODE, |
| /** |
| * Scene mode is off. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_AUTO}. |
| */ |
| AUTO, |
| /** |
| * Take photos of fast moving objects. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_ACTION}. |
| */ |
| ACTION, |
| /** |
| * Applications are looking for a barcode. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_BARCODE}. |
| */ |
| BARCODE, |
| /** |
| * Take pictures on the beach. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_BEACH}. |
| */ |
| BEACH, |
| /** |
| * Capture the naturally warm color of scenes lit by candles. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_CANDLELIGHT}. |
| */ |
| CANDLELIGHT, |
| /** |
| * For shooting firework displays. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_FIREWORKS}. |
| */ |
| FIREWORKS, |
| /** |
| * Capture a scene using high dynamic range imaging techniques. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_HDR}. |
| */ |
| // Note: Supported as a vendor tag on the Camera2 API for some LEGACY devices. |
| HDR, |
| /** |
| * Take pictures on distant objects. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_LANDSCAPE}. |
| */ |
| LANDSCAPE, |
| /** |
| * Take photos at night. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_NIGHT}. |
| */ |
| NIGHT, |
| /** |
| * Take people pictures at night. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_NIGHT_PORTRAIT}. |
| */ |
| // TODO: Unsupported on API 2 |
| NIGHT_PORTRAIT, |
| /** |
| * Take indoor low-light shot. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_PARTY}. |
| */ |
| PARTY, |
| /** |
| * Take people pictures. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_PORTRAIT}. |
| */ |
| PORTRAIT, |
| /** |
| * Take pictures on the snow. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_SNOW}. |
| */ |
| SNOW, |
| /** |
| * Take photos of fast moving objects. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_SPORTS}. |
| */ |
| SPORTS, |
| /** |
| * Avoid blurry pictures (for example, due to hand shake). |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_STEADYPHOTO}. |
| */ |
| STEADYPHOTO, |
| /** |
| * Take sunset photos. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_SUNSET}. |
| */ |
| SUNSET, |
| /** |
| * Take photos in a theater. |
| * @see {@link android.hardware.Camera.Parameters#SCENE_MODE_THEATRE}. |
| */ |
| THEATRE, |
| } |
| |
| /** |
| * White blances. |
| */ |
| public enum WhiteBalance { |
| /** |
| * @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_AUTO}. |
| */ |
| AUTO, |
| /** |
| * @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_CLOUDY_DAYLIGHT}. |
| */ |
| CLOUDY_DAYLIGHT, |
| /** |
| * @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_DAYLIGHT}. |
| */ |
| DAYLIGHT, |
| /** |
| * @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_FLUORESCENT}. |
| */ |
| FLUORESCENT, |
| /** |
| * @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_INCANDESCENT}. |
| */ |
| INCANDESCENT, |
| /** |
| * @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_SHADE}. |
| */ |
| SHADE, |
| /** |
| * @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_TWILIGHT}. |
| */ |
| TWILIGHT, |
| /** |
| * @see {@link android.hardware.Camera.Parameters#WHITE_BALANCE_WARM_FLUORESCENT}. |
| */ |
| WARM_FLUORESCENT, |
| } |
| |
| /** |
| * Features. |
| */ |
| public enum Feature { |
| /** |
| * Support zoom-related methods. |
| */ |
| ZOOM, |
| /** |
| * Support for photo capturing during video recording. |
| */ |
| VIDEO_SNAPSHOT, |
| /** |
| * Support for focus area settings. |
| */ |
| FOCUS_AREA, |
| /** |
| * Support for metering area settings. |
| */ |
| METERING_AREA, |
| /** |
| * Support for automatic exposure lock. |
| */ |
| AUTO_EXPOSURE_LOCK, |
| /** |
| * Support for automatic white balance lock. |
| */ |
| AUTO_WHITE_BALANCE_LOCK, |
| /** |
| * Support for video stabilization. |
| */ |
| VIDEO_STABILIZATION, |
| } |
| |
| /** |
| * A interface stringifier to convert abstract representations to API |
| * related string representation. |
| */ |
| public static class Stringifier { |
| /** |
| * Converts the string to hyphen-delimited lowercase for compatibility with multiple APIs. |
| * |
| * @param enumCase The name of an enum constant. |
| * @return The converted string. |
| */ |
| private static String toApiCase(String enumCase) { |
| return enumCase.toLowerCase(Locale.US).replaceAll("_", "-"); |
| } |
| |
| /** |
| * Converts the string to underscore-delimited uppercase to match the enum constant names. |
| * |
| * @param apiCase An API-related string representation. |
| * @return The converted string. |
| */ |
| private static String toEnumCase(String apiCase) { |
| return apiCase.toUpperCase(Locale.US).replaceAll("-", "_"); |
| } |
| |
| /** |
| * Converts the focus mode to API-related string representation. |
| * |
| * @param focus The focus mode to convert. |
| * @return The string used by the camera framework API to represent the |
| * focus mode. |
| */ |
| public String stringify(FocusMode focus) { |
| return toApiCase(focus.name()); |
| } |
| |
| /** |
| * Converts the API-related string representation of the focus mode to the |
| * abstract representation. |
| * |
| * @param val The string representation. |
| * @return The focus mode represented by the input string, or the focus |
| * mode with the lowest ordinal if it cannot be converted. |
| */ |
| public FocusMode focusModeFromString(String val) { |
| if (val == null) { |
| return FocusMode.values()[0]; |
| } |
| try { |
| return FocusMode.valueOf(toEnumCase(val)); |
| } catch (IllegalArgumentException ex) { |
| return FocusMode.values()[0]; |
| } |
| } |
| |
| /** |
| * Converts the flash mode to API-related string representation. |
| * |
| * @param flash The focus mode to convert. |
| * @return The string used by the camera framework API to represent the |
| * flash mode. |
| */ |
| public String stringify(FlashMode flash) { |
| return toApiCase(flash.name()); |
| } |
| |
| /** |
| * Converts the API-related string representation of the flash mode to the |
| * abstract representation. |
| * |
| * @param val The string representation. |
| * @return The flash mode represented by the input string, or the flash |
| * mode with the lowest ordinal if it cannot be converted. |
| */ |
| public FlashMode flashModeFromString(String val) { |
| if (val == null) { |
| return FlashMode.values()[0]; |
| } |
| try { |
| return FlashMode.valueOf(toEnumCase(val)); |
| } catch (IllegalArgumentException ex) { |
| return FlashMode.values()[0]; |
| } |
| } |
| |
| /** |
| * Converts the scene mode to API-related string representation. |
| * |
| * @param scene The focus mode to convert. |
| * @return The string used by the camera framework API to represent the |
| * scene mode. |
| */ |
| public String stringify(SceneMode scene) { |
| return toApiCase(scene.name()); |
| } |
| |
| /** |
| * Converts the API-related string representation of the scene mode to the |
| * abstract representation. |
| * |
| * @param val The string representation. |
| * @return The scene mode represented by the input string, or the scene |
| * mode with the lowest ordinal if it cannot be converted. |
| */ |
| public SceneMode sceneModeFromString(String val) { |
| if (val == null) { |
| return SceneMode.values()[0]; |
| } |
| try { |
| return SceneMode.valueOf(toEnumCase(val)); |
| } catch (IllegalArgumentException ex) { |
| return SceneMode.values()[0]; |
| } |
| } |
| |
| /** |
| * Converts the white balance to API-related string representation. |
| * |
| * @param wb The focus mode to convert. |
| * @return The string used by the camera framework API to represent the |
| * white balance. |
| */ |
| public String stringify(WhiteBalance wb) { |
| return toApiCase(wb.name()); |
| } |
| |
| /** |
| * Converts the API-related string representation of the white balance to |
| * the abstract representation. |
| * |
| * @param val The string representation. |
| * @return The white balance represented by the input string, or the |
| * white balance with the lowest ordinal if it cannot be |
| * converted. |
| */ |
| public WhiteBalance whiteBalanceFromString(String val) { |
| if (val == null) { |
| return WhiteBalance.values()[0]; |
| } |
| try { |
| return WhiteBalance.valueOf(toEnumCase(val)); |
| } catch (IllegalArgumentException ex) { |
| return WhiteBalance.values()[0]; |
| } |
| } |
| } |
| |
| /** |
| * Constructor. |
| * @param stringifier The API-specific stringifier for this instance. |
| */ |
| CameraCapabilities(Stringifier stringifier) { |
| mStringifier = stringifier; |
| } |
| |
| /** |
| * Copy constructor. |
| * @param src The source instance. |
| */ |
| public CameraCapabilities(CameraCapabilities src) { |
| mSupportedPreviewFpsRange.addAll(src.mSupportedPreviewFpsRange); |
| mSupportedPreviewSizes.addAll(src.mSupportedPreviewSizes); |
| mSupportedPreviewFormats.addAll(src.mSupportedPreviewFormats); |
| mSupportedVideoSizes.addAll(src.mSupportedVideoSizes); |
| mSupportedPhotoSizes.addAll(src.mSupportedPhotoSizes); |
| mSupportedPhotoFormats.addAll(src.mSupportedPhotoFormats); |
| mSupportedSceneModes.addAll(src.mSupportedSceneModes); |
| mSupportedFlashModes.addAll(src.mSupportedFlashModes); |
| mSupportedFocusModes.addAll(src.mSupportedFocusModes); |
| mSupportedWhiteBalances.addAll(src.mSupportedWhiteBalances); |
| mSupportedFeatures.addAll(src.mSupportedFeatures); |
| mPreferredPreviewSizeForVideo = src.mPreferredPreviewSizeForVideo; |
| mMaxExposureCompensation = src.mMaxExposureCompensation; |
| mMinExposureCompensation = src.mMinExposureCompensation; |
| mExposureCompensationStep = src.mExposureCompensationStep; |
| mMaxNumOfFacesSupported = src.mMaxNumOfFacesSupported; |
| mMaxNumOfFocusAreas = src.mMaxNumOfFocusAreas; |
| mMaxNumOfMeteringArea = src.mMaxNumOfMeteringArea; |
| mMaxZoomRatio = src.mMaxZoomRatio; |
| mHorizontalViewAngle = src.mHorizontalViewAngle; |
| mVerticalViewAngle = src.mVerticalViewAngle; |
| mStringifier = src.mStringifier; |
| } |
| |
| public float getHorizontalViewAngle() { |
| return mHorizontalViewAngle; |
| } |
| |
| public float getVerticalViewAngle() { |
| return mVerticalViewAngle; |
| } |
| |
| /** |
| * @return the supported picture formats. See {@link android.graphics.ImageFormat}. |
| */ |
| public Set<Integer> getSupportedPhotoFormats() { |
| return new TreeSet<Integer>(mSupportedPhotoFormats); |
| } |
| |
| /** |
| * Gets the supported preview formats. |
| * @return The supported preview {@link android.graphics.ImageFormat}s. |
| */ |
| public Set<Integer> getSupportedPreviewFormats() { |
| return new TreeSet<Integer>(mSupportedPreviewFormats); |
| } |
| |
| /** |
| * Gets the supported picture sizes. |
| */ |
| public List<Size> getSupportedPhotoSizes() { |
| return new ArrayList<Size>(mSupportedPhotoSizes); |
| } |
| |
| /** |
| * @return The supported preview fps (frame-per-second) ranges. The returned |
| * list is sorted by maximum fps then minimum fps in a descending order. |
| * The values are multiplied by 1000. |
| */ |
| public final List<int[]> getSupportedPreviewFpsRange() { |
| return new ArrayList<int[]>(mSupportedPreviewFpsRange); |
| } |
| |
| /** |
| * @return The supported preview sizes. The list is sorted by width then |
| * height in a descending order. |
| */ |
| public final List<Size> getSupportedPreviewSizes() { |
| return new ArrayList<Size>(mSupportedPreviewSizes); |
| } |
| |
| public final Size getPreferredPreviewSizeForVideo() { |
| return new Size(mPreferredPreviewSizeForVideo); |
| } |
| |
| /** |
| * @return The supported video frame sizes that can be used by MediaRecorder. |
| * The list is sorted by width then height in a descending order. |
| */ |
| public final List<Size> getSupportedVideoSizes() { |
| return new ArrayList<Size>(mSupportedVideoSizes); |
| } |
| |
| /** |
| * @return The supported scene modes. |
| */ |
| public final Set<SceneMode> getSupportedSceneModes() { |
| return new HashSet<SceneMode>(mSupportedSceneModes); |
| } |
| |
| /** |
| * @return Whether the scene mode is supported. |
| */ |
| public final boolean supports(SceneMode scene) { |
| return (scene != null && mSupportedSceneModes.contains(scene)); |
| } |
| |
| public boolean supports(final CameraSettings settings) { |
| if (zoomCheck(settings) && exposureCheck(settings) && focusCheck(settings) && |
| flashCheck(settings) && photoSizeCheck(settings) && previewSizeCheck(settings) && |
| videoStabilizationCheck(settings)) { |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * @return The supported flash modes. |
| */ |
| public final Set<FlashMode> getSupportedFlashModes() { |
| return new HashSet<FlashMode>(mSupportedFlashModes); |
| } |
| |
| /** |
| * @return Whether the flash mode is supported. |
| */ |
| public final boolean supports(FlashMode flash) { |
| return (flash != null && mSupportedFlashModes.contains(flash)); |
| } |
| |
| /** |
| * @return The supported focus modes. |
| */ |
| public final Set<FocusMode> getSupportedFocusModes() { |
| return new HashSet<FocusMode>(mSupportedFocusModes); |
| } |
| |
| /** |
| * @return Whether the focus mode is supported. |
| */ |
| public final boolean supports(FocusMode focus) { |
| return (focus != null && mSupportedFocusModes.contains(focus)); |
| } |
| |
| /** |
| * @return The supported white balanceas. |
| */ |
| public final Set<WhiteBalance> getSupportedWhiteBalance() { |
| return new HashSet<WhiteBalance>(mSupportedWhiteBalances); |
| } |
| |
| /** |
| * @return Whether the white balance is supported. |
| */ |
| public boolean supports(WhiteBalance wb) { |
| return (wb != null && mSupportedWhiteBalances.contains(wb)); |
| } |
| |
| public final Set<Feature> getSupportedFeature() { |
| return new HashSet<Feature>(mSupportedFeatures); |
| } |
| |
| public boolean supports(Feature ft) { |
| return (ft != null && mSupportedFeatures.contains(ft)); |
| } |
| |
| /** |
| * @return The maximal supported zoom ratio. |
| */ |
| public float getMaxZoomRatio() { |
| return mMaxZoomRatio; |
| } |
| |
| /** |
| * @return The min exposure compensation index. The EV is the compensation |
| * index multiplied by the step value. If unsupported, both this method and |
| * {@link #getMaxExposureCompensation()} return 0. |
| */ |
| public final int getMinExposureCompensation() { |
| return mMinExposureCompensation; |
| } |
| |
| /** |
| * @return The max exposure compensation index. The EV is the compensation |
| * index multiplied by the step value. If unsupported, both this method and |
| * {@link #getMinExposureCompensation()} return 0. |
| */ |
| public final int getMaxExposureCompensation() { |
| return mMaxExposureCompensation; |
| } |
| |
| /** |
| * @return The exposure compensation step. The EV is the compensation index |
| * multiplied by the step value. |
| */ |
| public final float getExposureCompensationStep() { |
| return mExposureCompensationStep; |
| } |
| |
| /** |
| * @return The max number of faces supported by the face detection. 0 if |
| * unsupported. |
| */ |
| public final int getMaxNumOfFacesSupported() { |
| return mMaxNumOfFacesSupported; |
| } |
| |
| /** |
| * @return The stringifier used by this instance. |
| */ |
| public Stringifier getStringifier() { |
| return mStringifier; |
| } |
| |
| private boolean zoomCheck(final CameraSettings settings) { |
| final float ratio = settings.getCurrentZoomRatio(); |
| if (!supports(Feature.ZOOM)) { |
| if (ratio != ZOOM_RATIO_UNZOOMED) { |
| Log.v(TAG, "Zoom is not supported"); |
| return false; |
| } |
| } else { |
| if (settings.getCurrentZoomRatio() > getMaxZoomRatio()) { |
| Log.v(TAG, "Zoom ratio is not supported: ratio = " + |
| settings.getCurrentZoomRatio()); |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| private boolean exposureCheck(final CameraSettings settings) { |
| final int index = settings.getExposureCompensationIndex(); |
| if (index > getMaxExposureCompensation() || index < getMinExposureCompensation()) { |
| Log.v(TAG, "Exposure compensation index is not supported. Min = " + |
| getMinExposureCompensation() + ", max = " + getMaxExposureCompensation() + "," + |
| " setting = " + index); |
| return false; |
| } |
| return true; |
| } |
| |
| private boolean focusCheck(final CameraSettings settings) { |
| FocusMode focusMode = settings.getCurrentFocusMode(); |
| if (!supports(focusMode)) { |
| if (supports(FocusMode.FIXED)) { |
| // Workaround for devices whose templates define defaults they don't really support |
| // TODO: Remove workaround (b/17177436) |
| Log.w(TAG, "Focus mode not supported... trying FIXED"); |
| settings.setFocusMode(FocusMode.FIXED); |
| } else { |
| Log.v(TAG, "Focus mode not supported:" + |
| (focusMode != null ? focusMode.name() : "null")); |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| private boolean flashCheck(final CameraSettings settings) { |
| FlashMode flashMode = settings.getCurrentFlashMode(); |
| if (!supports(flashMode)) { |
| Log.v(TAG, |
| "Flash mode not supported:" + (flashMode != null ? flashMode.name() : "null")); |
| return false; |
| } |
| return true; |
| } |
| |
| private boolean photoSizeCheck(final CameraSettings settings) { |
| Size photoSize = settings.getCurrentPhotoSize(); |
| if (mSupportedPhotoSizes.contains(photoSize)) { |
| return true; |
| } |
| Log.v(TAG, "Unsupported photo size:" + photoSize); |
| return false; |
| } |
| |
| private boolean previewSizeCheck(final CameraSettings settings) { |
| final Size previewSize = settings.getCurrentPreviewSize(); |
| if (mSupportedPreviewSizes.contains(previewSize)) { |
| return true; |
| } |
| Log.v(TAG, "Unsupported preview size:" + previewSize); |
| return false; |
| } |
| |
| private boolean videoStabilizationCheck(final CameraSettings settings) { |
| if (!settings.isVideoStabilizationEnabled() || supports(Feature.VIDEO_STABILIZATION)) { |
| return true; |
| } |
| Log.v(TAG, "Video stabilization is not supported"); |
| return false; |
| } |
| } |