/*
|
* 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.camera.settings;
|
|
import android.app.AlertDialog;
|
import android.content.Context;
|
import android.content.DialogInterface;
|
import android.content.res.Resources;
|
import android.media.CamcorderProfile;
|
import android.util.SparseArray;
|
|
import com.android.camera.debug.Log;
|
import com.android.camera.util.ApiHelper;
|
import com.android.camera.util.Callback;
|
import com.android.camera.util.Size;
|
import com.android.camera2.R;
|
import com.android.ex.camera2.portability.CameraDeviceInfo;
|
import com.android.ex.camera2.portability.CameraSettings;
|
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.LinkedList;
|
import java.util.List;
|
|
/**
|
* Utility functions around camera settings.
|
*/
|
public class SettingsUtil {
|
/**
|
* Returns the maximum video recording duration (in milliseconds).
|
*/
|
public static int getMaxVideoDuration(Context context) {
|
int duration = 0; // in milliseconds, 0 means unlimited.
|
try {
|
duration = context.getResources().getInteger(R.integer.max_video_recording_length);
|
} catch (Resources.NotFoundException ex) {
|
}
|
return duration;
|
}
|
|
/** The selected Camera sizes. */
|
public static class SelectedPictureSizes {
|
public Size large;
|
public Size medium;
|
public Size small;
|
|
/**
|
* This takes a string preference describing the desired resolution and
|
* returns the camera size it represents. <br/>
|
* It supports historical values of SIZE_LARGE, SIZE_MEDIUM, and
|
* SIZE_SMALL as well as resolutions separated by an x i.e. "1024x576" <br/>
|
* If it fails to parse the string, it will return the old SIZE_LARGE
|
* value.
|
*
|
* @param sizeSetting the preference string to convert to a size
|
* @param supportedSizes all possible camera sizes that are supported
|
* @return the size that this setting represents
|
*/
|
public Size getFromSetting(String sizeSetting, List<Size> supportedSizes) {
|
if (SIZE_LARGE.equals(sizeSetting)) {
|
return large;
|
} else if (SIZE_MEDIUM.equals(sizeSetting)) {
|
return medium;
|
} else if (SIZE_SMALL.equals(sizeSetting)) {
|
return small;
|
} else if (sizeSetting != null && sizeSetting.split("x").length == 2) {
|
Size desiredSize = sizeFromSettingString(sizeSetting);
|
if (supportedSizes.contains(desiredSize)) {
|
return desiredSize;
|
}
|
}
|
return large;
|
}
|
|
@Override
|
public String toString() {
|
return "SelectedPictureSizes: " + large + ", " + medium + ", " + small;
|
}
|
}
|
|
/** The selected {@link CamcorderProfile} qualities. */
|
public static class SelectedVideoQualities {
|
public int large = -1;
|
public int medium = -1;
|
public int small = -1;
|
|
public int getFromSetting(String sizeSetting) {
|
// Sanitize the value to be either small, medium or large. Default
|
// to the latter.
|
if (!SIZE_SMALL.equals(sizeSetting) && !SIZE_MEDIUM.equals(sizeSetting)) {
|
sizeSetting = SIZE_LARGE;
|
}
|
|
if (SIZE_LARGE.equals(sizeSetting)) {
|
return large;
|
} else if (SIZE_MEDIUM.equals(sizeSetting)) {
|
return medium;
|
} else {
|
return small;
|
}
|
}
|
}
|
|
private static final Log.Tag TAG = new Log.Tag("SettingsUtil");
|
|
/** Enable debug output. */
|
private static final boolean DEBUG = false;
|
|
private static final String SIZE_LARGE = "large";
|
private static final String SIZE_MEDIUM = "medium";
|
private static final String SIZE_SMALL = "small";
|
|
/** The ideal "medium" picture size is 50% of "large". */
|
private static final float MEDIUM_RELATIVE_PICTURE_SIZE = 0.5f;
|
|
/** The ideal "small" picture size is 25% of "large". */
|
private static final float SMALL_RELATIVE_PICTURE_SIZE = 0.25f;
|
|
/** Video qualities sorted by size. */
|
public static int[] sVideoQualities = new int[] {
|
CamcorderProfile.QUALITY_2160P,
|
CamcorderProfile.QUALITY_1080P,
|
CamcorderProfile.QUALITY_720P,
|
CamcorderProfile.QUALITY_480P,
|
CamcorderProfile.QUALITY_CIF,
|
CamcorderProfile.QUALITY_QVGA,
|
CamcorderProfile.QUALITY_QCIF
|
};
|
|
public static SparseArray<SelectedPictureSizes> sCachedSelectedPictureSizes =
|
new SparseArray<SelectedPictureSizes>(2);
|
public static SparseArray<SelectedVideoQualities> sCachedSelectedVideoQualities =
|
new SparseArray<SelectedVideoQualities>(2);
|
|
/**
|
* Based on the selected size, this method returns the matching concrete
|
* resolution.
|
*
|
* @param sizeSetting The setting selected by the user. One of "large",
|
* "medium, "small".
|
* @param supported The list of supported resolutions.
|
* @param cameraId This is used for caching the results for finding the
|
* different sizes.
|
*/
|
public static Size getPhotoSize(String sizeSetting, List<Size> supported, int cameraId) {
|
if (ResolutionUtil.NEXUS_5_LARGE_16_BY_9.equals(sizeSetting)) {
|
return ResolutionUtil.NEXUS_5_LARGE_16_BY_9_SIZE;
|
}
|
Size selectedSize = getCameraPictureSize(sizeSetting, supported, cameraId);
|
return selectedSize;
|
}
|
|
/**
|
* Based on the selected size (large, medium or small), and the list of
|
* supported resolutions, this method selects and returns the best matching
|
* picture size.
|
*
|
* @param sizeSetting The setting selected by the user. One of "large",
|
* "medium, "small".
|
* @param supported The list of supported resolutions.
|
* @param cameraId This is used for caching the results for finding the
|
* different sizes.
|
* @return The selected size.
|
*/
|
private static Size getCameraPictureSize(String sizeSetting, List<Size> supported,
|
int cameraId) {
|
return getSelectedCameraPictureSizes(supported, cameraId).getFromSetting(sizeSetting,
|
supported);
|
}
|
|
/**
|
* Based on the list of supported resolutions, this method selects the ones
|
* that shall be selected for being 'large', 'medium' and 'small'.
|
*
|
* @return It's guaranteed that all three sizes are filled. If less than
|
* three sizes are supported, the selected sizes might contain
|
* duplicates.
|
*/
|
static SelectedPictureSizes getSelectedCameraPictureSizes(List<Size> supported, int cameraId) {
|
List<Size> supportedCopy = new LinkedList<Size>(supported);
|
if (sCachedSelectedPictureSizes.get(cameraId) != null) {
|
return sCachedSelectedPictureSizes.get(cameraId);
|
}
|
if (supportedCopy == null) {
|
return null;
|
}
|
|
SelectedPictureSizes selectedSizes = new SelectedPictureSizes();
|
|
// Sort supported sizes by total pixel count, descending.
|
Collections.sort(supportedCopy, new Comparator<Size>() {
|
@Override
|
public int compare(Size lhs, Size rhs) {
|
int leftArea = lhs.width() * lhs.height();
|
int rightArea = rhs.width() * rhs.height();
|
return rightArea - leftArea;
|
}
|
});
|
if (DEBUG) {
|
Log.d(TAG, "Supported Sizes:");
|
for (Size size : supportedCopy) {
|
Log.d(TAG, " --> " + size.width() + "x" + size.height() + " "
|
+ ((size.width() * size.height()) / 1000000f) + " - "
|
+ (size.width() / (float) size.height()));
|
}
|
}
|
|
// Large size is always the size with the most pixels reported.
|
selectedSizes.large = supportedCopy.remove(0);
|
|
// If possible we want to find medium and small sizes with the same
|
// aspect ratio as 'large'.
|
final float targetAspectRatio = selectedSizes.large.width()
|
/ (float) selectedSizes.large.height();
|
|
// Create a list of sizes with the same aspect ratio as "large" which we
|
// will search in primarily.
|
ArrayList<Size> aspectRatioMatches = new ArrayList<Size>();
|
for (Size size : supportedCopy) {
|
float aspectRatio = size.width() / (float) size.height();
|
// Allow for small rounding errors in aspect ratio.
|
if (Math.abs(aspectRatio - targetAspectRatio) < 0.01) {
|
aspectRatioMatches.add(size);
|
}
|
}
|
|
// If we have at least two more resolutions that match the 'large'
|
// aspect ratio, use that list to find small and medium sizes. If not,
|
// use the full list with any aspect ratio.
|
final List<Size> searchList = (aspectRatioMatches.size() >= 2) ? aspectRatioMatches
|
: supportedCopy;
|
|
// Edge cases: If there are no further supported resolutions, use the
|
// only one we have.
|
// If there is only one remaining, use it for small and medium. If there
|
// are two, use the two for small and medium.
|
// These edge cases should never happen on a real device, but might
|
// happen on test devices and emulators.
|
if (searchList.isEmpty()) {
|
Log.w(TAG, "Only one supported resolution.");
|
selectedSizes.medium = selectedSizes.large;
|
selectedSizes.small = selectedSizes.large;
|
} else if (searchList.size() == 1) {
|
Log.w(TAG, "Only two supported resolutions.");
|
selectedSizes.medium = searchList.get(0);
|
selectedSizes.small = searchList.get(0);
|
} else if (searchList.size() == 2) {
|
Log.w(TAG, "Exactly three supported resolutions.");
|
selectedSizes.medium = searchList.get(0);
|
selectedSizes.small = searchList.get(1);
|
} else {
|
|
// Based on the large pixel count, determine the target pixel count
|
// for medium and small.
|
final int largePixelCount = selectedSizes.large.width() * selectedSizes.large.height();
|
final int mediumTargetPixelCount = (int) (largePixelCount * MEDIUM_RELATIVE_PICTURE_SIZE);
|
final int smallTargetPixelCount = (int) (largePixelCount * SMALL_RELATIVE_PICTURE_SIZE);
|
|
int mediumSizeIndex = findClosestSize(searchList, mediumTargetPixelCount);
|
int smallSizeIndex = findClosestSize(searchList, smallTargetPixelCount);
|
|
// If the selected sizes are the same, move the small size one down
|
// or
|
// the medium size one up.
|
if (searchList.get(mediumSizeIndex).equals(searchList.get(smallSizeIndex))) {
|
if (smallSizeIndex < (searchList.size() - 1)) {
|
smallSizeIndex += 1;
|
} else {
|
mediumSizeIndex -= 1;
|
}
|
}
|
selectedSizes.medium = searchList.get(mediumSizeIndex);
|
selectedSizes.small = searchList.get(smallSizeIndex);
|
}
|
sCachedSelectedPictureSizes.put(cameraId, selectedSizes);
|
return selectedSizes;
|
}
|
|
/**
|
* Determines the video quality for large/medium/small for the given camera.
|
* Returns the one matching the given setting. Defaults to 'large' of the
|
* qualitySetting does not match either large. medium or small.
|
*
|
* @param qualitySetting One of 'large', 'medium', 'small'.
|
* @param cameraId The ID of the camera for which to get the quality
|
* setting.
|
* @return The CamcorderProfile quality setting.
|
*/
|
public static int getVideoQuality(String qualitySetting, int cameraId) {
|
return getSelectedVideoQualities(cameraId).getFromSetting(qualitySetting);
|
}
|
|
static SelectedVideoQualities getSelectedVideoQualities(int cameraId) {
|
if (sCachedSelectedVideoQualities.get(cameraId) != null) {
|
return sCachedSelectedVideoQualities.get(cameraId);
|
}
|
|
// Go through the sizes in descending order, see if they are supported,
|
// and set large/medium/small accordingly.
|
// If no quality is supported at all, the first call to
|
// getNextSupportedQuality will throw an exception.
|
// If only one quality is supported, then all three selected qualities
|
// will be the same.
|
int largeIndex = getNextSupportedVideoQualityIndex(cameraId, -1);
|
int mediumIndex = getNextSupportedVideoQualityIndex(cameraId, largeIndex);
|
int smallIndex = getNextSupportedVideoQualityIndex(cameraId, mediumIndex);
|
|
SelectedVideoQualities selectedQualities = new SelectedVideoQualities();
|
selectedQualities.large = sVideoQualities[largeIndex];
|
selectedQualities.medium = sVideoQualities[mediumIndex];
|
selectedQualities.small = sVideoQualities[smallIndex];
|
sCachedSelectedVideoQualities.put(cameraId, selectedQualities);
|
return selectedQualities;
|
}
|
|
/**
|
* Starting from 'start' this method returns the next supported video
|
* quality.
|
*/
|
private static int getNextSupportedVideoQualityIndex(int cameraId, int start) {
|
for (int i = start + 1; i < sVideoQualities.length; ++i) {
|
if (isVideoQualitySupported(sVideoQualities[i])
|
&& CamcorderProfile.hasProfile(cameraId, sVideoQualities[i])) {
|
// We found a new supported quality.
|
return i;
|
}
|
}
|
|
// Failed to find another supported quality.
|
if (start < 0 || start >= sVideoQualities.length) {
|
// This means we couldn't find any supported quality.
|
throw new IllegalArgumentException("Could not find supported video qualities.");
|
}
|
|
// We previously found a larger supported size. In this edge case, just
|
// return the same index as the previous size.
|
return start;
|
}
|
|
/**
|
* @return Whether the given {@link CamcorderProfile} is supported on the
|
* current device/OS version.
|
*/
|
private static boolean isVideoQualitySupported(int videoQuality) {
|
// 4k is only supported on L or higher but some devices falsely report
|
// to have support for it on K, see b/18172081.
|
if (!ApiHelper.isLOrHigher() && videoQuality == CamcorderProfile.QUALITY_2160P) {
|
return false;
|
}
|
return true;
|
}
|
|
/**
|
* Returns the index of the size within the given list that is closest to
|
* the given target pixel count.
|
*/
|
private static int findClosestSize(List<Size> sortedSizes, int targetPixelCount) {
|
int closestMatchIndex = 0;
|
int closestMatchPixelCountDiff = Integer.MAX_VALUE;
|
|
for (int i = 0; i < sortedSizes.size(); ++i) {
|
Size size = sortedSizes.get(i);
|
int pixelCountDiff = Math.abs((size.width() * size.height()) - targetPixelCount);
|
if (pixelCountDiff < closestMatchPixelCountDiff) {
|
closestMatchIndex = i;
|
closestMatchPixelCountDiff = pixelCountDiff;
|
}
|
}
|
return closestMatchIndex;
|
}
|
|
private static final String SIZE_SETTING_STRING_DIMENSION_DELIMITER = "x";
|
|
/**
|
* This is used to serialize a size to a string for storage in settings
|
*
|
* @param size The size to serialize.
|
* @return the string to be saved in preferences
|
*/
|
public static String sizeToSettingString(Size size) {
|
return size.width() + SIZE_SETTING_STRING_DIMENSION_DELIMITER + size.height();
|
}
|
|
/**
|
* This parses a setting string and returns the representative size.
|
*
|
* @param sizeSettingString The string that stored in settings to represent a size.
|
* @return the represented Size.
|
*/
|
public static Size sizeFromSettingString(String sizeSettingString) {
|
if (sizeSettingString == null) {
|
return null;
|
}
|
String[] parts = sizeSettingString.split(SIZE_SETTING_STRING_DIMENSION_DELIMITER);
|
if (parts.length != 2) {
|
return null;
|
}
|
|
try {
|
int width = Integer.parseInt(parts[0]);
|
int height = Integer.parseInt(parts[1]);
|
return new Size(width, height);
|
} catch (NumberFormatException ex) {
|
return null;
|
}
|
}
|
|
/**
|
* Updates an AlertDialog.Builder to explain what it means to enable
|
* location on captures.
|
*/
|
public static AlertDialog.Builder getFirstTimeLocationAlertBuilder(
|
AlertDialog.Builder builder, Callback<Boolean> callback) {
|
if (callback == null) {
|
return null;
|
}
|
|
getLocationAlertBuilder(builder, callback)
|
.setMessage(R.string.remember_location_prompt);
|
|
return builder;
|
}
|
|
/**
|
* Updates an AlertDialog.Builder for choosing whether to include location
|
* on captures.
|
*/
|
public static AlertDialog.Builder getLocationAlertBuilder(AlertDialog.Builder builder,
|
final Callback<Boolean> callback) {
|
if (callback == null) {
|
return null;
|
}
|
|
builder.setTitle(R.string.remember_location_title)
|
.setPositiveButton(R.string.remember_location_yes,
|
new DialogInterface.OnClickListener() {
|
@Override
|
public void onClick(DialogInterface dialog, int arg1) {
|
callback.onCallback(true);
|
}
|
})
|
.setNegativeButton(R.string.remember_location_no,
|
new DialogInterface.OnClickListener() {
|
@Override
|
public void onClick(DialogInterface dialog, int arg1) {
|
callback.onCallback(false);
|
}
|
});
|
|
return builder;
|
}
|
|
/**
|
* Gets the first (lowest-indexed) camera matching the given criterion.
|
*
|
* @param facing Either {@link CAMERA_FACING_BACK}, {@link CAMERA_FACING_FRONT}, or some other
|
* implementation of {@link CameraDeviceSelector}.
|
* @return The ID of the first camera matching the supplied criterion, or
|
* -1, if no camera meeting the specification was found.
|
*/
|
public static int getCameraId(CameraDeviceInfo info, CameraDeviceSelector chooser) {
|
if (info == null) {
|
return -1;
|
}
|
int numCameras = info.getNumberOfCameras();
|
for (int i = 0; i < numCameras; ++i) {
|
CameraDeviceInfo.Characteristics props = info.getCharacteristics(i);
|
if (props == null) {
|
// Skip this device entry
|
continue;
|
}
|
if (chooser.useCamera(props)) {
|
return i;
|
}
|
}
|
return -1;
|
}
|
|
public static interface CameraDeviceSelector {
|
/**
|
* Given the static characteristics of a specific camera device, decide whether it is the
|
* one we will use.
|
*
|
* @param info The static characteristics of a device.
|
* @return Whether we're electing to use this particular device.
|
*/
|
public boolean useCamera(CameraDeviceInfo.Characteristics info);
|
}
|
|
public static final CameraDeviceSelector CAMERA_FACING_BACK = new CameraDeviceSelector() {
|
@Override
|
public boolean useCamera(CameraDeviceInfo.Characteristics info) {
|
return info.isFacingBack();
|
}};
|
|
public static final CameraDeviceSelector CAMERA_FACING_FRONT = new CameraDeviceSelector() {
|
@Override
|
public boolean useCamera(CameraDeviceInfo.Characteristics info) {
|
return info.isFacingFront();
|
}};
|
}
|
