Add support for new independent Lens Blur quality setting.

  Bug: 19424875

This CL and its sibling do two things:
- Bring back the Lens Blur setting
- Populate the setting with up to three native picture resolutions.
- If needed, choose the default as being the second highest resolution.
  (The list is not a full list, but filterd by what we show to the user).
- Make sure that after a new install a the default is set.
- Extra check in RefocusModule to make sure the default is set if old
  setting is not valid. This is important for upgrades.
- To make the size logic re-usable, I wrapped it into a PictureSizeLoader
  which also makes the CameraSettingsActivity a bit easier to read.

Change-Id: I53fcac8304f19be4f2c5ac053363f6805b933d89

9 files changed, 275 insertions, 88 deletions

diff --git a/src/com/android/camera/CameraActivity.java b/src/com/android/camera/CameraActivity.java
index b4159238d..4ebbad862 100644
--- a/src/com/android/camera/CameraActivity.java
+++ b/src/com/android/camera/CameraActivity.java
@@ -134,6 +134,7 @@ import com.android.camera.ui.ModeListView.ModeListVisibilityChangedListener;
 import com.android.camera.ui.PreviewStatusListener;
 import com.android.camera.util.ApiHelper;
 import com.android.camera.util.Callback;
+import com.android.camera.util.CameraSettingsActivityHelper;
 import com.android.camera.util.CameraUtil;
 import com.android.camera.util.GalleryHelper;
 import com.android.camera.util.GcamHelper;
