src/com/android/camera/settings/AppUpgrader.java - platform/packages/apps/Camera2 - Git at Google

 /*
  * 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.content.Context;
 import android.content.SharedPreferences;

 import com.android.camera.app.AppController;
 import com.android.camera.app.ModuleManagerImpl;
 import com.android.camera.debug.Log;
 import com.android.camera.util.ApiHelper;
 import com.android.camera.util.Size;
 import com.android.camera2.R;
 import com.android.ex.camera2.portability.CameraAgentFactory;
 import com.android.ex.camera2.portability.CameraDeviceInfo;

 import java.util.List;
 import java.util.Map;

 /**
  * Defines the general upgrade path for the app. Modules may define specific
  * upgrade logic, but upgrading for preferences across modules, CameraActivity
  * or application-wide can be added here.
  */
 public class AppUpgrader extends SettingsUpgrader {
     private static final Log.Tag TAG = new Log.Tag("AppUpgrader");

     private static final String OLD_CAMERA_PREFERENCES_PREFIX = "_preferences_";
     private static final String OLD_MODULE_PREFERENCES_PREFIX = "_preferences_module_";
     private static final String OLD_GLOBAL_PREFERENCES_FILENAME = "_preferences_camera";
     private static final String OLD_KEY_UPGRADE_VERSION = "pref_strict_upgrade_version";

     /**
      * With this version everyone was forced to choose their location settings
      * again.
      */
     private static final int FORCE_LOCATION_CHOICE_VERSION = 2;

     /**
      * With this version, the camera size setting changed from a "small",
      * "medium" and "default" to strings representing the actual resolutions,
      * i.e. "1080x1776".
      */
     private static final int CAMERA_SIZE_SETTING_UPGRADE_VERSION = 3;

     /**
      * With this version, the names of the files storing camera specific and
      * module specific settings changed.
      * <p>
      * NOTE: changed this from 4 to 6 to re-run on latest Glacier upgrade.
      * Initial upgraders to Glacier will run conversion once as of the change.
      * When re-run for early dogfooders, values will get overwritten but will
      * all work.
      */
     private static final int CAMERA_MODULE_SETTINGS_FILES_RENAMED_VERSION = 6;

     /**
      * With this version, timelapse mode was removed and mode indices need to be
      * resequenced.
      */
     private static final int CAMERA_SETTINGS_SELECTED_MODULE_INDEX = 5;

     /**
      * With this version internal storage is changed to use only Strings, and
      * a type conversion process should execute.
      */
     private static final int CAMERA_SETTINGS_STRINGS_UPGRADE = 5;

     /**
      * With this version we needed to convert the artificial 16:9 high
      * resolution size on the N5 since we stored it with a swapped width/height.
      */
     public static final int NEEDS_N5_16by9_RESOLUTION_SWAP = 7;
     /**
      * Increment this value whenever new AOSP UpgradeSteps need to be executed.
      */
     public static final int APP_UPGRADE_VERSION = 7;

     private final AppController mAppController;

     public AppUpgrader(final AppController appController) {
         super(Keys.KEY_UPGRADE_VERSION, APP_UPGRADE_VERSION);
         mAppController = appController;
     }

     @Override
     protected int getLastVersion(SettingsManager settingsManager) {
         // Prior upgrade versions were stored in the default preferences as int
         // and String. We create a new version location for migration to String.
         // If we don't have a version persisted in the new location, check for
         // the prior value from the old location. We expect the old value to be
         // processed during {@link #upgradeTypesToStrings}.
         SharedPreferences defaultPreferences = settingsManager.getDefaultPreferences();
         if (defaultPreferences.contains(OLD_KEY_UPGRADE_VERSION)) {
             Map<String, ?> allPrefs = defaultPreferences.getAll();
             Object oldVersion = allPrefs.get(OLD_KEY_UPGRADE_VERSION);
             defaultPreferences.edit().remove(OLD_KEY_UPGRADE_VERSION).apply();
             if (oldVersion instanceof Integer) {
                 return (Integer) oldVersion;
             } else if (oldVersion instanceof String) {
                 return SettingsManager.convertToInt((String) oldVersion);
             }
         }
         return super.getLastVersion(settingsManager);
     }

     @Override
     public void upgrade(SettingsManager settingsManager, int lastVersion, int currentVersion) {
         Context context = mAppController.getAndroidContext();

         // Do strings upgrade first before 'earlier' upgrades, since they assume
         // valid storage of values.
         if (lastVersion < CAMERA_SETTINGS_STRINGS_UPGRADE) {
             upgradeTypesToStrings(settingsManager);
         }

         if (lastVersion < FORCE_LOCATION_CHOICE_VERSION) {
             forceLocationChoice(settingsManager);
         }

         if (lastVersion < CAMERA_SIZE_SETTING_UPGRADE_VERSION) {
             CameraDeviceInfo infos = CameraAgentFactory
                     .getAndroidCameraAgent(context, CameraAgentFactory.CameraApi.API_1)
                     .getCameraDeviceInfo();
             upgradeCameraSizeSetting(settingsManager, context, infos,
                     SettingsUtil.CAMERA_FACING_FRONT);
             upgradeCameraSizeSetting(settingsManager, context, infos,
                     SettingsUtil.CAMERA_FACING_BACK);
             // We changed size handling and aspect ratio placement, put user
             // back into Camera mode this time to ensure they see the ratio
             // chooser if applicable.
             settingsManager.remove(SettingsManager.SCOPE_GLOBAL,
                     Keys.KEY_STARTUP_MODULE_INDEX);
             CameraAgentFactory.recycle(CameraAgentFactory.CameraApi.API_1);
         }

         if (lastVersion < CAMERA_MODULE_SETTINGS_FILES_RENAMED_VERSION) {
             upgradeCameraSettingsFiles(settingsManager, context);
             upgradeModuleSettingsFiles(settingsManager, context,
                     mAppController);
         }

         if (lastVersion < CAMERA_SETTINGS_SELECTED_MODULE_INDEX) {
             upgradeSelectedModeIndex(settingsManager, context);
         }

         if (lastVersion < NEEDS_N5_16by9_RESOLUTION_SWAP) {
             updateN516by9ResolutionIfNeeded(settingsManager);
         }
     }

     /**
      * Converts settings that were stored in SharedPreferences as non-Strings,
      * to Strings. This is necessary due to a SettingsManager API refactoring.
      * Should only be executed if we detected a change in
      * Keys.KEY_UPGRADE_VERSION type from int to string; rerunning this on
      * string values will result in ClassCastExceptions when trying to retrieve
      * an int or boolean as a String.
      */
     private void upgradeTypesToStrings(SettingsManager settingsManager) {
         SharedPreferences defaultPreferences = settingsManager.getDefaultPreferences();
         SharedPreferences oldGlobalPreferences =
                 settingsManager.openPreferences(OLD_GLOBAL_PREFERENCES_FILENAME);

         // Location: boolean -> String, from default.
         if (defaultPreferences.contains(Keys.KEY_RECORD_LOCATION)) {
             boolean location = removeBoolean(defaultPreferences, Keys.KEY_RECORD_LOCATION);
             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_RECORD_LOCATION, location);
         }

         // User selected aspect ratio: boolean -> String, from default.
         if (defaultPreferences.contains(Keys.KEY_USER_SELECTED_ASPECT_RATIO)) {
             boolean userSelectedAspectRatio = removeBoolean(defaultPreferences,
                     Keys.KEY_USER_SELECTED_ASPECT_RATIO);
             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_USER_SELECTED_ASPECT_RATIO,
                     userSelectedAspectRatio);
         }

         // Manual exposure compensation: boolean -> String, from default.
         if (defaultPreferences.contains(Keys.KEY_EXPOSURE_COMPENSATION_ENABLED)) {
             boolean manualExposureCompensationEnabled = removeBoolean(defaultPreferences,
                     Keys.KEY_EXPOSURE_COMPENSATION_ENABLED);
             settingsManager.set(SettingsManager.SCOPE_GLOBAL,
                     Keys.KEY_EXPOSURE_COMPENSATION_ENABLED, manualExposureCompensationEnabled);
         }

         // Hint: boolean -> String, from default.
         if (defaultPreferences.contains(Keys.KEY_CAMERA_FIRST_USE_HINT_SHOWN)) {
             boolean hint = removeBoolean(defaultPreferences, Keys.KEY_CAMERA_FIRST_USE_HINT_SHOWN);
             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_FIRST_USE_HINT_SHOWN,
                     hint);
         }

         // Startup module index: Integer -> String, from default.
         if (defaultPreferences.contains(Keys.KEY_STARTUP_MODULE_INDEX)) {
             int startupModuleIndex = removeInteger(defaultPreferences,
                     Keys.KEY_STARTUP_MODULE_INDEX);
             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_STARTUP_MODULE_INDEX,
                     startupModuleIndex);
         }

         // Last camera used module index: Integer -> String, from default.
         if (defaultPreferences.contains(Keys.KEY_CAMERA_MODULE_LAST_USED)) {
             int lastCameraUsedModuleIndex = removeInteger(defaultPreferences,
                     Keys.KEY_CAMERA_MODULE_LAST_USED);
             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_MODULE_LAST_USED,
                     lastCameraUsedModuleIndex);
         }

         // Flash supported back camera setting: boolean -> String, from old
         // global.
         if (oldGlobalPreferences.contains(Keys.KEY_FLASH_SUPPORTED_BACK_CAMERA)) {
             boolean flashSupportedBackCamera = removeBoolean(oldGlobalPreferences,
                     Keys.KEY_FLASH_SUPPORTED_BACK_CAMERA);
             if (flashSupportedBackCamera) {
                 settingsManager.set(SettingsManager.SCOPE_GLOBAL,
                         Keys.KEY_FLASH_SUPPORTED_BACK_CAMERA, flashSupportedBackCamera);
             }
         }

         // Should show refocus viewer cling: boolean -> String, from default.
         if (defaultPreferences.contains(Keys.KEY_SHOULD_SHOW_REFOCUS_VIEWER_CLING)) {
             boolean shouldShowRefocusViewer = removeBoolean(defaultPreferences,
                     Keys.KEY_SHOULD_SHOW_REFOCUS_VIEWER_CLING);
             settingsManager.set(SettingsManager.SCOPE_GLOBAL,
                     Keys.KEY_SHOULD_SHOW_REFOCUS_VIEWER_CLING, shouldShowRefocusViewer);
         }

         // Should show settings button cling: boolean -> String, from default.
         if (defaultPreferences.contains(Keys.KEY_SHOULD_SHOW_SETTINGS_BUTTON_CLING)) {
             boolean shouldShowSettingsButtonCling = removeBoolean(defaultPreferences,
                     Keys.KEY_SHOULD_SHOW_SETTINGS_BUTTON_CLING);
             settingsManager.set(SettingsManager.SCOPE_GLOBAL,
                     Keys.KEY_SHOULD_SHOW_SETTINGS_BUTTON_CLING, shouldShowSettingsButtonCling);
         }

         // HDR plus on setting: String on/off -> String, from old global.
         if (oldGlobalPreferences.contains(Keys.KEY_CAMERA_HDR_PLUS)) {
             String hdrPlus = removeString(oldGlobalPreferences, Keys.KEY_CAMERA_HDR_PLUS);
             if (OLD_SETTINGS_VALUE_ON.equals(hdrPlus)) {
                 settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_HDR_PLUS, true);
             }
         }

         // HDR on setting: String on/off -> String, from old global.
         if (oldGlobalPreferences.contains(Keys.KEY_CAMERA_HDR)) {
             String hdrPlus = removeString(oldGlobalPreferences, Keys.KEY_CAMERA_HDR);
             if (OLD_SETTINGS_VALUE_ON.equals(hdrPlus)) {
                 settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_HDR, true);
             }
         }

         // Grid on setting: String on/off -> String, from old global.
         if (oldGlobalPreferences.contains(Keys.KEY_CAMERA_GRID_LINES)) {
             String hdrPlus = removeString(oldGlobalPreferences, Keys.KEY_CAMERA_GRID_LINES);
             if (OLD_SETTINGS_VALUE_ON.equals(hdrPlus)) {
                 settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_GRID_LINES,
                         true);
             }
         }
     }

     /**
      * Part of the AOSP upgrade path, forces the user to choose their location
      * again if it was originally set to false.
      */
     private void forceLocationChoice(SettingsManager settingsManager) {
         SharedPreferences oldGlobalPreferences =
                 settingsManager.openPreferences(OLD_GLOBAL_PREFERENCES_FILENAME);
        // Show the location dialog on upgrade if
         // (a) the user has never set this option (status quo).
         // (b) the user opt'ed out previously.
         if (settingsManager.isSet(SettingsManager.SCOPE_GLOBAL,
                 Keys.KEY_RECORD_LOCATION)) {
             // Location is set in the source file defined for this setting.
             // Remove the setting if the value is false to launch the dialog.
             if (!settingsManager.getBoolean(SettingsManager.SCOPE_GLOBAL,
                     Keys.KEY_RECORD_LOCATION)) {
                 settingsManager.remove(SettingsManager.SCOPE_GLOBAL, Keys.KEY_RECORD_LOCATION);
             }
         } else if (oldGlobalPreferences.contains(Keys.KEY_RECORD_LOCATION)) {
             // Location is not set, check to see if we're upgrading from
             // a different source file.
             String location = removeString(oldGlobalPreferences, Keys.KEY_RECORD_LOCATION);
             if (OLD_SETTINGS_VALUE_ON.equals(location)) {
                     settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_RECORD_LOCATION,
                             true);
             }
         }
     }

     /**
      * Part of the AOSP upgrade path, sets front and back picture sizes.
      */
     private void upgradeCameraSizeSetting(SettingsManager settingsManager,
             Context context, CameraDeviceInfo infos,
             SettingsUtil.CameraDeviceSelector facing) {
         String key;
         if (facing == SettingsUtil.CAMERA_FACING_FRONT) {
             key = Keys.KEY_PICTURE_SIZE_FRONT;
         } else if (facing == SettingsUtil.CAMERA_FACING_BACK) {
             key = Keys.KEY_PICTURE_SIZE_BACK;
         } else {
             Log.w(TAG, "Ignoring attempt to upgrade size of unhandled camera facing direction");
             return;
         }

         // infos might be null if the underlying camera device is broken. In
         // that case, just delete the old settings and force the user to
         // reselect, it's the least evil solution given we want to only upgrade
         // settings once.
         if (infos == null) {
             settingsManager.remove(SettingsManager.SCOPE_GLOBAL, key);
             return;
         }

         String pictureSize = settingsManager.getString(SettingsManager.SCOPE_GLOBAL, key);
         int camera = SettingsUtil.getCameraId(infos, facing);
         if (camera != -1) {
             List<Size> supported = CameraPictureSizesCacher.getSizesForCamera(camera, context);
             if (supported != null) {
                 Size size = SettingsUtil.getPhotoSize(pictureSize, supported, camera);
                 settingsManager.set(SettingsManager.SCOPE_GLOBAL, key,
                         SettingsUtil.sizeToSettingString(size));
             }
         }
     }

     /**
      * Part of the AOSP upgrade path, copies all of the keys and values in a
      * SharedPreferences file to another SharedPreferences file, as Strings.
      * Settings that are not a known supported format (int/boolean/String)
      * are dropped with warning.
      *
      * This will normally be run only once but was used both for upgrade version
      * 4 and 6 -- in 6 we repair issues with previous runs of the upgrader. So
      * we make sure to remove entries from destination if the source isn't valid
      * like a null or unsupported type.
      */
     private void copyPreferences(SharedPreferences oldPrefs,
             SharedPreferences newPrefs) {
         Map<String, ?> entries = oldPrefs.getAll();
         for (Map.Entry<String, ?> entry : entries.entrySet()) {
             String key = entry.getKey();
             Object value = entry.getValue();
             if (value == null) {
                 Log.w(TAG, "skipped upgrade and removing entry for null key " + key);
                 newPrefs.edit().remove(key).apply();
             } else if (value instanceof Boolean) {
                 String boolValue = SettingsManager.convert((Boolean) value);
                 newPrefs.edit().putString(key, boolValue).apply();
             } else if (value instanceof Integer) {
                 String intValue = SettingsManager.convert((Integer) value);
                 newPrefs.edit().putString(key, intValue).apply();
             } else if (value instanceof Long){
                 // New SettingsManager only supports int values. Attempt to
                 // recover any longs which happen to be present if they are
                 // within int range.
                 long longValue = (Long) value;
                 if (longValue <= Integer.MAX_VALUE && longValue >= Integer.MIN_VALUE) {
                     String intValue = SettingsManager.convert((int) longValue);
                     newPrefs.edit().putString(key, intValue).apply();
                 } else {
                     Log.w(TAG, "skipped upgrade for out of bounds long key " +
                             key + " : " + longValue);
                 }
             } else if (value instanceof String){
                 newPrefs.edit().putString(key, (String) value).apply();
             } else {
                 Log.w(TAG,"skipped upgrade and removing entry for unrecognized "
                         + "key type " + key + " : " + value.getClass());
                 newPrefs.edit().remove(key).apply();
             }
         }
     }

     /**
      * Part of the AOSP upgrade path, copies all of the key and values in the
      * old camera SharedPreferences files to new files.
      */
     private void upgradeCameraSettingsFiles(SettingsManager settingsManager,
             Context context) {
         String[] cameraIds =
                 context.getResources().getStringArray(R.array.camera_id_entryvalues);

         for (int i = 0; i < cameraIds.length; i++) {
             SharedPreferences oldCameraPreferences =
                     settingsManager.openPreferences(
                             OLD_CAMERA_PREFERENCES_PREFIX + cameraIds[i]);
             SharedPreferences newCameraPreferences =
                     settingsManager.openPreferences(
                             SettingsManager.getCameraSettingScope(cameraIds[i]));

             copyPreferences(oldCameraPreferences, newCameraPreferences);
         }
     }

     private void upgradeModuleSettingsFiles(SettingsManager settingsManager,
             Context context, AppController app) {
         int[] moduleIds = context.getResources().getIntArray(R.array.camera_modes);

         for (int i = 0; i < moduleIds.length; i++) {
             String moduleId = Integer.toString(moduleIds[i]);
             SharedPreferences oldModulePreferences =
                     settingsManager.openPreferences(
                             OLD_MODULE_PREFERENCES_PREFIX + moduleId);

             if (oldModulePreferences != null && oldModulePreferences.getAll().size() > 0) {
                 ModuleManagerImpl.ModuleAgent agent =
                         app.getModuleManager().getModuleAgent(moduleIds[i]);
                 if (agent != null) {
                     SharedPreferences newModulePreferences = settingsManager.openPreferences(
                             SettingsManager.getModuleSettingScope(agent.getScopeNamespace()));

                     copyPreferences(oldModulePreferences, newModulePreferences);
                 }
             }
         }
     }

     /**
      * The R.integer.camera_mode_* indices were cleaned up, resulting in
      * removals and renaming of certain values. In particular camera_mode_gcam
      * is now 5, not 6. We modify any persisted user settings that may refer to
      * the old value.
      */
     private void upgradeSelectedModeIndex(SettingsManager settingsManager, Context context) {
         int oldGcamIndex = 6; // from hardcoded previous mode index resource
         int gcamIndex = context.getResources().getInteger(R.integer.camera_mode_gcam);

         int lastUsedCameraIndex = settingsManager.getInteger(SettingsManager.SCOPE_GLOBAL,
                 Keys.KEY_CAMERA_MODULE_LAST_USED);
         if (lastUsedCameraIndex == oldGcamIndex) {
             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_MODULE_LAST_USED,
                     gcamIndex);
         }

         int startupModuleIndex = settingsManager.getInteger(SettingsManager.SCOPE_GLOBAL,
                 Keys.KEY_STARTUP_MODULE_INDEX);
         if (startupModuleIndex == oldGcamIndex) {
             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_STARTUP_MODULE_INDEX,
                     gcamIndex);
         }
     }

     /**
      * A targeted fix for b/19693226.
      * <p>
      * Since the N5 doesn't natively support a high resolution 16:9 size we need
      * to artificially add it and then crop the result from the high-resolution
      * 4:3 size. In version 2.4 we unfortunately swapped the dimensions of
      * ResolutionUtil#NEXUS_5_LARGE_16_BY_9_SIZE, which now causes a few issues
      * in 2.5. If we detect this case, we will swap the dimensions here to make
      * sure they are the right way around going forward.
      */
     private void updateN516by9ResolutionIfNeeded(SettingsManager settingsManager) {
         if (!ApiHelper.IS_NEXUS_5) {
             return;
         }

         String pictureSize = settingsManager.getString(SettingsManager.SCOPE_GLOBAL,
                 Keys.KEY_PICTURE_SIZE_BACK);
         if ("1836x3264".equals(pictureSize)) {
             Log.i(TAG, "Swapped dimensions on N5 16:9 resolution.");
             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_PICTURE_SIZE_BACK,
                     "3264x1836");
         }
     }
 }
	/*
	* 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.content.Context;
	import android.content.SharedPreferences;

	import com.android.camera.app.AppController;
	import com.android.camera.app.ModuleManagerImpl;
	import com.android.camera.debug.Log;
	import com.android.camera.util.ApiHelper;
	import com.android.camera.util.Size;
	import com.android.camera2.R;
	import com.android.ex.camera2.portability.CameraAgentFactory;
	import com.android.ex.camera2.portability.CameraDeviceInfo;

	import java.util.List;
	import java.util.Map;

	/**
	* Defines the general upgrade path for the app. Modules may define specific
	* upgrade logic, but upgrading for preferences across modules, CameraActivity
	* or application-wide can be added here.
	*/
	public class AppUpgrader extends SettingsUpgrader {
	private static final Log.Tag TAG = new Log.Tag("AppUpgrader");

	private static final String OLD_CAMERA_PREFERENCES_PREFIX = "_preferences_";
	private static final String OLD_MODULE_PREFERENCES_PREFIX = "_preferences_module_";
	private static final String OLD_GLOBAL_PREFERENCES_FILENAME = "_preferences_camera";
	private static final String OLD_KEY_UPGRADE_VERSION = "pref_strict_upgrade_version";

	/**
	* With this version everyone was forced to choose their location settings
	* again.
	*/
	private static final int FORCE_LOCATION_CHOICE_VERSION = 2;

	/**
	* With this version, the camera size setting changed from a "small",
	* "medium" and "default" to strings representing the actual resolutions,
	* i.e. "1080x1776".
	*/
	private static final int CAMERA_SIZE_SETTING_UPGRADE_VERSION = 3;

	/**
	* With this version, the names of the files storing camera specific and
	* module specific settings changed.
	* <p>
	* NOTE: changed this from 4 to 6 to re-run on latest Glacier upgrade.
	* Initial upgraders to Glacier will run conversion once as of the change.
	* When re-run for early dogfooders, values will get overwritten but will
	* all work.
	*/
	private static final int CAMERA_MODULE_SETTINGS_FILES_RENAMED_VERSION = 6;

	/**
	* With this version, timelapse mode was removed and mode indices need to be
	* resequenced.
	*/
	private static final int CAMERA_SETTINGS_SELECTED_MODULE_INDEX = 5;

	/**
	* With this version internal storage is changed to use only Strings, and
	* a type conversion process should execute.
	*/
	private static final int CAMERA_SETTINGS_STRINGS_UPGRADE = 5;

	/**
	* With this version we needed to convert the artificial 16:9 high
	* resolution size on the N5 since we stored it with a swapped width/height.
	*/
	public static final int NEEDS_N5_16by9_RESOLUTION_SWAP = 7;
	/**
	* Increment this value whenever new AOSP UpgradeSteps need to be executed.
	*/
	public static final int APP_UPGRADE_VERSION = 7;

	private final AppController mAppController;

	public AppUpgrader(final AppController appController) {
	super(Keys.KEY_UPGRADE_VERSION, APP_UPGRADE_VERSION);
	mAppController = appController;
	}

	@Override
	protected int getLastVersion(SettingsManager settingsManager) {
	// Prior upgrade versions were stored in the default preferences as int
	// and String. We create a new version location for migration to String.
	// If we don't have a version persisted in the new location, check for
	// the prior value from the old location. We expect the old value to be
	// processed during {@link #upgradeTypesToStrings}.
	SharedPreferences defaultPreferences = settingsManager.getDefaultPreferences();
	if (defaultPreferences.contains(OLD_KEY_UPGRADE_VERSION)) {
	Map<String, ?> allPrefs = defaultPreferences.getAll();
	Object oldVersion = allPrefs.get(OLD_KEY_UPGRADE_VERSION);
	defaultPreferences.edit().remove(OLD_KEY_UPGRADE_VERSION).apply();
	if (oldVersion instanceof Integer) {
	return (Integer) oldVersion;
	} else if (oldVersion instanceof String) {
	return SettingsManager.convertToInt((String) oldVersion);
	}
	}
	return super.getLastVersion(settingsManager);
	}

	@Override
	public void upgrade(SettingsManager settingsManager, int lastVersion, int currentVersion) {
	Context context = mAppController.getAndroidContext();

	// Do strings upgrade first before 'earlier' upgrades, since they assume
	// valid storage of values.
	if (lastVersion < CAMERA_SETTINGS_STRINGS_UPGRADE) {
	upgradeTypesToStrings(settingsManager);
	}

	if (lastVersion < FORCE_LOCATION_CHOICE_VERSION) {
	forceLocationChoice(settingsManager);
	}

	if (lastVersion < CAMERA_SIZE_SETTING_UPGRADE_VERSION) {
	CameraDeviceInfo infos = CameraAgentFactory
	.getAndroidCameraAgent(context, CameraAgentFactory.CameraApi.API_1)
	.getCameraDeviceInfo();
	upgradeCameraSizeSetting(settingsManager, context, infos,
	SettingsUtil.CAMERA_FACING_FRONT);
	upgradeCameraSizeSetting(settingsManager, context, infos,
	SettingsUtil.CAMERA_FACING_BACK);
	// We changed size handling and aspect ratio placement, put user
	// back into Camera mode this time to ensure they see the ratio
	// chooser if applicable.
	settingsManager.remove(SettingsManager.SCOPE_GLOBAL,
	Keys.KEY_STARTUP_MODULE_INDEX);
	CameraAgentFactory.recycle(CameraAgentFactory.CameraApi.API_1);
	}

	if (lastVersion < CAMERA_MODULE_SETTINGS_FILES_RENAMED_VERSION) {
	upgradeCameraSettingsFiles(settingsManager, context);
	upgradeModuleSettingsFiles(settingsManager, context,
	mAppController);
	}

	if (lastVersion < CAMERA_SETTINGS_SELECTED_MODULE_INDEX) {
	upgradeSelectedModeIndex(settingsManager, context);
	}

	if (lastVersion < NEEDS_N5_16by9_RESOLUTION_SWAP) {
	updateN516by9ResolutionIfNeeded(settingsManager);
	}
	}

	/**
	* Converts settings that were stored in SharedPreferences as non-Strings,
	* to Strings. This is necessary due to a SettingsManager API refactoring.
	* Should only be executed if we detected a change in
	* Keys.KEY_UPGRADE_VERSION type from int to string; rerunning this on
	* string values will result in ClassCastExceptions when trying to retrieve
	* an int or boolean as a String.
	*/
	private void upgradeTypesToStrings(SettingsManager settingsManager) {
	SharedPreferences defaultPreferences = settingsManager.getDefaultPreferences();
	SharedPreferences oldGlobalPreferences =
	settingsManager.openPreferences(OLD_GLOBAL_PREFERENCES_FILENAME);

	// Location: boolean -> String, from default.
	if (defaultPreferences.contains(Keys.KEY_RECORD_LOCATION)) {
	boolean location = removeBoolean(defaultPreferences, Keys.KEY_RECORD_LOCATION);
	settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_RECORD_LOCATION, location);
	}

	// User selected aspect ratio: boolean -> String, from default.
	if (defaultPreferences.contains(Keys.KEY_USER_SELECTED_ASPECT_RATIO)) {
	boolean userSelectedAspectRatio = removeBoolean(defaultPreferences,
	Keys.KEY_USER_SELECTED_ASPECT_RATIO);
	settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_USER_SELECTED_ASPECT_RATIO,
	userSelectedAspectRatio);
	}

	// Manual exposure compensation: boolean -> String, from default.
	if (defaultPreferences.contains(Keys.KEY_EXPOSURE_COMPENSATION_ENABLED)) {
	boolean manualExposureCompensationEnabled = removeBoolean(defaultPreferences,
	Keys.KEY_EXPOSURE_COMPENSATION_ENABLED);
	settingsManager.set(SettingsManager.SCOPE_GLOBAL,
	Keys.KEY_EXPOSURE_COMPENSATION_ENABLED, manualExposureCompensationEnabled);
	}

	// Hint: boolean -> String, from default.
	if (defaultPreferences.contains(Keys.KEY_CAMERA_FIRST_USE_HINT_SHOWN)) {
	boolean hint = removeBoolean(defaultPreferences, Keys.KEY_CAMERA_FIRST_USE_HINT_SHOWN);
	settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_FIRST_USE_HINT_SHOWN,
	hint);
	}

	// Startup module index: Integer -> String, from default.
	if (defaultPreferences.contains(Keys.KEY_STARTUP_MODULE_INDEX)) {
	int startupModuleIndex = removeInteger(defaultPreferences,
	Keys.KEY_STARTUP_MODULE_INDEX);
	settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_STARTUP_MODULE_INDEX,
	startupModuleIndex);
	}

	// Last camera used module index: Integer -> String, from default.
	if (defaultPreferences.contains(Keys.KEY_CAMERA_MODULE_LAST_USED)) {
	int lastCameraUsedModuleIndex = removeInteger(defaultPreferences,
	Keys.KEY_CAMERA_MODULE_LAST_USED);
	settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_MODULE_LAST_USED,
	lastCameraUsedModuleIndex);
	}

	// Flash supported back camera setting: boolean -> String, from old
	// global.
	if (oldGlobalPreferences.contains(Keys.KEY_FLASH_SUPPORTED_BACK_CAMERA)) {
	boolean flashSupportedBackCamera = removeBoolean(oldGlobalPreferences,
	Keys.KEY_FLASH_SUPPORTED_BACK_CAMERA);
	if (flashSupportedBackCamera) {
	settingsManager.set(SettingsManager.SCOPE_GLOBAL,
	Keys.KEY_FLASH_SUPPORTED_BACK_CAMERA, flashSupportedBackCamera);
	}
	}

	// Should show refocus viewer cling: boolean -> String, from default.
	if (defaultPreferences.contains(Keys.KEY_SHOULD_SHOW_REFOCUS_VIEWER_CLING)) {
	boolean shouldShowRefocusViewer = removeBoolean(defaultPreferences,
	Keys.KEY_SHOULD_SHOW_REFOCUS_VIEWER_CLING);
	settingsManager.set(SettingsManager.SCOPE_GLOBAL,
	Keys.KEY_SHOULD_SHOW_REFOCUS_VIEWER_CLING, shouldShowRefocusViewer);
	}

	// Should show settings button cling: boolean -> String, from default.
	if (defaultPreferences.contains(Keys.KEY_SHOULD_SHOW_SETTINGS_BUTTON_CLING)) {
	boolean shouldShowSettingsButtonCling = removeBoolean(defaultPreferences,
	Keys.KEY_SHOULD_SHOW_SETTINGS_BUTTON_CLING);
	settingsManager.set(SettingsManager.SCOPE_GLOBAL,
	Keys.KEY_SHOULD_SHOW_SETTINGS_BUTTON_CLING, shouldShowSettingsButtonCling);
	}

	// HDR plus on setting: String on/off -> String, from old global.
	if (oldGlobalPreferences.contains(Keys.KEY_CAMERA_HDR_PLUS)) {
	String hdrPlus = removeString(oldGlobalPreferences, Keys.KEY_CAMERA_HDR_PLUS);
	if (OLD_SETTINGS_VALUE_ON.equals(hdrPlus)) {
	settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_HDR_PLUS, true);
	}
	}

	// HDR on setting: String on/off -> String, from old global.
	if (oldGlobalPreferences.contains(Keys.KEY_CAMERA_HDR)) {
	String hdrPlus = removeString(oldGlobalPreferences, Keys.KEY_CAMERA_HDR);
	if (OLD_SETTINGS_VALUE_ON.equals(hdrPlus)) {
	settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_HDR, true);
	}
	}

	// Grid on setting: String on/off -> String, from old global.
	if (oldGlobalPreferences.contains(Keys.KEY_CAMERA_GRID_LINES)) {
	String hdrPlus = removeString(oldGlobalPreferences, Keys.KEY_CAMERA_GRID_LINES);
	if (OLD_SETTINGS_VALUE_ON.equals(hdrPlus)) {
	settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_GRID_LINES,
	true);
	}
	}
	}

	/**
	* Part of the AOSP upgrade path, forces the user to choose their location
	* again if it was originally set to false.
	*/
	private void forceLocationChoice(SettingsManager settingsManager) {
	SharedPreferences oldGlobalPreferences =
	settingsManager.openPreferences(OLD_GLOBAL_PREFERENCES_FILENAME);
	// Show the location dialog on upgrade if
	// (a) the user has never set this option (status quo).
	// (b) the user opt'ed out previously.
	if (settingsManager.isSet(SettingsManager.SCOPE_GLOBAL,
	Keys.KEY_RECORD_LOCATION)) {
	// Location is set in the source file defined for this setting.
	// Remove the setting if the value is false to launch the dialog.
	if (!settingsManager.getBoolean(SettingsManager.SCOPE_GLOBAL,
	Keys.KEY_RECORD_LOCATION)) {
	settingsManager.remove(SettingsManager.SCOPE_GLOBAL, Keys.KEY_RECORD_LOCATION);
	}
	} else if (oldGlobalPreferences.contains(Keys.KEY_RECORD_LOCATION)) {
	// Location is not set, check to see if we're upgrading from
	// a different source file.
	String location = removeString(oldGlobalPreferences, Keys.KEY_RECORD_LOCATION);
	if (OLD_SETTINGS_VALUE_ON.equals(location)) {
	settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_RECORD_LOCATION,
	true);
	}
	}
	}

	/**
	* Part of the AOSP upgrade path, sets front and back picture sizes.
	*/
	private void upgradeCameraSizeSetting(SettingsManager settingsManager,
	Context context, CameraDeviceInfo infos,
	SettingsUtil.CameraDeviceSelector facing) {
	String key;
	if (facing == SettingsUtil.CAMERA_FACING_FRONT) {
	key = Keys.KEY_PICTURE_SIZE_FRONT;
	} else if (facing == SettingsUtil.CAMERA_FACING_BACK) {
	key = Keys.KEY_PICTURE_SIZE_BACK;
	} else {
	Log.w(TAG, "Ignoring attempt to upgrade size of unhandled camera facing direction");
	return;
	}

	// infos might be null if the underlying camera device is broken. In
	// that case, just delete the old settings and force the user to
	// reselect, it's the least evil solution given we want to only upgrade
	// settings once.
	if (infos == null) {
	settingsManager.remove(SettingsManager.SCOPE_GLOBAL, key);
	return;
	}

	String pictureSize = settingsManager.getString(SettingsManager.SCOPE_GLOBAL, key);
	int camera = SettingsUtil.getCameraId(infos, facing);
	if (camera != -1) {
	List<Size> supported = CameraPictureSizesCacher.getSizesForCamera(camera, context);
	if (supported != null) {
	Size size = SettingsUtil.getPhotoSize(pictureSize, supported, camera);
	settingsManager.set(SettingsManager.SCOPE_GLOBAL, key,
	SettingsUtil.sizeToSettingString(size));
	}
	}
	}

	/**
	* Part of the AOSP upgrade path, copies all of the keys and values in a
	* SharedPreferences file to another SharedPreferences file, as Strings.
	* Settings that are not a known supported format (int/boolean/String)
	* are dropped with warning.
	*
	* This will normally be run only once but was used both for upgrade version
	* 4 and 6 -- in 6 we repair issues with previous runs of the upgrader. So
	* we make sure to remove entries from destination if the source isn't valid
	* like a null or unsupported type.
	*/
	private void copyPreferences(SharedPreferences oldPrefs,
	SharedPreferences newPrefs) {
	Map<String, ?> entries = oldPrefs.getAll();
	for (Map.Entry<String, ?> entry : entries.entrySet()) {
	String key = entry.getKey();
	Object value = entry.getValue();
	if (value == null) {
	Log.w(TAG, "skipped upgrade and removing entry for null key " + key);
	newPrefs.edit().remove(key).apply();
	} else if (value instanceof Boolean) {
	String boolValue = SettingsManager.convert((Boolean) value);
	newPrefs.edit().putString(key, boolValue).apply();
	} else if (value instanceof Integer) {
	String intValue = SettingsManager.convert((Integer) value);
	newPrefs.edit().putString(key, intValue).apply();
	} else if (value instanceof Long){
	// New SettingsManager only supports int values. Attempt to
	// recover any longs which happen to be present if they are
	// within int range.
	long longValue = (Long) value;
	if (longValue <= Integer.MAX_VALUE && longValue >= Integer.MIN_VALUE) {
	String intValue = SettingsManager.convert((int) longValue);
	newPrefs.edit().putString(key, intValue).apply();
	} else {
	Log.w(TAG, "skipped upgrade for out of bounds long key " +
	key + " : " + longValue);
	}
	} else if (value instanceof String){
	newPrefs.edit().putString(key, (String) value).apply();
	} else {
	Log.w(TAG,"skipped upgrade and removing entry for unrecognized "
	+ "key type " + key + " : " + value.getClass());
	newPrefs.edit().remove(key).apply();
	}
	}
	}

	/**
	* Part of the AOSP upgrade path, copies all of the key and values in the
	* old camera SharedPreferences files to new files.
	*/
	private void upgradeCameraSettingsFiles(SettingsManager settingsManager,
	Context context) {
	String[] cameraIds =
	context.getResources().getStringArray(R.array.camera_id_entryvalues);

	for (int i = 0; i < cameraIds.length; i++) {
	SharedPreferences oldCameraPreferences =
	settingsManager.openPreferences(
	OLD_CAMERA_PREFERENCES_PREFIX + cameraIds[i]);
	SharedPreferences newCameraPreferences =
	settingsManager.openPreferences(
	SettingsManager.getCameraSettingScope(cameraIds[i]));

	copyPreferences(oldCameraPreferences, newCameraPreferences);
	}
	}

	private void upgradeModuleSettingsFiles(SettingsManager settingsManager,
	Context context, AppController app) {
	int[] moduleIds = context.getResources().getIntArray(R.array.camera_modes);

	for (int i = 0; i < moduleIds.length; i++) {
	String moduleId = Integer.toString(moduleIds[i]);
	SharedPreferences oldModulePreferences =
	settingsManager.openPreferences(
	OLD_MODULE_PREFERENCES_PREFIX + moduleId);

	if (oldModulePreferences != null && oldModulePreferences.getAll().size() > 0) {
	ModuleManagerImpl.ModuleAgent agent =
	app.getModuleManager().getModuleAgent(moduleIds[i]);
	if (agent != null) {
	SharedPreferences newModulePreferences = settingsManager.openPreferences(
	SettingsManager.getModuleSettingScope(agent.getScopeNamespace()));

	copyPreferences(oldModulePreferences, newModulePreferences);
	}
	}
	}
	}

	/**
	* The R.integer.camera_mode_* indices were cleaned up, resulting in
	* removals and renaming of certain values. In particular camera_mode_gcam
	* is now 5, not 6. We modify any persisted user settings that may refer to
	* the old value.
	*/
	private void upgradeSelectedModeIndex(SettingsManager settingsManager, Context context) {
	int oldGcamIndex = 6; // from hardcoded previous mode index resource
	int gcamIndex = context.getResources().getInteger(R.integer.camera_mode_gcam);

	int lastUsedCameraIndex = settingsManager.getInteger(SettingsManager.SCOPE_GLOBAL,
	Keys.KEY_CAMERA_MODULE_LAST_USED);
	if (lastUsedCameraIndex == oldGcamIndex) {
	settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_MODULE_LAST_USED,
	gcamIndex);
	}

	int startupModuleIndex = settingsManager.getInteger(SettingsManager.SCOPE_GLOBAL,
	Keys.KEY_STARTUP_MODULE_INDEX);
	if (startupModuleIndex == oldGcamIndex) {
	settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_STARTUP_MODULE_INDEX,
	gcamIndex);
	}
	}

	/**
	* A targeted fix for b/19693226.
	* <p>
	* Since the N5 doesn't natively support a high resolution 16:9 size we need
	* to artificially add it and then crop the result from the high-resolution
	* 4:3 size. In version 2.4 we unfortunately swapped the dimensions of
	* ResolutionUtil#NEXUS_5_LARGE_16_BY_9_SIZE, which now causes a few issues
	* in 2.5. If we detect this case, we will swap the dimensions here to make
	* sure they are the right way around going forward.
	*/
	private void updateN516by9ResolutionIfNeeded(SettingsManager settingsManager) {
	if (!ApiHelper.IS_NEXUS_5) {
	return;
	}

	String pictureSize = settingsManager.getString(SettingsManager.SCOPE_GLOBAL,
	Keys.KEY_PICTURE_SIZE_BACK);
	if ("1836x3264".equals(pictureSize)) {
	Log.i(TAG, "Swapped dimensions on N5 16:9 resolution.");
	settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_PICTURE_SIZE_BACK,
	"3264x1836");
	}
	}
	}