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