1 /*
2  * Copyright (C) 2014 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.camera.settings;
18 
19 import android.content.Context;
20 import android.content.SharedPreferences;
21 
22 import com.android.camera.app.AppController;
23 import com.android.camera.app.ModuleManagerImpl;
24 import com.android.camera.debug.Log;
25 import com.android.camera.util.ApiHelper;
26 import com.android.camera.util.Size;
27 import com.android.camera2.R;
28 import com.android.ex.camera2.portability.CameraAgentFactory;
29 import com.android.ex.camera2.portability.CameraDeviceInfo;
30 
31 import java.util.List;
32 import java.util.Map;
33 
34 /**
35  * Defines the general upgrade path for the app. Modules may define specific
36  * upgrade logic, but upgrading for preferences across modules, CameraActivity
37  * or application-wide can be added here.
38  */
39 public class AppUpgrader extends SettingsUpgrader {
40     private static final Log.Tag TAG = new Log.Tag("AppUpgrader");
41 
42     private static final String OLD_CAMERA_PREFERENCES_PREFIX = "_preferences_";
43     private static final String OLD_MODULE_PREFERENCES_PREFIX = "_preferences_module_";
44     private static final String OLD_GLOBAL_PREFERENCES_FILENAME = "_preferences_camera";
45     private static final String OLD_KEY_UPGRADE_VERSION = "pref_strict_upgrade_version";
46 
47     /**
48      * With this version everyone was forced to choose their location settings
49      * again.
50      */
51     private static final int FORCE_LOCATION_CHOICE_VERSION = 2;
52 
53     /**
54      * With this version, the camera size setting changed from a "small",
55      * "medium" and "default" to strings representing the actual resolutions,
56      * i.e. "1080x1776".
57      */
58     private static final int CAMERA_SIZE_SETTING_UPGRADE_VERSION = 3;
59 
60     /**
61      * With this version, the names of the files storing camera specific and
62      * module specific settings changed.
63      * <p>
64      * NOTE: changed this from 4 to 6 to re-run on latest Glacier upgrade.
65      * Initial upgraders to Glacier will run conversion once as of the change.
66      * When re-run for early dogfooders, values will get overwritten but will
67      * all work.
68      */
69     private static final int CAMERA_MODULE_SETTINGS_FILES_RENAMED_VERSION = 6;
70 
71     /**
72      * With this version, timelapse mode was removed and mode indices need to be
73      * resequenced.
74      */
75     private static final int CAMERA_SETTINGS_SELECTED_MODULE_INDEX = 5;
76 
77     /**
78      * With this version internal storage is changed to use only Strings, and
79      * a type conversion process should execute.
80      */
81     private static final int CAMERA_SETTINGS_STRINGS_UPGRADE = 5;
82 
83     /**
84      * With this version we needed to convert the artificial 16:9 high
85      * resolution size on the N5 since we stored it with a swapped width/height.
86      */
87     public static final int NEEDS_N5_16by9_RESOLUTION_SWAP = 7;
88     /**
89      * Increment this value whenever new AOSP UpgradeSteps need to be executed.
90      */
91     public static final int APP_UPGRADE_VERSION = 7;
92 
93     private final AppController mAppController;
94 
AppUpgrader(final AppController appController)95     public AppUpgrader(final AppController appController) {
96         super(Keys.KEY_UPGRADE_VERSION, APP_UPGRADE_VERSION);
97         mAppController = appController;
98     }
99 
100     @Override
getLastVersion(SettingsManager settingsManager)101     protected int getLastVersion(SettingsManager settingsManager) {
102         // Prior upgrade versions were stored in the default preferences as int
103         // and String. We create a new version location for migration to String.
104         // If we don't have a version persisted in the new location, check for
105         // the prior value from the old location. We expect the old value to be
106         // processed during {@link #upgradeTypesToStrings}.
107         SharedPreferences defaultPreferences = settingsManager.getDefaultPreferences();
108         if (defaultPreferences.contains(OLD_KEY_UPGRADE_VERSION)) {
109             Map<String, ?> allPrefs = defaultPreferences.getAll();
110             Object oldVersion = allPrefs.get(OLD_KEY_UPGRADE_VERSION);
111             defaultPreferences.edit().remove(OLD_KEY_UPGRADE_VERSION).apply();
112             if (oldVersion instanceof Integer) {
113                 return (Integer) oldVersion;
114             } else if (oldVersion instanceof String) {
115                 return SettingsManager.convertToInt((String) oldVersion);
116             }
117         }
118         return super.getLastVersion(settingsManager);
119     }
120 
121     @Override
upgrade(SettingsManager settingsManager, int lastVersion, int currentVersion)122     public void upgrade(SettingsManager settingsManager, int lastVersion, int currentVersion) {
123         Context context = mAppController.getAndroidContext();
124 
125         // Do strings upgrade first before 'earlier' upgrades, since they assume
126         // valid storage of values.
127         if (lastVersion < CAMERA_SETTINGS_STRINGS_UPGRADE) {
128             upgradeTypesToStrings(settingsManager);
129         }
130 
131         if (lastVersion < FORCE_LOCATION_CHOICE_VERSION) {
132             forceLocationChoice(settingsManager);
133         }
134 
135         if (lastVersion < CAMERA_SIZE_SETTING_UPGRADE_VERSION) {
136             CameraDeviceInfo infos = CameraAgentFactory
137                     .getAndroidCameraAgent(context, CameraAgentFactory.CameraApi.API_1)
138                     .getCameraDeviceInfo();
139             upgradeCameraSizeSetting(settingsManager, context, infos,
140                     SettingsUtil.CAMERA_FACING_FRONT);
141             upgradeCameraSizeSetting(settingsManager, context, infos,
142                     SettingsUtil.CAMERA_FACING_BACK);
143             // We changed size handling and aspect ratio placement, put user
144             // back into Camera mode this time to ensure they see the ratio
145             // chooser if applicable.
146             settingsManager.remove(SettingsManager.SCOPE_GLOBAL,
147                     Keys.KEY_STARTUP_MODULE_INDEX);
148         }
149 
150         if (lastVersion < CAMERA_MODULE_SETTINGS_FILES_RENAMED_VERSION) {
151             upgradeCameraSettingsFiles(settingsManager, context);
152             upgradeModuleSettingsFiles(settingsManager, context,
153                     mAppController);
154         }
155 
156         if (lastVersion < CAMERA_SETTINGS_SELECTED_MODULE_INDEX) {
157             upgradeSelectedModeIndex(settingsManager, context);
158         }
159 
160         if (lastVersion < NEEDS_N5_16by9_RESOLUTION_SWAP) {
161             updateN516by9ResolutionIfNeeded(settingsManager);
162         }
163     }
164 
165     /**
166      * Converts settings that were stored in SharedPreferences as non-Strings,
167      * to Strings. This is necessary due to a SettingsManager API refactoring.
168      * Should only be executed if we detected a change in
169      * Keys.KEY_UPGRADE_VERSION type from int to string; rerunning this on
170      * string values will result in ClassCastExceptions when trying to retrieve
171      * an int or boolean as a String.
172      */
upgradeTypesToStrings(SettingsManager settingsManager)173     private void upgradeTypesToStrings(SettingsManager settingsManager) {
174         SharedPreferences defaultPreferences = settingsManager.getDefaultPreferences();
175         SharedPreferences oldGlobalPreferences =
176                 settingsManager.openPreferences(OLD_GLOBAL_PREFERENCES_FILENAME);
177 
178         // Location: boolean -> String, from default.
179         if (defaultPreferences.contains(Keys.KEY_RECORD_LOCATION)) {
180             boolean location = removeBoolean(defaultPreferences, Keys.KEY_RECORD_LOCATION);
181             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_RECORD_LOCATION, location);
182         }
183 
184         // User selected aspect ratio: boolean -> String, from default.
185         if (defaultPreferences.contains(Keys.KEY_USER_SELECTED_ASPECT_RATIO)) {
186             boolean userSelectedAspectRatio = removeBoolean(defaultPreferences,
187                     Keys.KEY_USER_SELECTED_ASPECT_RATIO);
188             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_USER_SELECTED_ASPECT_RATIO,
189                     userSelectedAspectRatio);
190         }
191 
192         // Manual exposure compensation: boolean -> String, from default.
193         if (defaultPreferences.contains(Keys.KEY_EXPOSURE_COMPENSATION_ENABLED)) {
194             boolean manualExposureCompensationEnabled = removeBoolean(defaultPreferences,
195                     Keys.KEY_EXPOSURE_COMPENSATION_ENABLED);
196             settingsManager.set(SettingsManager.SCOPE_GLOBAL,
197                     Keys.KEY_EXPOSURE_COMPENSATION_ENABLED, manualExposureCompensationEnabled);
198         }
199 
200         // Hint: boolean -> String, from default.
201         if (defaultPreferences.contains(Keys.KEY_CAMERA_FIRST_USE_HINT_SHOWN)) {
202             boolean hint = removeBoolean(defaultPreferences, Keys.KEY_CAMERA_FIRST_USE_HINT_SHOWN);
203             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_FIRST_USE_HINT_SHOWN,
204                     hint);
205         }
206 
207         // Startup module index: Integer -> String, from default.
208         if (defaultPreferences.contains(Keys.KEY_STARTUP_MODULE_INDEX)) {
209             int startupModuleIndex = removeInteger(defaultPreferences,
210                     Keys.KEY_STARTUP_MODULE_INDEX);
211             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_STARTUP_MODULE_INDEX,
212                     startupModuleIndex);
213         }
214 
215         // Last camera used module index: Integer -> String, from default.
216         if (defaultPreferences.contains(Keys.KEY_CAMERA_MODULE_LAST_USED)) {
217             int lastCameraUsedModuleIndex = removeInteger(defaultPreferences,
218                     Keys.KEY_CAMERA_MODULE_LAST_USED);
219             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_MODULE_LAST_USED,
220                     lastCameraUsedModuleIndex);
221         }
222 
223         // Flash supported back camera setting: boolean -> String, from old
224         // global.
225         if (oldGlobalPreferences.contains(Keys.KEY_FLASH_SUPPORTED_BACK_CAMERA)) {
226             boolean flashSupportedBackCamera = removeBoolean(oldGlobalPreferences,
227                     Keys.KEY_FLASH_SUPPORTED_BACK_CAMERA);
228             if (flashSupportedBackCamera) {
229                 settingsManager.set(SettingsManager.SCOPE_GLOBAL,
230                         Keys.KEY_FLASH_SUPPORTED_BACK_CAMERA, flashSupportedBackCamera);
231             }
232         }
233 
234         // Should show refocus viewer cling: boolean -> String, from default.
235         if (defaultPreferences.contains(Keys.KEY_SHOULD_SHOW_REFOCUS_VIEWER_CLING)) {
236             boolean shouldShowRefocusViewer = removeBoolean(defaultPreferences,
237                     Keys.KEY_SHOULD_SHOW_REFOCUS_VIEWER_CLING);
238             settingsManager.set(SettingsManager.SCOPE_GLOBAL,
239                     Keys.KEY_SHOULD_SHOW_REFOCUS_VIEWER_CLING, shouldShowRefocusViewer);
240         }
241 
242         // Should show settings button cling: boolean -> String, from default.
243         if (defaultPreferences.contains(Keys.KEY_SHOULD_SHOW_SETTINGS_BUTTON_CLING)) {
244             boolean shouldShowSettingsButtonCling = removeBoolean(defaultPreferences,
245                     Keys.KEY_SHOULD_SHOW_SETTINGS_BUTTON_CLING);
246             settingsManager.set(SettingsManager.SCOPE_GLOBAL,
247                     Keys.KEY_SHOULD_SHOW_SETTINGS_BUTTON_CLING, shouldShowSettingsButtonCling);
248         }
249 
250         // HDR plus on setting: String on/off -> String, from old global.
251         if (oldGlobalPreferences.contains(Keys.KEY_CAMERA_HDR_PLUS)) {
252             String hdrPlus = removeString(oldGlobalPreferences, Keys.KEY_CAMERA_HDR_PLUS);
253             if (OLD_SETTINGS_VALUE_ON.equals(hdrPlus)) {
254                 settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_HDR_PLUS, true);
255             }
256         }
257 
258         // HDR on setting: String on/off -> String, from old global.
259         if (oldGlobalPreferences.contains(Keys.KEY_CAMERA_HDR)) {
260             String hdrPlus = removeString(oldGlobalPreferences, Keys.KEY_CAMERA_HDR);
261             if (OLD_SETTINGS_VALUE_ON.equals(hdrPlus)) {
262                 settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_HDR, true);
263             }
264         }
265 
266         // Grid on setting: String on/off -> String, from old global.
267         if (oldGlobalPreferences.contains(Keys.KEY_CAMERA_GRID_LINES)) {
268             String hdrPlus = removeString(oldGlobalPreferences, Keys.KEY_CAMERA_GRID_LINES);
269             if (OLD_SETTINGS_VALUE_ON.equals(hdrPlus)) {
270                 settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_GRID_LINES,
271                         true);
272             }
273         }
274     }
275 
276     /**
277      * Part of the AOSP upgrade path, forces the user to choose their location
278      * again if it was originally set to false.
279      */
forceLocationChoice(SettingsManager settingsManager)280     private void forceLocationChoice(SettingsManager settingsManager) {
281         SharedPreferences oldGlobalPreferences =
282                 settingsManager.openPreferences(OLD_GLOBAL_PREFERENCES_FILENAME);
283        // Show the location dialog on upgrade if
284         // (a) the user has never set this option (status quo).
285         // (b) the user opt'ed out previously.
286         if (settingsManager.isSet(SettingsManager.SCOPE_GLOBAL,
287                 Keys.KEY_RECORD_LOCATION)) {
288             // Location is set in the source file defined for this setting.
289             // Remove the setting if the value is false to launch the dialog.
290             if (!settingsManager.getBoolean(SettingsManager.SCOPE_GLOBAL,
291                     Keys.KEY_RECORD_LOCATION)) {
292                 settingsManager.remove(SettingsManager.SCOPE_GLOBAL, Keys.KEY_RECORD_LOCATION);
293             }
294         } else if (oldGlobalPreferences.contains(Keys.KEY_RECORD_LOCATION)) {
295             // Location is not set, check to see if we're upgrading from
296             // a different source file.
297             String location = removeString(oldGlobalPreferences, Keys.KEY_RECORD_LOCATION);
298             if (OLD_SETTINGS_VALUE_ON.equals(location)) {
299                     settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_RECORD_LOCATION,
300                             true);
301             }
302         }
303     }
304 
305     /**
306      * Part of the AOSP upgrade path, sets front and back picture sizes.
307      */
upgradeCameraSizeSetting(SettingsManager settingsManager, Context context, CameraDeviceInfo infos, SettingsUtil.CameraDeviceSelector facing)308     private void upgradeCameraSizeSetting(SettingsManager settingsManager,
309             Context context, CameraDeviceInfo infos,
310             SettingsUtil.CameraDeviceSelector facing) {
311         String key;
312         if (facing == SettingsUtil.CAMERA_FACING_FRONT) {
313             key = Keys.KEY_PICTURE_SIZE_FRONT;
314         } else if (facing == SettingsUtil.CAMERA_FACING_BACK) {
315             key = Keys.KEY_PICTURE_SIZE_BACK;
316         } else {
317             Log.w(TAG, "Ignoring attempt to upgrade size of unhandled camera facing direction");
318             return;
319         }
320 
321         // infos might be null if the underlying camera device is broken. In
322         // that case, just delete the old settings and force the user to
323         // reselect, it's the least evil solution given we want to only upgrade
324         // settings once.
325         if (infos == null) {
326             settingsManager.remove(SettingsManager.SCOPE_GLOBAL, key);
327             return;
328         }
329 
330         String pictureSize = settingsManager.getString(SettingsManager.SCOPE_GLOBAL, key);
331         int camera = SettingsUtil.getCameraId(infos, facing);
332         if (camera != -1) {
333             List<Size> supported = CameraPictureSizesCacher.getSizesForCamera(camera, context);
334             if (supported != null) {
335                 Size size = SettingsUtil.getPhotoSize(pictureSize, supported, camera);
336                 settingsManager.set(SettingsManager.SCOPE_GLOBAL, key,
337                         SettingsUtil.sizeToSettingString(size));
338             }
339         }
340     }
341 
342     /**
343      * Part of the AOSP upgrade path, copies all of the keys and values in a
344      * SharedPreferences file to another SharedPreferences file, as Strings.
345      * Settings that are not a known supported format (int/boolean/String)
346      * are dropped with warning.
347      *
348      * This will normally be run only once but was used both for upgrade version
349      * 4 and 6 -- in 6 we repair issues with previous runs of the upgrader. So
350      * we make sure to remove entries from destination if the source isn't valid
351      * like a null or unsupported type.
352      */
copyPreferences(SharedPreferences oldPrefs, SharedPreferences newPrefs)353     private void copyPreferences(SharedPreferences oldPrefs,
354             SharedPreferences newPrefs) {
355         Map<String, ?> entries = oldPrefs.getAll();
356         for (Map.Entry<String, ?> entry : entries.entrySet()) {
357             String key = entry.getKey();
358             Object value = entry.getValue();
359             if (value == null) {
360                 Log.w(TAG, "skipped upgrade and removing entry for null key " + key);
361                 newPrefs.edit().remove(key).apply();
362             } else if (value instanceof Boolean) {
363                 String boolValue = SettingsManager.convert((Boolean) value);
364                 newPrefs.edit().putString(key, boolValue).apply();
365             } else if (value instanceof Integer) {
366                 String intValue = SettingsManager.convert((Integer) value);
367                 newPrefs.edit().putString(key, intValue).apply();
368             } else if (value instanceof Long){
369                 // New SettingsManager only supports int values. Attempt to
370                 // recover any longs which happen to be present if they are
371                 // within int range.
372                 long longValue = (Long) value;
373                 if (longValue <= Integer.MAX_VALUE && longValue >= Integer.MIN_VALUE) {
374                     String intValue = SettingsManager.convert((int) longValue);
375                     newPrefs.edit().putString(key, intValue).apply();
376                 } else {
377                     Log.w(TAG, "skipped upgrade for out of bounds long key " +
378                             key + " : " + longValue);
379                 }
380             } else if (value instanceof String){
381                 newPrefs.edit().putString(key, (String) value).apply();
382             } else {
383                 Log.w(TAG,"skipped upgrade and removing entry for unrecognized "
384                         + "key type " + key + " : " + value.getClass());
385                 newPrefs.edit().remove(key).apply();
386             }
387         }
388     }
389 
390     /**
391      * Part of the AOSP upgrade path, copies all of the key and values in the
392      * old camera SharedPreferences files to new files.
393      */
upgradeCameraSettingsFiles(SettingsManager settingsManager, Context context)394     private void upgradeCameraSettingsFiles(SettingsManager settingsManager,
395             Context context) {
396         String[] cameraIds =
397                 context.getResources().getStringArray(R.array.camera_id_entryvalues);
398 
399         for (int i = 0; i < cameraIds.length; i++) {
400             SharedPreferences oldCameraPreferences =
401                     settingsManager.openPreferences(
402                             OLD_CAMERA_PREFERENCES_PREFIX + cameraIds[i]);
403             SharedPreferences newCameraPreferences =
404                     settingsManager.openPreferences(
405                             SettingsManager.getCameraSettingScope(cameraIds[i]));
406 
407             copyPreferences(oldCameraPreferences, newCameraPreferences);
408         }
409     }
410 
upgradeModuleSettingsFiles(SettingsManager settingsManager, Context context, AppController app)411     private void upgradeModuleSettingsFiles(SettingsManager settingsManager,
412             Context context, AppController app) {
413         int[] moduleIds = context.getResources().getIntArray(R.array.camera_modes);
414 
415         for (int i = 0; i < moduleIds.length; i++) {
416             String moduleId = Integer.toString(moduleIds[i]);
417             SharedPreferences oldModulePreferences =
418                     settingsManager.openPreferences(
419                             OLD_MODULE_PREFERENCES_PREFIX + moduleId);
420 
421             if (oldModulePreferences != null && oldModulePreferences.getAll().size() > 0) {
422                 ModuleManagerImpl.ModuleAgent agent =
423                         app.getModuleManager().getModuleAgent(moduleIds[i]);
424                 if (agent != null) {
425                     SharedPreferences newModulePreferences = settingsManager.openPreferences(
426                             SettingsManager.getModuleSettingScope(agent.getScopeNamespace()));
427 
428                     copyPreferences(oldModulePreferences, newModulePreferences);
429                 }
430             }
431         }
432     }
433 
434     /**
435      * The R.integer.camera_mode_* indices were cleaned up, resulting in
436      * removals and renaming of certain values. In particular camera_mode_gcam
437      * is now 5, not 6. We modify any persisted user settings that may refer to
438      * the old value.
439      */
upgradeSelectedModeIndex(SettingsManager settingsManager, Context context)440     private void upgradeSelectedModeIndex(SettingsManager settingsManager, Context context) {
441         int oldGcamIndex = 6; // from hardcoded previous mode index resource
442         int gcamIndex = context.getResources().getInteger(R.integer.camera_mode_gcam);
443 
444         int lastUsedCameraIndex = settingsManager.getInteger(SettingsManager.SCOPE_GLOBAL,
445                 Keys.KEY_CAMERA_MODULE_LAST_USED);
446         if (lastUsedCameraIndex == oldGcamIndex) {
447             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_CAMERA_MODULE_LAST_USED,
448                     gcamIndex);
449         }
450 
451         int startupModuleIndex = settingsManager.getInteger(SettingsManager.SCOPE_GLOBAL,
452                 Keys.KEY_STARTUP_MODULE_INDEX);
453         if (startupModuleIndex == oldGcamIndex) {
454             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_STARTUP_MODULE_INDEX,
455                     gcamIndex);
456         }
457     }
458 
459     /**
460      * A targeted fix for b/19693226.
461      * <p>
462      * Since the N5 doesn't natively support a high resolution 16:9 size we need
463      * to artificially add it and then crop the result from the high-resolution
464      * 4:3 size. In version 2.4 we unfortunately swapped the dimensions of
465      * ResolutionUtil#NEXUS_5_LARGE_16_BY_9_SIZE, which now causes a few issues
466      * in 2.5. If we detect this case, we will swap the dimensions here to make
467      * sure they are the right way around going forward.
468      */
updateN516by9ResolutionIfNeeded(SettingsManager settingsManager)469     private void updateN516by9ResolutionIfNeeded(SettingsManager settingsManager) {
470         if (!ApiHelper.IS_NEXUS_5) {
471             return;
472         }
473 
474         String pictureSize = settingsManager.getString(SettingsManager.SCOPE_GLOBAL,
475                 Keys.KEY_PICTURE_SIZE_BACK);
476         if ("1836x3264".equals(pictureSize)) {
477             Log.i(TAG, "Swapped dimensions on N5 16:9 resolution.");
478             settingsManager.set(SettingsManager.SCOPE_GLOBAL, Keys.KEY_PICTURE_SIZE_BACK,
479                     "3264x1836");
480         }
481     }
482 }
483