android-6.0.0_r1/s

/*
 * 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 android.hardware.Camera;

import com.android.ex.camera2.portability.debug.Log;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

/**
 * A class which stores the camera settings.
 */
public abstract class CameraSettings {
    private static final Log.Tag TAG = new Log.Tag("CamSet");

    // Attempts to provide a value outside this range will be ignored.
    private static final int MIN_JPEG_COMPRESSION_QUALITY = 1;
    private static final int MAX_JPEG_COMPRESSION_QUALITY = 100;

    protected final Map<String, String> mGeneralSetting = new TreeMap<>();
    protected final List<Camera.Area> mMeteringAreas = new ArrayList<>();
    protected final List<Camera.Area> mFocusAreas = new ArrayList<>();
    protected boolean mSizesLocked;
    protected int mPreviewFpsRangeMin;
    protected int mPreviewFpsRangeMax;
    protected int mPreviewFrameRate;
    protected Size mCurrentPreviewSize;
    private int mCurrentPreviewFormat;
    protected Size mCurrentPhotoSize;
    protected byte mJpegCompressQuality;
    protected int mCurrentPhotoFormat;
    protected float mCurrentZoomRatio;
    protected int mExposureCompensationIndex;
    protected CameraCapabilities.FlashMode mCurrentFlashMode;
    protected CameraCapabilities.FocusMode mCurrentFocusMode;
    protected CameraCapabilities.SceneMode mCurrentSceneMode;
    protected CameraCapabilities.WhiteBalance mWhiteBalance;
    protected boolean mVideoStabilizationEnabled;
    protected boolean mAutoExposureLocked;
    protected boolean mAutoWhiteBalanceLocked;
    protected boolean mRecordingHintEnabled;
    protected GpsData mGpsData;
    protected Size mExifThumbnailSize;

    /**
     * An immutable class storing GPS related information.
     * <p>It's a hack since we always use GPS time stamp but does not use other
     * fields sometimes. Setting processing method to null means the other
     * fields should not be used.</p>
     */
    public static class GpsData {
        public final double latitude;
        public final double longitude;
        public final double altitude;
        public final long timeStamp;
        public final String processingMethod;

        /**
         * Construct what may or may not actually represent a location,
         * depending on the value of {@code processingMethod}.
         *
         * <p>Setting {@code processingMethod} to {@code null} means that
         * {@code latitude}, {@code longitude}, and {@code altitude} will be
         * completely ignored.</p>
         */
        public GpsData(double latitude, double longitude, double altitude, long timeStamp,
                String processingMethod) {
            if (processingMethod == null &&
                    (latitude != 0.0 || longitude != 0.0 || altitude != 0.0)) {
                Log.w(TAG, "GpsData's nonzero data will be ignored due to null processingMethod");
            }
            this.latitude = latitude;
            this.longitude = longitude;
            this.altitude = altitude;
            this.timeStamp = timeStamp;
            this.processingMethod = processingMethod;
        }

        /** Copy constructor. */
        public GpsData(GpsData src) {
            this.latitude = src.latitude;
            this.longitude = src.longitude;
            this.altitude = src.altitude;
            this.timeStamp = src.timeStamp;
            this.processingMethod = src.processingMethod;
        }
    }

    protected CameraSettings() {
    }

    /**
     * Copy constructor.
     *
     * @param src The source settings.
     * @return The copy of the source.
     */
    protected CameraSettings(CameraSettings src) {
        mGeneralSetting.putAll(src.mGeneralSetting);
        mMeteringAreas.addAll(src.mMeteringAreas);
        mFocusAreas.addAll(src.mFocusAreas);
        mSizesLocked = src.mSizesLocked;
        mPreviewFpsRangeMin = src.mPreviewFpsRangeMin;
        mPreviewFpsRangeMax = src.mPreviewFpsRangeMax;
        mPreviewFrameRate = src.mPreviewFrameRate;
        mCurrentPreviewSize =
                (src.mCurrentPreviewSize == null ? null : new Size(src.mCurrentPreviewSize));
        mCurrentPreviewFormat = src.mCurrentPreviewFormat;
        mCurrentPhotoSize =
                (src.mCurrentPhotoSize == null ? null : new Size(src.mCurrentPhotoSize));
        mJpegCompressQuality = src.mJpegCompressQuality;
        mCurrentPhotoFormat = src.mCurrentPhotoFormat;
        mCurrentZoomRatio = src.mCurrentZoomRatio;
        mExposureCompensationIndex = src.mExposureCompensationIndex;
        mCurrentFlashMode = src.mCurrentFlashMode;
        mCurrentFocusMode = src.mCurrentFocusMode;
        mCurrentSceneMode = src.mCurrentSceneMode;
        mWhiteBalance = src.mWhiteBalance;
        mVideoStabilizationEnabled = src.mVideoStabilizationEnabled;
        mAutoExposureLocked = src.mAutoExposureLocked;
        mAutoWhiteBalanceLocked = src.mAutoWhiteBalanceLocked;
        mRecordingHintEnabled = src.mRecordingHintEnabled;
        mGpsData = src.mGpsData;
        mExifThumbnailSize = src.mExifThumbnailSize;
    }