@@ -1674,6 +1675,10 @@ public class CameraActivity extends QuickActivity
               new FirstRunDialog.FirstRunDialogListener() {
             @Override
             public void onFirstRunStateReady() {
+                // Make sure additional preferences have the correct resolution selected
+                CameraSettingsActivityHelper.verifyDefaults(getSettingsManager(),
+                        getAndroidContext());
+
                 // Run normal resume tasks.
                 resume();
             }
diff --git a/src/com/android/camera/settings/AppUpgrader.java b/src/com/android/camera/settings/AppUpgrader.java
index 730220f6a..92bd953d1 100644
--- a/src/com/android/camera/settings/AppUpgrader.java
+++ b/src/com/android/camera/settings/AppUpgrader.java
@@ -19,7 +19,6 @@ package com.android.camera.settings;
 import android.content.Context;
 import android.content.SharedPreferences;
 
-import com.android.camera.CameraActivity;
 import com.android.camera.app.AppController;
 import com.android.camera.app.ModuleManagerImpl;
 import com.android.camera.debug.Log;
diff --git a/src/com/android/camera/settings/CameraPictureSizesCacher.java b/src/com/android/camera/settings/CameraPictureSizesCacher.java
index 689cd9ce0..9cdca20bf 100644
--- a/src/com/android/camera/settings/CameraPictureSizesCacher.java
+++ b/src/com/android/camera/settings/CameraPictureSizesCacher.java
@@ -23,6 +23,7 @@ import android.os.Build;
 import android.preference.PreferenceManager;
 
 import com.android.camera.util.Size;
+import com.google.common.base.Optional;
 
 import java.util.List;
 
@@ -31,8 +32,8 @@ import java.util.List;
  * to query.  Will update cache if Build ID changes.
  */
 public class CameraPictureSizesCacher {
-    public static final String PICTURE_SIZES_BUILD_KEY = "CachedSupportedPictureSizes_Build_Camera";
-    public static final String PICTURE_SIZES_SIZES_KEY = "CachedSupportedPictureSizes_Sizes_Camera";
+    private static final String PICTURE_SIZES_BUILD_KEY = "CachedSupportedPictureSizes_Build_Camera";
+    private static final String PICTURE_SIZES_SIZES_KEY = "CachedSupportedPictureSizes_Sizes_Camera";
 
     /**
      * Opportunistically update the picture sizes cache, if needed.
@@ -62,20 +63,15 @@ public class CameraPictureSizesCacher {
      * cached.
      *
      * @param cameraId cameraID we would like sizes for.
+     * @param context valid android application context.
      * @return List of valid sizes, or null if the Camera can not be opened.
      */
     public static List<Size> getSizesForCamera(int cameraId, Context context) {
-        String key_build = PICTURE_SIZES_BUILD_KEY + cameraId;
-        String key_sizes = PICTURE_SIZES_SIZES_KEY + cameraId;
-        SharedPreferences defaultPrefs = PreferenceManager.getDefaultSharedPreferences(context);
-        // Return cached value for cameraId and current build, if available.
-        String thisCameraCachedBuild = defaultPrefs.getString(key_build, null);
-        if (thisCameraCachedBuild != null && thisCameraCachedBuild.equals(Build.DISPLAY)) {
-            String thisCameraCachedSizeList = defaultPrefs.getString(key_sizes, null);
-            if (thisCameraCachedSizeList != null) {
-                return Size.stringToList(thisCameraCachedSizeList);
-            }
+        Optional<List<Size>> cachedSizes = getCachedSizesForCamera(cameraId, context);
+        if (cachedSizes.isPresent()) {
+            return cachedSizes.get();
         }
+
         // No cached value, so need to query Camera API.
         Camera thisCamera;
         try {
@@ -85,6 +81,10 @@ public class CameraPictureSizesCacher {
             return null;
         }
         if (thisCamera != null) {
+            String key_build = PICTURE_SIZES_BUILD_KEY + cameraId;
+            String key_sizes = PICTURE_SIZES_SIZES_KEY + cameraId;
+            SharedPreferences defaultPrefs = PreferenceManager.getDefaultSharedPreferences(context);
+
             List<Size> sizes = Size.buildListFromCameraSizes(thisCamera.getParameters()
                     .getSupportedPictureSizes());
             thisCamera.release();
@@ -96,4 +96,28 @@ public class CameraPictureSizesCacher {
         }
         return null;
     }
+
+    /**
+     * Returns the cached sizes for the current camera. See
+     * {@link #getSizesForCamera} for details.
+     *
+     * @param cameraId cameraID we would like sizes for.
+     * @param context valid android application context.
+     * @return Optional ist of valid sizes. Not present if the sizes for the
+     *         given camera were not cached.
+     */
+    public static Optional<List<Size>> getCachedSizesForCamera(int cameraId, Context context) {
+        String key_build = PICTURE_SIZES_BUILD_KEY + cameraId;
+        String key_sizes = PICTURE_SIZES_SIZES_KEY + cameraId;
+        SharedPreferences defaultPrefs = PreferenceManager.getDefaultSharedPreferences(context);
+        // Return cached value for cameraId and current build, if available.
+        String thisCameraCachedBuild = defaultPrefs.getString(key_build, null);
+        if (thisCameraCachedBuild != null && thisCameraCachedBuild.equals(Build.DISPLAY)) {
+            String thisCameraCachedSizeList = defaultPrefs.getString(key_sizes, null);
+            if (thisCameraCachedSizeList != null) {
+                return Optional.of(Size.stringToList(thisCameraCachedSizeList));
+            }
+        }
+        return Optional.absent();
+    }
 }
diff --git a/src/com/android/camera/settings/CameraSettingsActivity.java b/src/com/android/camera/settings/CameraSettingsActivity.java
index fb15aef79..9925eb2f5 100644
--- a/src/com/android/camera/settings/CameraSettingsActivity.java
+++ b/src/com/android/camera/settings/CameraSettingsActivity.java
@@ -42,11 +42,10 @@ import com.android.camera.one.OneCameraCharacteristics;
 import com.android.camera.one.OneCameraException;
 import com.android.camera.one.OneCameraManager;
 import com.android.camera.one.OneCameraModule;
-import com.android.camera.settings.SettingsUtil.SelectedPictureSizes;
+import com.android.camera.settings.PictureSizeLoader.PictureSizes;
 import com.android.camera.settings.SettingsUtil.SelectedVideoQualities;
 import com.android.camera.util.CameraSettingsActivityHelper;
 import com.android.camera.util.GoogleHelpHelper;
-import com.android.camera.util.GservicesHelper;
 import com.android.camera.util.Size;
 import com.android.camera2.R;
 import com.android.ex.camera2.portability.CameraAgentFactory;
@@ -60,6 +59,7 @@ import java.util.List;
  * Provides the settings UI for the Camera app.
  */
 public class CameraSettingsActivity extends FragmentActivity {
+
     /**
      * Used to denote a subsection of the preference tree to display in the
      * Fragment. For instance, if 'Advanced' key is provided, the advanced
@@ -143,12 +143,7 @@ public class CameraSettingsActivity extends FragmentActivity {
         private boolean mGetSubPrefAsRoot = true;
 
         // Selected resolutions for the different cameras and sizes.
-        private SelectedPictureSizes mOldPictureSizesBack;
-        private SelectedPictureSizes mOldPictureSizesFront;
-        private List<Size> mPictureSizesBack;
-        private List<Size> mPictureSizesFront;
-        private SelectedVideoQualities mVideoQualitiesBack;
-        private SelectedVideoQualities mVideoQualitiesFront;
+        private PictureSizes mPictureSizes;
 
         @Override
         public void onCreate(Bundle savedInstanceState) {
@@ -189,6 +184,15 @@ public class CameraSettingsActivity extends FragmentActivity {
             // Load the camera sizes.
             loadSizes();
 
+            // Send loaded sizes to additional preferences.
+            CameraSettingsActivityHelper.onSizesLoaded(this, mPictureSizes.backCameraSizes,
+                    new ListPreferenceFiller() {
+                        @Override
+                        public void fill(List<Size> sizes, ListPreference preference) {
+                            setEntriesForSelection(sizes, preference);
+                        }
+                    });
+
             // Make sure to hide settings for cameras that don't exist on this
             // device.
             setVisibilities();
@@ -275,13 +279,13 @@ public class CameraSettingsActivity extends FragmentActivity {
         private void setVisibilities() {
             PreferenceGroup resolutions =
                     (PreferenceGroup) findPreference(PREF_CATEGORY_RESOLUTION);
-            if (mPictureSizesBack == null) {
+            if (mPictureSizes.backCameraSizes.isEmpty()) {
                 recursiveDelete(resolutions,
                         findPreference(Keys.KEY_PICTURE_SIZE_BACK));
                 recursiveDelete(resolutions,
                         findPreference(Keys.KEY_VIDEO_QUALITY_BACK));
             }
-            if (mPictureSizesFront == null) {
+            if (mPictureSizes.frontCameraSizes.isEmpty()) {
                 recursiveDelete(resolutions,
                         findPreference(Keys.KEY_PICTURE_SIZE_FRONT));
                 recursiveDelete(resolutions,
@@ -357,13 +361,13 @@ public class CameraSettingsActivity extends FragmentActivity {
 
             ListPreference listPreference = (ListPreference) preference;
             if (listPreference.getKey().equals(Keys.KEY_PICTURE_SIZE_BACK)) {
-                setEntriesForSelection(mPictureSizesBack, listPreference);
+                setEntriesForSelection(mPictureSizes.backCameraSizes, listPreference);
             } else if (listPreference.getKey().equals(Keys.KEY_PICTURE_SIZE_FRONT)) {
-                setEntriesForSelection(mPictureSizesFront, listPreference);
+                setEntriesForSelection(mPictureSizes.frontCameraSizes, listPreference);
             } else if (listPreference.getKey().equals(Keys.KEY_VIDEO_QUALITY_BACK)) {
-                setEntriesForSelection(mVideoQualitiesBack, listPreference);
+                setEntriesForSelection(mPictureSizes.videoQualitiesBack.orNull(), listPreference);
             } else if (listPreference.getKey().equals(Keys.KEY_VIDEO_QUALITY_FRONT)) {
-                setEntriesForSelection(mVideoQualitiesFront, listPreference);
+                setEntriesForSelection(mPictureSizes.videoQualitiesFront.orNull(), listPreference);
             }
         }
 
@@ -378,13 +382,15 @@ public class CameraSettingsActivity extends FragmentActivity {
 
             ListPreference listPreference = (ListPreference) preference;
             if (listPreference.getKey().equals(Keys.KEY_PICTURE_SIZE_BACK)) {
-                setSummaryForSelection(mOldPictureSizesBack, mPictureSizesBack, listPreference);
+                setSummaryForSelection(mPictureSizes.backCameraSizes,
+                        listPreference);
             } else if (listPreference.getKey().equals(Keys.KEY_PICTURE_SIZE_FRONT)) {
-                setSummaryForSelection(mOldPictureSizesFront, mPictureSizesFront, listPreference);
+                setSummaryForSelection(mPictureSizes.frontCameraSizes,
+                        listPreference);
             } else if (listPreference.getKey().equals(Keys.KEY_VIDEO_QUALITY_BACK)) {
-                setSummaryForSelection(mVideoQualitiesBack, listPreference);
+                setSummaryForSelection(mPictureSizes.videoQualitiesBack.orNull(), listPreference);
             } else if (listPreference.getKey().equals(Keys.KEY_VIDEO_QUALITY_FRONT)) {
-                setSummaryForSelection(mVideoQualitiesFront, listPreference);
+                setSummaryForSelection(mPictureSizes.videoQualitiesFront.orNull(), listPreference);
             } else {
                 listPreference.setSummary(listPreference.getEntry());
             }
@@ -443,21 +449,20 @@ public class CameraSettingsActivity extends FragmentActivity {
         /**
          * Sets the summary for the given list preference.
          *
-         * @param oldPictureSizes The old selected picture sizes for small
-         *            medium and large
          * @param displayableSizes The human readable preferred sizes
          * @param preference The preference for which to set the summary.
          */
-        private void setSummaryForSelection(SelectedPictureSizes oldPictureSizes,
-                List<Size> displayableSizes, ListPreference preference) {
-            if (oldPictureSizes == null) {
+        private void setSummaryForSelection(List<Size> displayableSizes,
+                                            ListPreference preference) {
+            String setting = preference.getValue();
+            if (setting == null || !setting.contains("x")) {
                 return;
             }
-
-            String setting = preference.getValue();
-            Size selectedSize = oldPictureSizes.getFromSetting(setting, displayableSizes);
-
-            preference.setSummary(getSizeSummaryString(selectedSize));
+            Size settingSize = SettingsUtil.sizeFromSettingString(setting);
+            if (settingSize == null) {
+                return;
+            }
+            preference.setSummary(getSizeSummaryString(settingSize));
         }
 
         /**
@@ -478,57 +483,15 @@ public class CameraSettingsActivity extends FragmentActivity {
 
         /**
          * This method gets the selected picture sizes for S,M,L and populates
-         * {@link #mPictureSizesBack}, {@link #mPictureSizesFront},
-         * {@link #mVideoQualitiesBack} and {@link #mVideoQualitiesFront}
-         * accordingly.
+         * {@link #mPictureSizes} accordingly.
          */
         private void loadSizes() {
             if (mInfos == null) {
                 Log.w(TAG, "null deviceInfo, cannot display resolution sizes");
                 return;
             }
-            // Back camera.
-            int backCameraId = SettingsUtil.getCameraId(mInfos, SettingsUtil.CAMERA_FACING_BACK);
-            if (backCameraId >= 0) {
-                List<Size> sizes = CameraPictureSizesCacher.getSizesForCamera(backCameraId,
-                        this.getActivity().getApplicationContext());
-                if (sizes != null) {
-                    mOldPictureSizesBack = SettingsUtil.getSelectedCameraPictureSizes(sizes,
-                            backCameraId);
-                    mPictureSizesBack = ResolutionUtil
-                            .getDisplayableSizesFromSupported(sizes, true);
-
-                    String blacklisted = GservicesHelper
-                            .getBlacklistedResolutionsBack(getActivity().getContentResolver());
-                    mPictureSizesBack = ResolutionUtil.filterBlackListedSizes(mPictureSizesBack,
-                            blacklisted);
-                }
-                mVideoQualitiesBack = SettingsUtil.getSelectedVideoQualities(backCameraId);
-            } else {
-                mPictureSizesBack = null;
-                mVideoQualitiesBack = null;
-            }
-
-            // Front camera.
-            int frontCameraId = SettingsUtil.getCameraId(mInfos, SettingsUtil.CAMERA_FACING_FRONT);
-            if (frontCameraId >= 0) {
-                List<Size> sizes = CameraPictureSizesCacher.getSizesForCamera(frontCameraId,
-                        this.getActivity().getApplicationContext());
-                if (sizes != null) {
-                    mOldPictureSizesFront = SettingsUtil.getSelectedCameraPictureSizes(sizes,
-                            frontCameraId);
-                    mPictureSizesFront =
-                            ResolutionUtil.getDisplayableSizesFromSupported(sizes, false);
-                    String blacklisted = GservicesHelper
-                            .getBlacklistedResolutionsFront(getActivity().getContentResolver());
-                    mPictureSizesFront = ResolutionUtil.filterBlackListedSizes(mPictureSizesFront,
-                            blacklisted);
-                }
-                mVideoQualitiesFront = SettingsUtil.getSelectedVideoQualities(frontCameraId);
-            } else {
-                mPictureSizesFront = null;
-                mVideoQualitiesFront = null;
-            }
+            PictureSizeLoader loader = new PictureSizeLoader(getActivity().getApplicationContext());
+            mPictureSizes = loader.computePictureSizes();
         }
 
         /**
diff --git a/src/com/android/camera/settings/ListPreferenceFiller.java b/src/com/android/camera/settings/ListPreferenceFiller.java
new file mode 100644
index 000000000..ee55891a3
--- /dev/null
+++ b/src/com/android/camera/settings/ListPreferenceFiller.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2015 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.preference.ListPreference;
+
+import com.android.camera.util.Size;
+
+import java.util.List;
+
+/**
+ * Classes implementing this interface can fill a list interface with content.
+ */
+public interface ListPreferenceFiller {
+    public void fill(List<Size> sizes, ListPreference preference);
+}
diff --git a/src/com/android/camera/settings/PictureSizeLoader.java b/src/com/android/camera/settings/PictureSizeLoader.java
new file mode 100644
index 000000000..a3cb49b70
--- /dev/null
+++ b/src/com/android/camera/settings/PictureSizeLoader.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2015 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.content.ContentResolver;
+import android.content.Context;
+
+import com.android.camera.settings.SettingsUtil.CameraDeviceSelector;
+import com.android.camera.settings.SettingsUtil.SelectedVideoQualities;
+import com.android.camera.util.GservicesHelper;
+import com.android.camera.util.Size;
+import com.android.ex.camera2.portability.CameraAgentFactory;
+import com.android.ex.camera2.portability.CameraDeviceInfo;
+import com.google.common.base.Optional;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.annotation.Nonnull;
+import javax.annotation.ParametersAreNonnullByDefault;
+
+/**
+ * Loads the camera picture sizes that can be set by the user.
+ * <p>
+ * This class is compatible with pre-Lollipop since it uses the compatibility
+ * layer to access the camera metadata.
+ */
+@ParametersAreNonnullByDefault
+public class PictureSizeLoader {
+    /**
+     * Holds the sizes for the back- and front cameras which will be available
+     * to the user for selection form settings.
+     */
+    @ParametersAreNonnullByDefault
+    public static class PictureSizes {
+        public final List<Size> backCameraSizes;
+        public final List<Size> frontCameraSizes;
+        public final Optional<SelectedVideoQualities> videoQualitiesBack;
+        public final Optional<SelectedVideoQualities> videoQualitiesFront;
+
+        PictureSizes(List<Size> backCameraSizes,
+                List<Size> frontCameraSizes,
+                Optional<SelectedVideoQualities> videoQualitiesBack,
+                Optional<SelectedVideoQualities> videoQualitiesFront) {
+            this.backCameraSizes = backCameraSizes;
+            this.frontCameraSizes = frontCameraSizes;
+            this.videoQualitiesBack = videoQualitiesBack;
+            this.videoQualitiesFront = videoQualitiesFront;
+        }
+    }
+
+    private final Context mContext;
+    private final ContentResolver mContentResolver;
+    private final CameraDeviceInfo mCameraDeviceInfo;
+    private final boolean mCachedOnly;
+
+    /**
+     * Initializes a new picture size loader.
+     * <p>
+     * This constructor will default to using the camera devices if the size
+     * values were not found in cache.
+     *
+     * @param context used to load caches sizes from preferences.
+     */
+    public PictureSizeLoader(Context context) {
+        this(context, false);
+    }
+
+    /**
+     * Initializes a new picture size loader.
+     *
+     * @param context used to load caches sizes from preferences.
+     * @param cachedOnly if set to true, this will only check the cache for
+     *            sizes. If the cache is empty, this will NOT attempt to open
+     *            the camera devices in order to obtain the sizes.
+     */
+    public PictureSizeLoader(Context context, boolean cachedOnly) {
+        mContext = context;
+        mContentResolver = context.getContentResolver();
+        mCameraDeviceInfo = CameraAgentFactory
+                .getAndroidCameraAgent(context, CameraAgentFactory.CameraApi.API_1)
+                .getCameraDeviceInfo();
+        mCachedOnly = cachedOnly;
+    }
+
+    /**
+     * Computes the list of picture sizes that should be displayed by settings.
+     * <p>
+     * For this it will open the camera devices to determine the available
+     * sizes, if the sizes are not already cached. This is to be compatible with
+     * devices running Camera API 1.
+     * <p>
+     * We then calculate the resolutions that should be available and in the end
+     * filter it in case a resolution is on the blacklist for this device.
+     */
+    public PictureSizes computePictureSizes() {
+        List<Size> backCameraSizes = computeSizesForCamera(SettingsUtil.CAMERA_FACING_BACK);
+        List<Size> frontCameraSizes = computeSizesForCamera(SettingsUtil.CAMERA_FACING_FRONT);
+        Optional<SelectedVideoQualities> videoQualitiesBack =
+                computeQualitiesForCamera(SettingsUtil.CAMERA_FACING_BACK);
+        Optional<SelectedVideoQualities> videoQualitiesFront =
+                computeQualitiesForCamera(SettingsUtil.CAMERA_FACING_FRONT);
+        return new PictureSizes(backCameraSizes, frontCameraSizes, videoQualitiesBack,
+                videoQualitiesFront);
+    }
+
+    private List<Size> computeSizesForCamera(CameraDeviceSelector facingSelector) {
+        List<Size> sizes;
+        int cameraId = SettingsUtil.getCameraId(mCameraDeviceInfo, facingSelector);
+        if (cameraId >= 0) {
+            if (mCachedOnly) {
+                sizes = CameraPictureSizesCacher.getCachedSizesForCamera(cameraId, mContext)
+                        .orNull();
+            } else {
+                sizes = CameraPictureSizesCacher.getSizesForCamera(cameraId, mContext);
+            }
+
+            if (sizes != null) {
+                sizes = ResolutionUtil
+                        .getDisplayableSizesFromSupported(sizes,
+                                facingSelector == SettingsUtil.CAMERA_FACING_BACK);
+                String blacklisted = GservicesHelper
+                        .getBlacklistedResolutionsBack(mContentResolver);
+                sizes = ResolutionUtil.filterBlackListedSizes(sizes, blacklisted);
+                return sizes;
+            }
+        }
+        return new ArrayList<>(0);
+    }
+
+    private Optional<SelectedVideoQualities> computeQualitiesForCamera(
+            CameraDeviceSelector facingSelector) {
+        int cameraId = SettingsUtil.getCameraId(mCameraDeviceInfo, facingSelector);
+        if (cameraId >= 0) {
+            // This is guaranteed not to be null/absent.
+            return Optional.of(SettingsUtil.getSelectedVideoQualities(cameraId));
+        }
+        return Optional.absent();
+    }
+}
diff --git a/src/com/android/camera/settings/SettingsUtil.java b/src/com/android/camera/settings/SettingsUtil.java
index 728e7a920..03ba37200 100644
--- a/src/com/android/camera/settings/SettingsUtil.java
+++ b/src/com/android/camera/settings/SettingsUtil.java
@@ -402,7 +402,7 @@ public class SettingsUtil {
      * @param sizeSettingString The string that stored in settings to represent a size.
      * @return the represented Size.
      */
-    static public Size sizeFromSettingString(String sizeSettingString) {
+    public static Size sizeFromSettingString(String sizeSettingString) {
         if (sizeSettingString == null) {
             return null;
         }
diff --git a/src/com/android/camera/util/Size.java b/src/com/android/camera/util/Size.java
index 820390448..59a2756dc 100644
--- a/src/com/android/camera/util/Size.java
+++ b/src/com/android/camera/util/Size.java
@@ -19,8 +19,8 @@ package com.android.camera.util;
 import android.annotation.TargetApi;
 import android.graphics.Point;
 import android.graphics.Rect;
-import android.os.Build.VERSION_CODES;
 import android.hardware.Camera;
+import android.os.Build.VERSION_CODES;
 import android.text.TextUtils;
 
 import com.google.common.base.Objects;
@@ -123,6 +123,11 @@ public class Size {
         return width * height;
     }
 
+    /** Returns width/height. */
+    public float aspectRatio() {
+        return (float) width / height;
+    }
+
     @Override
     public boolean equals(Object other) {
         if (!(other instanceof Size)) {
diff --git a/src_pd/com/android/camera/util/CameraSettingsActivityHelper.java b/src_pd/com/android/camera/util/CameraSettingsActivityHelper.java
index f7759a3fb..966539195 100644
--- a/src_pd/com/android/camera/util/CameraSettingsActivityHelper.java
+++ b/src_pd/com/android/camera/util/CameraSettingsActivityHelper.java
@@ -22,4 +22,11 @@ import android.preference.PreferenceFragment;
 public class CameraSettingsActivityHelper {
     public static void addAdditionalPreferences(PreferenceFragment fragment, Context context) {
     }
+
+    public static void onSizesLoaded(PreferenceFragment fragment,
+            List<Size> backCameraSizes, ListPreferenceFiller cameraSizesFiller) {
+    }
+
+    public static void verifyDefaults(SettingsManager settingsManager, Context context) {
+    }
 }