/*
|
* 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);
|
}
|
}
|