    /**
     * @return A copy of this object, as an instance of the implementing class.
     */
    public abstract CameraSettings copy();

    /** General setting **/
    @Deprecated
    public void setSetting(String key, String value) {
        mGeneralSetting.put(key, value);
    }

    /**
     * Changes whether classes outside this class are allowed to set the preview
     * and photo capture sizes.
     *
     * @param locked Whether to prevent changes to these fields.
     *
     * @see #setPhotoSize
     * @see #setPreviewSize
     */
    /*package*/ void setSizesLocked(boolean locked) {
        mSizesLocked = locked;
    }

    /**  Preview **/

    /**
     * Sets the preview FPS range. This call will invalidate prior calls to
     * {@link #setPreviewFrameRate(int)}.
     *
     * @param min The min FPS.
     * @param max The max FPS.
     */
    public void setPreviewFpsRange(int min, int max) {
        if (min > max) {
            int temp = max;
            max = min;
            min = temp;
        }
        mPreviewFpsRangeMax = max;
        mPreviewFpsRangeMin = min;
        mPreviewFrameRate = -1;
    }

    /**
     * @return The min of the preview FPS range.
     */
    public int getPreviewFpsRangeMin() {
        return mPreviewFpsRangeMin;
    }

    /**
     * @return The max of the preview FPS range.
     */
    public int getPreviewFpsRangeMax() {
        return mPreviewFpsRangeMax;
    }

    /**
     * Sets the preview FPS. This call will invalidate prior calls to
     * {@link #setPreviewFpsRange(int, int)}.
     *
     * @param frameRate The target frame rate.
     */
    public void setPreviewFrameRate(int frameRate) {
        if (frameRate > 0) {
            mPreviewFrameRate = frameRate;
            mPreviewFpsRangeMax = frameRate;
            mPreviewFpsRangeMin = frameRate;
        }
    }

    public int getPreviewFrameRate() {
        return mPreviewFrameRate;
    }

    /**
     * @return The current preview size.
     */
    public Size getCurrentPreviewSize() {
        return new Size(mCurrentPreviewSize);
    }

    /**
     * @param previewSize The size to use for preview.
     * @return Whether the operation was allowed (i.e. the sizes are unlocked).
     */
    public boolean setPreviewSize(Size previewSize) {
        if (mSizesLocked) {
            Log.w(TAG, "Attempt to change preview size while locked");
            return false;
        }

        mCurrentPreviewSize = new Size(previewSize);
        return true;
    }

    /**
     * Sets the preview format.
     *
     * @param format
     * @see {@link android.graphics.ImageFormat}.
     */
    public void setPreviewFormat(int format) {
        mCurrentPreviewFormat = format;
    }

    /**
     * @return The preview format.
     * @see {@link android.graphics.ImageFormat}.
     */
    public int getCurrentPreviewFormat() {
        return mCurrentPreviewFormat;
    }

    /** Picture **/

    /**
     * @return The current photo size.
     */
    public Size getCurrentPhotoSize() {
        return new Size(mCurrentPhotoSize);
    }

    /**
     * @param photoSize The size to use for preview.
     * @return Whether the operation was allowed (i.e. the sizes are unlocked).
     */
    public boolean setPhotoSize(Size photoSize) {
        if (mSizesLocked) {
            Log.w(TAG, "Attempt to change photo size while locked");
            return false;
        }

        mCurrentPhotoSize = new Size(photoSize);
        return true;
    }

    /**
     * Sets the format for the photo.
     *
     * @param format The format for the photos taken.
     * @see {@link android.graphics.ImageFormat}.
     */
    public void setPhotoFormat(int format) {
        mCurrentPhotoFormat = format;
    }

    /**
     * @return The format for the photos taken.
     * @see {@link android.graphics.ImageFormat}.
     */
    public int getCurrentPhotoFormat() {
        return mCurrentPhotoFormat;
    }

    /**
     * Sets the JPEG compression quality.
     *
     * @param quality The quality for JPEG.
     */
    public void setPhotoJpegCompressionQuality(int quality) {
        if (quality < MIN_JPEG_COMPRESSION_QUALITY || quality > MAX_JPEG_COMPRESSION_QUALITY) {
            Log.w(TAG, "Ignoring JPEG quality that falls outside the expected range");
            return;
        }
        // This is safe because the positive numbers go up to 127.
        mJpegCompressQuality = (byte) quality;
    }

    public int getPhotoJpegCompressionQuality() {
        return mJpegCompressQuality;
    }

    /** Zoom **/

    /**
     * @return The current zoom ratio. The min is 1.0f.
     */
    public float getCurrentZoomRatio() {
        return mCurrentZoomRatio;
    }

    /**
     * Sets the zoom ratio.
     * @param ratio The new zoom ratio. Should be in the range between 1.0 to
     *              the value returned from {@link
     *              com.android.camera.cameradevice.CameraCapabilities#getMaxZoomRatio()}.
     * @throws java.lang.UnsupportedOperationException if the ratio is not
     *         supported.
     */
    public void setZoomRatio(float ratio) {
        mCurrentZoomRatio = ratio;
    }

    /** Exposure **/

    public void setExposureCompensationIndex(int index) {
        mExposureCompensationIndex = index;
    }

    /**
     * @return The exposure compensation, with 0 meaning unadjusted.
     */
    public int getExposureCompensationIndex() {
        return mExposureCompensationIndex;
    }

    public void setAutoExposureLock(boolean locked) {
        mAutoExposureLocked = locked;
    }

    public boolean isAutoExposureLocked() {
        return mAutoExposureLocked;
    }

    /**
     * @param areas The areas for autoexposure. The coordinate system has domain
     *              and range [-1000,1000], measured relative to the visible
     *              preview image, with orientation matching that of the sensor.
     *              This means the coordinates must be transformed to account
     *              for the devices rotation---but not the zoom level---before
     *              being passed into this method.
     */
    public void setMeteringAreas(List<Camera.Area> areas) {
        mMeteringAreas.clear();
        if (areas != null) {
            mMeteringAreas.addAll(areas);
        }
    }

    public List<Camera.Area> getMeteringAreas() {
        return new ArrayList<Camera.Area>(mMeteringAreas);
    }

    /** Flash **/

    public CameraCapabilities.FlashMode getCurrentFlashMode() {
        return mCurrentFlashMode;
    }

    public void setFlashMode(CameraCapabilities.FlashMode flashMode) {
        mCurrentFlashMode = flashMode;
    }

    /** Focus **/

    /**
     * Sets the focus mode.
     * @param focusMode The focus mode to use.
     */
    public void setFocusMode(CameraCapabilities.FocusMode focusMode) {
        mCurrentFocusMode = focusMode;
    }

    /**
     * @return The current focus mode.
     */
    public CameraCapabilities.FocusMode getCurrentFocusMode() {
        return mCurrentFocusMode;
    }

    /**
     * @param areas The areas to focus. The coordinate system has domain and
     *              range [-1000,1000], measured relative to the visible preview
     *              image, with orientation matching that of the sensor. This
     *              means the coordinates must be transformed to account for
     *              the devices rotation---but not the zoom level---before being
     *              passed into this method.
     */
    public void setFocusAreas(List<Camera.Area> areas) {
        mFocusAreas.clear();
        if (areas != null) {
            mFocusAreas.addAll(areas);
        }
    }

    public List<Camera.Area> getFocusAreas() {
        return new ArrayList<Camera.Area>(mFocusAreas);
    }

    /** White balance **/

    public void setWhiteBalance(CameraCapabilities.WhiteBalance whiteBalance) {
        mWhiteBalance = whiteBalance;
    }

    public CameraCapabilities.WhiteBalance getWhiteBalance() {
        return mWhiteBalance;
    }

    public void setAutoWhiteBalanceLock(boolean locked) {
        mAutoWhiteBalanceLocked = locked;
    }

    public boolean isAutoWhiteBalanceLocked() {
        return mAutoWhiteBalanceLocked;
    }

    /** Scene mode **/

    /**
     * @return The current scene mode.
     */
    public CameraCapabilities.SceneMode getCurrentSceneMode() {
        return mCurrentSceneMode;
    }

    /**
     * Sets the scene mode for capturing.
     *
     * @param sceneMode The scene mode to use.
     * @throws java.lang.UnsupportedOperationException if it's not supported.
     */
    public void setSceneMode(CameraCapabilities.SceneMode sceneMode) {
        mCurrentSceneMode = sceneMode;
    }

    /** Other Features **/

    public void setVideoStabilization(boolean enabled) {
        mVideoStabilizationEnabled = enabled;
    }

    public boolean isVideoStabilizationEnabled() {
        return mVideoStabilizationEnabled;
    }

    public void setRecordingHintEnabled(boolean hintEnabled) {
        mRecordingHintEnabled = hintEnabled;
    }

    public boolean isRecordingHintEnabled() {
        return mRecordingHintEnabled;
    }

    public void setGpsData(GpsData data) {
        mGpsData = new GpsData(data);
    }

    public GpsData getGpsData() {
        return (mGpsData == null ? null : new GpsData(mGpsData));
    }

    public void clearGpsData() {
        mGpsData = null;
    }

    /**
     * Sets the size of the thumbnail in EXIF header. To suppress thumbnail
     * generation, set a size of (0,0).
     *
     * @param s The size for the thumbnail. If {@code null}, agent will not
     *          set a thumbnail size.
     */
    public void setExifThumbnailSize(Size s) {
        mExifThumbnailSize = s;
    }

    /**
     * Gets the size of the thumbnail in EXIF header.
     *
     * @return desired thumbnail size, or null if no size was set
     */
    public Size getExifThumbnailSize() {
        return (mExifThumbnailSize == null) ? null : new Size(mExifThumbnailSize);
    }
}