Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2013 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 | |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 19 | import android.content.Context; |
| 20 | import android.content.SharedPreferences; |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 21 | import android.content.SharedPreferences.OnSharedPreferenceChangeListener; |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 22 | import android.preference.PreferenceManager; |
Erin Dahlgren | d186f22 | 2014-01-10 11:24:31 -0800 | [diff] [blame] | 23 | import android.util.SparseArray; |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 24 | |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 25 | import com.android.camera.ListPreference; |
Erin Dahlgren | d186f22 | 2014-01-10 11:24:31 -0800 | [diff] [blame] | 26 | import com.android.camera.app.AppController; |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 27 | import com.android.camera.app.LocationManager; |
Angus Kong | 2bca210 | 2014-03-11 16:27:30 -0700 | [diff] [blame^] | 28 | import com.android.camera.debug.Log; |
Erin Dahlgren | 1ba90e3 | 2014-03-03 12:05:57 -0800 | [diff] [blame] | 29 | import com.android.camera.util.CameraUtil; |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 30 | import com.android.camera.util.SettingsHelper; |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 31 | import com.android.camera2.R; |
| 32 | |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 33 | import java.util.ArrayList; |
Sascha Haeberling | 3b0ab89 | 2014-01-29 20:54:39 +0100 | [diff] [blame] | 34 | import java.util.List; |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 35 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 36 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 37 | * SettingsManager class provides an api for getting and setting both global and |
| 38 | * local SharedPreferences. |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 39 | */ |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 40 | public class SettingsManager { |
Angus Kong | 2bca210 | 2014-03-11 16:27:30 -0700 | [diff] [blame^] | 41 | private static final Log.Tag TAG = new Log.Tag("SettingsManager"); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 42 | |
Sascha Haeberling | a63dbb6 | 2013-11-22 11:55:32 -0800 | [diff] [blame] | 43 | private final Context mContext; |
| 44 | private final SharedPreferences mDefaultSettings; |
| 45 | private final SettingsCache mSettingsCache; |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 46 | private SharedPreferences mGlobalSettings; |
| 47 | private SharedPreferences mCameraSettings; |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 48 | private final SparseArray<SharedPreferences> mModuleSettings = new SparseArray<SharedPreferences>(); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 49 | private SettingsCapabilities mCapabilities; |
| 50 | |
| 51 | private int mCameraId = -1; |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 52 | private final AppController mAppController; |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 53 | |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 54 | /** |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 55 | * General settings upgrade model: |
| 56 | * |
| 57 | * On app upgrade, there are three main ways Settings can be stale/incorrect: |
| 58 | * (1) if the type of a setting has changed. |
| 59 | * (2) if a set value is no longer a member of the set of possible values. |
| 60 | * (3) if the SharedPreferences backing file has changed for a setting. |
| 61 | * |
| 62 | * Recovery strategies: |
| 63 | * (1) catch the ClassCastException or NumberFormatException and try to do a |
| 64 | * type conversion, or reset the setting to whatever default is valid. |
| 65 | * (2) sanitize sets, and reset to default if set value is no longer valid. |
| 66 | * (3) use the default value by virtue of the setting not yet being in the |
| 67 | * new file. |
| 68 | * |
| 69 | * Special cases: |
| 70 | * |
| 71 | * There are some settings which shouldn't be reset to default on upgrade if |
| 72 | * possible. We provide a callback which is executed only on strict upgrade. |
| 73 | * This callback does special case upgrades to a subset of the settings. This |
| 74 | * contrasts with the general upgrade strategies, which happen lazily, once a |
| 75 | * setting is used. |
| 76 | * |
| 77 | * Removing obsolete key/value pairs: |
| 78 | * |
| 79 | * This can be done in the strict upgrade callback. The strict upgrade callback |
| 80 | * should be idempotent, so it is important to leave removal code in the upgrade |
| 81 | * callback so the key/value pairs are removed even if a user skips a version. |
| 82 | */ |
| 83 | public interface StrictUpgradeCallback { |
| 84 | /** |
| 85 | * Will be executed in the SettingsManager constructor if the strict |
| 86 | * upgrade version counter has changed. |
| 87 | */ |
| 88 | public void upgrade(SettingsManager settingsManager, int version); |
| 89 | } |
| 90 | |
| 91 | /** |
| 92 | * Increment this value whenever a new StrictUpgradeCallback needs to |
| 93 | * be executed. This defines upgrade behavior that should be executed |
| 94 | * strictly on app upgrades, when the upgrade behavior differs from the general, |
| 95 | * lazy upgrade strategies. |
| 96 | */ |
Erin Dahlgren | bd245b2 | 2014-03-18 09:48:51 -0700 | [diff] [blame] | 97 | private static final int STRICT_UPGRADE_VERSION = 2; |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 98 | |
| 99 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 100 | * A List of OnSettingChangedListener's, maintained to compare to new |
| 101 | * listeners and prevent duplicate registering. |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 102 | */ |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 103 | private final List<OnSettingChangedListener> mListeners = new ArrayList<OnSettingChangedListener>(); |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 104 | |
| 105 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 106 | * A List of OnSharedPreferenceChangeListener's, maintained to hold pointers |
| 107 | * to actually registered listeners, so they can be unregistered. |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 108 | */ |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 109 | private final List<OnSharedPreferenceChangeListener> mSharedPreferenceListeners = new ArrayList<OnSharedPreferenceChangeListener>(); |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 110 | |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 111 | public SettingsManager(Context context, AppController app, int nCameras, |
| 112 | StrictUpgradeCallback upgradeCallback) { |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 113 | mContext = context; |
Erin Dahlgren | d186f22 | 2014-01-10 11:24:31 -0800 | [diff] [blame] | 114 | mAppController = app; |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 115 | |
| 116 | SettingsCache.ExtraSettings extraSettings = new SettingsHelper(); |
| 117 | mSettingsCache = new SettingsCache(mContext, extraSettings); |
| 118 | |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 119 | mDefaultSettings = PreferenceManager.getDefaultSharedPreferences(context); |
Erin Dahlgren | 7f0151d | 2014-01-02 16:08:12 -0800 | [diff] [blame] | 120 | initGlobal(); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 121 | |
| 122 | if (upgradeCallback != null) { |
| 123 | // Check for a strict version upgrade. |
| 124 | int version = getInt(SETTING_STRICT_UPGRADE_VERSION); |
| 125 | if (STRICT_UPGRADE_VERSION != version) { |
| 126 | upgradeCallback.upgrade(this, STRICT_UPGRADE_VERSION); |
| 127 | } |
| 128 | setInt(SETTING_STRICT_UPGRADE_VERSION, STRICT_UPGRADE_VERSION); |
| 129 | } |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 130 | } |
| 131 | |
| 132 | /** |
| 133 | * Initialize global SharedPreferences. |
| 134 | */ |
Erin Dahlgren | 7f0151d | 2014-01-02 16:08:12 -0800 | [diff] [blame] | 135 | private void initGlobal() { |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 136 | String globalKey = mContext.getPackageName() + "_preferences_camera"; |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 137 | mGlobalSettings = mContext.getSharedPreferences(globalKey, Context.MODE_PRIVATE); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 138 | } |
| 139 | |
| 140 | /** |
Erin Dahlgren | d186f22 | 2014-01-10 11:24:31 -0800 | [diff] [blame] | 141 | * Load and cache a module specific SharedPreferences. |
| 142 | */ |
| 143 | public SharedPreferences getModulePreferences(int modeIndex) { |
| 144 | SharedPreferences sharedPreferences = mModuleSettings.get(modeIndex); |
| 145 | if (sharedPreferences == null) { |
| 146 | String moduleKey = mContext.getPackageName() + "_preferences_module_" + modeIndex; |
| 147 | sharedPreferences = mContext.getSharedPreferences(moduleKey, Context.MODE_PRIVATE); |
| 148 | mModuleSettings.put(modeIndex, sharedPreferences); |
| 149 | } |
| 150 | return sharedPreferences; |
| 151 | } |
| 152 | |
| 153 | /** |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 154 | * Initialize SharedPreferences for other cameras. |
| 155 | */ |
| 156 | public void changeCamera(int cameraId, SettingsCapabilities capabilities) { |
| 157 | mCapabilities = capabilities; |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 158 | mSettingsCache.setCapabilities(mCapabilities); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 159 | |
| 160 | if (cameraId == mCameraId) { |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 161 | return; |
| 162 | } |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 163 | |
| 164 | // We've changed camera ids, that means we need to flush the |
| 165 | // settings cache of settings dependent on SettingsCapabilities. |
| 166 | mSettingsCache.flush(); |
| 167 | |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 168 | // Cache the camera id so we don't need to reload preferences |
| 169 | // if we're using the same camera. |
| 170 | mCameraId = cameraId; |
| 171 | |
| 172 | String cameraKey = mContext.getPackageName() + "_preferences_" + cameraId; |
| 173 | mCameraSettings = mContext.getSharedPreferences( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 174 | cameraKey, Context.MODE_PRIVATE); |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 175 | |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 176 | for (OnSharedPreferenceChangeListener listener : mSharedPreferenceListeners) { |
| 177 | mCameraSettings.registerOnSharedPreferenceChangeListener(listener); |
| 178 | } |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 179 | } |
| 180 | |
| 181 | /** |
| 182 | * Interface with Camera Parameters and Modules. |
| 183 | */ |
Erin Dahlgren | 7f0151d | 2014-01-02 16:08:12 -0800 | [diff] [blame] | 184 | public interface OnSettingChangedListener { |
| 185 | /** |
| 186 | * Called every time a SharedPreference has been changed. |
| 187 | */ |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 188 | public void onSettingChanged(SettingsManager settingsManager, int setting); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 189 | } |
| 190 | |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 191 | private OnSharedPreferenceChangeListener getSharedPreferenceListener( |
| 192 | final OnSettingChangedListener listener) { |
| 193 | return new OnSharedPreferenceChangeListener() { |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 194 | @Override |
| 195 | public void onSharedPreferenceChanged( |
| 196 | SharedPreferences sharedPreferences, String key) { |
| 197 | Integer settingId = mSettingsCache.getId(key); |
| 198 | if (settingId != null) { |
| 199 | listener.onSettingChanged(SettingsManager.this, settingId); |
| 200 | } else { |
| 201 | Log.w(TAG, "Setting id from key=" + key + " is null"); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 202 | } |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 203 | } |
| 204 | }; |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 205 | } |
Erin Dahlgren | 7f0151d | 2014-01-02 16:08:12 -0800 | [diff] [blame] | 206 | |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 207 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 208 | * Add an OnSettingChangedListener to the SettingsManager, which will |
| 209 | * execute onSettingsChanged when any SharedPreference has been updated. |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 210 | */ |
| 211 | public void addListener(final OnSettingChangedListener listener) { |
| 212 | if (listener == null) { |
| 213 | throw new IllegalArgumentException("OnSettingChangedListener cannot be null."); |
Erin Dahlgren | 7f0151d | 2014-01-02 16:08:12 -0800 | [diff] [blame] | 214 | } |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 215 | |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 216 | if (mListeners.contains(listener)) { |
| 217 | return; |
| 218 | } |
| 219 | |
| 220 | mListeners.add(listener); |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 221 | OnSharedPreferenceChangeListener sharedPreferenceListener = |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 222 | getSharedPreferenceListener(listener); |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 223 | mSharedPreferenceListeners.add(sharedPreferenceListener); |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 224 | |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 225 | if (mGlobalSettings != null) { |
| 226 | mGlobalSettings.registerOnSharedPreferenceChangeListener(sharedPreferenceListener); |
| 227 | } |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 228 | |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 229 | if (mCameraSettings != null) { |
| 230 | mCameraSettings.registerOnSharedPreferenceChangeListener(sharedPreferenceListener); |
| 231 | } |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 232 | |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 233 | if (mDefaultSettings != null) { |
| 234 | mDefaultSettings.registerOnSharedPreferenceChangeListener(sharedPreferenceListener); |
Erin Dahlgren | 7f0151d | 2014-01-02 16:08:12 -0800 | [diff] [blame] | 235 | } |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 236 | } |
| 237 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 238 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 239 | * Remove a specific SettingsListener. This should be done in onPause if a |
| 240 | * listener has been set. |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 241 | */ |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 242 | public void removeListener(OnSettingChangedListener listener) { |
| 243 | if (listener == null) { |
| 244 | throw new IllegalArgumentException(); |
| 245 | } |
| 246 | |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 247 | if (!mListeners.contains(listener)) { |
| 248 | return; |
| 249 | } |
| 250 | |
| 251 | int index = mListeners.indexOf(listener); |
| 252 | mListeners.remove(listener); |
| 253 | |
| 254 | // Get the reference to the actual OnSharedPreferenceChangeListener |
| 255 | // that was registered. |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 256 | OnSharedPreferenceChangeListener sharedPreferenceListener = |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 257 | mSharedPreferenceListeners.get(index); |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 258 | mSharedPreferenceListeners.remove(index); |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 259 | |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 260 | if (mGlobalSettings != null) { |
| 261 | mGlobalSettings.unregisterOnSharedPreferenceChangeListener( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 262 | sharedPreferenceListener); |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 263 | } |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 264 | |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 265 | if (mCameraSettings != null) { |
| 266 | mCameraSettings.unregisterOnSharedPreferenceChangeListener( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 267 | sharedPreferenceListener); |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 268 | } |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 269 | |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 270 | if (mDefaultSettings != null) { |
| 271 | mDefaultSettings.unregisterOnSharedPreferenceChangeListener( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 272 | sharedPreferenceListener); |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 273 | } |
| 274 | } |
| 275 | |
| 276 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 277 | * Remove all OnSharedPreferenceChangedListener's. This should be done in |
| 278 | * onDestroy. |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 279 | */ |
| 280 | public void removeAllListeners() { |
| 281 | for (OnSharedPreferenceChangeListener listener : mSharedPreferenceListeners) { |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 282 | if (mGlobalSettings != null) { |
| 283 | mGlobalSettings.unregisterOnSharedPreferenceChangeListener(listener); |
| 284 | } |
| 285 | |
| 286 | if (mCameraSettings != null) { |
| 287 | mCameraSettings.unregisterOnSharedPreferenceChangeListener(listener); |
| 288 | } |
| 289 | |
| 290 | if (mDefaultSettings != null) { |
| 291 | mDefaultSettings.unregisterOnSharedPreferenceChangeListener(listener); |
| 292 | } |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 293 | } |
Erin Dahlgren | 8da3452 | 2014-01-07 10:12:15 -0800 | [diff] [blame] | 294 | mSharedPreferenceListeners.clear(); |
Erin Dahlgren | 1841b11 | 2014-01-29 15:44:57 -0800 | [diff] [blame] | 295 | mListeners.clear(); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 296 | } |
| 297 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 298 | /** |
| 299 | * SettingsCapabilities defines constraints around settings that need to be |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 300 | * queried from external sources, like the camera parameters. This interface |
| 301 | * is camera api agnostic. |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 302 | */ |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 303 | public interface SettingsCapabilities { |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 304 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 305 | * Returns a dynamically calculated list of exposure values, based on |
| 306 | * the min and max exposure compensation supported by the camera device. |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 307 | */ |
| 308 | public String[] getSupportedExposureValues(); |
| 309 | |
| 310 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 311 | * Returns a list of camera ids based on the number of cameras available |
| 312 | * on the device. |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 313 | */ |
| 314 | public String[] getSupportedCameraIds(); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 315 | } |
| 316 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 317 | /** |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 318 | * Get the camera id for which the SettingsManager has loaded camera |
| 319 | * specific preferences. |
| 320 | */ |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 321 | public int getRegisteredCameraId() { |
| 322 | return mCameraId; |
| 323 | } |
| 324 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 325 | // Manage individual settings. |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 326 | public static final String VALUE_NONE = "none"; |
| 327 | public static final String VALUE_ON = "on"; |
| 328 | public static final String VALUE_OFF = "off"; |
| 329 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 330 | public static final String TYPE_STRING = "string"; |
| 331 | public static final String TYPE_BOOLEAN = "boolean"; |
| 332 | public static final String TYPE_INTEGER = "integer"; |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 333 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 334 | public static final String SOURCE_DEFAULT = "default"; |
| 335 | public static final String SOURCE_GLOBAL = "global"; |
| 336 | public static final String SOURCE_CAMERA = "camera"; |
Erin Dahlgren | d186f22 | 2014-01-10 11:24:31 -0800 | [diff] [blame] | 337 | public static final String SOURCE_MODULE = "module"; |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 338 | |
| 339 | public static final boolean FLUSH_ON = true; |
| 340 | public static final boolean FLUSH_OFF = false; |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 341 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 342 | // For quick lookup from id to Setting. |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 343 | public static final int SETTING_RECORD_LOCATION = 0; |
Sascha Haeberling | 6ccec20 | 2014-03-11 09:44:34 -0700 | [diff] [blame] | 344 | public static final int SETTING_VIDEO_QUALITY_BACK = 1; |
| 345 | public static final int SETTING_VIDEO_QUALITY_FRONT = 2; |
| 346 | public static final int SETTING_VIDEO_TIME_LAPSE_FRAME_INTERVAL = 3; |
| 347 | public static final int SETTING_PICTURE_SIZE_BACK = 4; |
| 348 | public static final int SETTING_PICTURE_SIZE_FRONT = 5; |
| 349 | public static final int SETTING_JPEG_QUALITY = 6; |
| 350 | public static final int SETTING_FOCUS_MODE = 7; |
| 351 | public static final int SETTING_FLASH_MODE = 8; |
| 352 | public static final int SETTING_VIDEOCAMERA_FLASH_MODE = 9; |
| 353 | public static final int SETTING_WHITE_BALANCE = 10; |
| 354 | public static final int SETTING_SCENE_MODE = 11; |
| 355 | public static final int SETTING_EXPOSURE = 12; |
| 356 | public static final int SETTING_TIMER = 13; |
| 357 | public static final int SETTING_TIMER_SOUND_EFFECTS = 14; |
| 358 | public static final int SETTING_VIDEO_EFFECT = 15; |
| 359 | public static final int SETTING_CAMERA_ID = 16; |
| 360 | public static final int SETTING_CAMERA_HDR = 17; |
| 361 | public static final int SETTING_CAMERA_HDR_PLUS = 18; |
| 362 | public static final int SETTING_CAMERA_FIRST_USE_HINT_SHOWN = 19; |
| 363 | public static final int SETTING_VIDEO_FIRST_USE_HINT_SHOWN = 20; |
| 364 | public static final int SETTING_STARTUP_MODULE_INDEX = 21; |
Sascha Haeberling | 6ccec20 | 2014-03-11 09:44:34 -0700 | [diff] [blame] | 365 | public static final int SETTING_KEY_CAMERA_MODULE_LAST_USED_INDEX = 23; |
| 366 | public static final int SETTING_CAMERA_PANO_ORIENTATION = 24; |
| 367 | public static final int SETTING_CAMERA_GRID_LINES = 25; |
| 368 | public static final int SETTING_RELEASE_DIALOG_LAST_SHOWN_VERSION = 26; |
| 369 | public static final int SETTING_FLASH_SUPPORTED_BACK_CAMERA = 27; |
| 370 | public static final int SETTING_STRICT_UPGRADE_VERSION = 28; |
Erin Dahlgren | 1ba90e3 | 2014-03-03 12:05:57 -0800 | [diff] [blame] | 371 | // A boolean for requesting to return to HDR plus |
| 372 | // as soon as possible, if a user requests a setting/mode option |
| 373 | // that forces them to leave HDR plus. |
Sascha Haeberling | 6ccec20 | 2014-03-11 09:44:34 -0700 | [diff] [blame] | 374 | public static final int SETTING_REQUEST_RETURN_HDR_PLUS = 30; |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 375 | |
| 376 | // Shared preference keys. |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 377 | public static final String KEY_RECORD_LOCATION = "pref_camera_recordlocation_key"; |
Sascha Haeberling | 6ccec20 | 2014-03-11 09:44:34 -0700 | [diff] [blame] | 378 | public static final String KEY_VIDEO_QUALITY_BACK = "pref_video_quality_back_key"; |
| 379 | public static final String KEY_VIDEO_QUALITY_FRONT = "pref_video_quality_front_key"; |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 380 | public static final String KEY_VIDEO_TIME_LAPSE_FRAME_INTERVAL = |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 381 | "pref_video_time_lapse_frame_interval_key"; |
Sascha Haeberling | 6ccec20 | 2014-03-11 09:44:34 -0700 | [diff] [blame] | 382 | public static final String KEY_PICTURE_SIZE_BACK = "pref_camera_picturesize_back_key"; |
| 383 | public static final String KEY_PICTURE_SIZE_FRONT = "pref_camera_picturesize_front_key"; |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 384 | public static final String KEY_JPEG_QUALITY = "pref_camera_jpegquality_key"; |
| 385 | public static final String KEY_FOCUS_MODE = "pref_camera_focusmode_key"; |
| 386 | public static final String KEY_FLASH_MODE = "pref_camera_flashmode_key"; |
| 387 | public static final String KEY_VIDEOCAMERA_FLASH_MODE = "pref_camera_video_flashmode_key"; |
| 388 | public static final String KEY_WHITE_BALANCE = "pref_camera_whitebalance_key"; |
| 389 | public static final String KEY_SCENE_MODE = "pref_camera_scenemode_key"; |
| 390 | public static final String KEY_EXPOSURE = "pref_camera_exposure_key"; |
| 391 | public static final String KEY_TIMER = "pref_camera_timer_key"; |
| 392 | public static final String KEY_TIMER_SOUND_EFFECTS = "pref_camera_timer_sound_key"; |
| 393 | public static final String KEY_VIDEO_EFFECT = "pref_video_effect_key"; |
| 394 | public static final String KEY_CAMERA_ID = "pref_camera_id_key"; |
| 395 | public static final String KEY_CAMERA_HDR = "pref_camera_hdr_key"; |
| 396 | public static final String KEY_CAMERA_HDR_PLUS = "pref_camera_hdr_plus_key"; |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 397 | public static final String KEY_CAMERA_FIRST_USE_HINT_SHOWN = |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 398 | "pref_camera_first_use_hint_shown_key"; |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 399 | public static final String KEY_VIDEO_FIRST_USE_HINT_SHOWN = |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 400 | "pref_video_first_use_hint_shown_key"; |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 401 | public static final String KEY_STARTUP_MODULE_INDEX = "camera.startup_module"; |
Doris Liu | cf8b653 | 2014-01-15 19:17:38 -0800 | [diff] [blame] | 402 | public static final String KEY_CAMERA_MODULE_LAST_USED = |
| 403 | "pref_camera_module_last_used_index"; |
Erin Dahlgren | a1fab41 | 2014-01-21 09:31:11 -0800 | [diff] [blame] | 404 | public static final String KEY_CAMERA_PANO_ORIENTATION = "pref_camera_pano_orientation"; |
Erin Dahlgren | d5e5146 | 2014-02-07 12:38:57 -0800 | [diff] [blame] | 405 | public static final String KEY_CAMERA_GRID_LINES = "pref_camera_grid_lines"; |
Sascha Haeberling | c26a328 | 2014-02-19 08:39:28 -0800 | [diff] [blame] | 406 | public static final String KEY_RELEASE_DIALOG_LAST_SHOWN_VERSION = |
| 407 | "pref_release_dialog_last_shown_version"; |
Erin Dahlgren | e346fb2 | 2014-02-19 17:23:01 -0800 | [diff] [blame] | 408 | public static final String KEY_FLASH_SUPPORTED_BACK_CAMERA = |
| 409 | "pref_flash_supported_back_camera"; |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 410 | public static final String KEY_STRICT_UPGRADE_VERSION = "pref_strict_upgrade_version"; |
Erin Dahlgren | 1ba90e3 | 2014-03-03 12:05:57 -0800 | [diff] [blame] | 411 | public static final String KEY_REQUEST_RETURN_HDR_PLUS = "pref_request_return_hdr_plus"; |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 412 | |
| 413 | public static final int WHITE_BALANCE_DEFAULT_INDEX = 2; |
| 414 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 415 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 416 | * Defines a simple class for holding a the spec of a setting. This spec is |
| 417 | * used by the generic api methods to query and update a setting. |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 418 | */ |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 419 | public static class Setting { |
| 420 | private final String mSource; |
| 421 | private final String mType; |
| 422 | private final String mDefault; |
| 423 | private final String mKey; |
| 424 | private final String[] mValues; |
| 425 | private final boolean mFlushOnCameraChange; |
| 426 | |
| 427 | /** |
| 428 | * A constructor used to store a setting's profile. |
| 429 | */ |
Sascha Haeberling | ed10741 | 2014-03-19 19:48:06 -0700 | [diff] [blame] | 430 | public Setting(String source, String type, String defaultValue, String key, |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 431 | String[] values, boolean flushOnCameraChange) { |
| 432 | mSource = source; |
| 433 | mType = type; |
| 434 | mDefault = defaultValue; |
| 435 | mKey = key; |
| 436 | mValues = values; |
| 437 | mFlushOnCameraChange = flushOnCameraChange; |
| 438 | } |
| 439 | |
| 440 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 441 | * Returns the id of a SharedPreferences instance from which this |
| 442 | * Setting may be found. Possible values are {@link #SOURCE_DEFAULT}, |
| 443 | * {@link #SOURCE_GLOBAL}, {@link #SOURCE_CAMERA}. |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 444 | */ |
| 445 | public String getSource() { |
| 446 | return mSource; |
| 447 | } |
| 448 | |
| 449 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 450 | * Returns the type of the setting stored in SharedPreferences. Possible |
| 451 | * values are {@link #TYPE_STRING}, {@link #TYPE_INTEGER}, |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 452 | * {@link #TYPE_BOOLEAN}. |
| 453 | */ |
| 454 | public String getType() { |
| 455 | return mType; |
| 456 | } |
| 457 | |
| 458 | /** |
| 459 | * Returns the default value of this setting. |
| 460 | */ |
| 461 | public String getDefault() { |
| 462 | return mDefault; |
| 463 | } |
| 464 | |
| 465 | /** |
| 466 | * Returns the SharedPreferences key for this setting. |
| 467 | */ |
| 468 | public String getKey() { |
| 469 | return mKey; |
| 470 | } |
| 471 | |
| 472 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 473 | * Returns an array of possible String values for this setting. If this |
| 474 | * setting is not of type {@link #TYPE_STRING}, or it's not possible to |
| 475 | * generate the string values, this should return null; |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 476 | */ |
| 477 | public String[] getStringValues() { |
| 478 | return mValues; |
| 479 | } |
| 480 | |
| 481 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 482 | * Returns whether the setting should be flushed from the cache when the |
| 483 | * camera device has changed. |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 484 | */ |
| 485 | public boolean isFlushedOnCameraChanged() { |
| 486 | return mFlushOnCameraChange; |
| 487 | } |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 488 | } |
| 489 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 490 | /** |
| 491 | * Get the SharedPreferences needed to query/update the setting. |
| 492 | */ |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 493 | public SharedPreferences getSettingSource(Setting setting) { |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 494 | return getSettingSource(setting.getSource()); |
| 495 | } |
| 496 | |
| 497 | private SharedPreferences getSettingSource(String source) { |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 498 | if (source.equals(SOURCE_DEFAULT)) { |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 499 | return mDefaultSettings; |
| 500 | } |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 501 | if (source.equals(SOURCE_GLOBAL)) { |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 502 | return mGlobalSettings; |
| 503 | } |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 504 | if (source.equals(SOURCE_CAMERA)) { |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 505 | return mCameraSettings; |
| 506 | } |
Erin Dahlgren | d186f22 | 2014-01-10 11:24:31 -0800 | [diff] [blame] | 507 | if (source.equals(SOURCE_MODULE)) { |
Erin Dahlgren | 1ba90e3 | 2014-03-03 12:05:57 -0800 | [diff] [blame] | 508 | int modeIndex = CameraUtil.getCameraModeParentModeId( |
| 509 | mAppController.getCurrentModuleIndex(), mAppController.getAndroidContext()); |
Erin Dahlgren | d186f22 | 2014-01-10 11:24:31 -0800 | [diff] [blame] | 510 | return getModulePreferences(modeIndex); |
| 511 | } |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 512 | return null; |
| 513 | } |
| 514 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 515 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 516 | * Based on Setting id, finds the index of a Setting's String value in an |
| 517 | * array of possible String values. If the Setting is not of type String, |
| 518 | * this returns -1. |
| 519 | * <p> |
| 520 | * TODO: make this a supported api call for all types. |
| 521 | * </p> |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 522 | */ |
| 523 | public int getStringValueIndex(int id) { |
| 524 | Setting setting = mSettingsCache.get(id); |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 525 | if (setting == null || !TYPE_STRING.equals(setting.getType())) { |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 526 | return -1; |
| 527 | } |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 528 | return getStringValueIndex(setting.getStringValues(), get(id)); |
| 529 | } |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 530 | |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 531 | private int getStringValueIndex(String[] possibleValues, String value) { |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 532 | if (value != null) { |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 533 | if (possibleValues != null) { |
| 534 | for (int i = 0; i < possibleValues.length; i++) { |
| 535 | if (value.equals(possibleValues[i])) { |
| 536 | return i; |
| 537 | } |
| 538 | } |
| 539 | } |
| 540 | } |
| 541 | return -1; |
| 542 | } |
| 543 | |
| 544 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 545 | * Based on Setting id, sets a Setting's String value using the index into |
| 546 | * an array of possible String values. Fails to set a value if the index is |
| 547 | * out of bounds or the Setting is not of type String. |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 548 | * |
| 549 | * @return Whether the value was set. |
| 550 | */ |
| 551 | public boolean setStringValueIndex(int id, int index) { |
| 552 | Setting setting = mSettingsCache.get(id); |
| 553 | if (setting == null || setting.getType() != TYPE_STRING) { |
| 554 | return false; |
| 555 | } |
| 556 | |
| 557 | String[] possibleValues = setting.getStringValues(); |
| 558 | if (possibleValues != null) { |
| 559 | if (index >= 0 && index < possibleValues.length) { |
| 560 | set(id, possibleValues[index]); |
| 561 | return true; |
| 562 | } |
| 563 | } |
| 564 | return false; |
| 565 | } |
| 566 | |
| 567 | /** |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 568 | * Returns whether this Setting was last set as a String. |
| 569 | */ |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 570 | private boolean isString(int id, String source) { |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 571 | Setting setting = mSettingsCache.get(id); |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 572 | SharedPreferences preferences = getSettingSource(source); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 573 | try { |
| 574 | preferences.getString(setting.getKey(), null); |
| 575 | return true; |
| 576 | } catch (ClassCastException e) { |
| 577 | return false; |
| 578 | } |
| 579 | } |
| 580 | |
| 581 | /** |
| 582 | * Returns whether this Setting was last set as a boolean. |
| 583 | */ |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 584 | private boolean isBoolean(int id, String source) { |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 585 | Setting setting = mSettingsCache.get(id); |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 586 | SharedPreferences preferences = getSettingSource(source); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 587 | try { |
| 588 | preferences.getBoolean(setting.getKey(), false); |
| 589 | return true; |
| 590 | } catch (ClassCastException e) { |
| 591 | return false; |
| 592 | } |
| 593 | } |
| 594 | |
| 595 | /** |
| 596 | * Returns whether this Setting was last set as an Integer. |
| 597 | */ |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 598 | private boolean isInteger(int id, String source) { |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 599 | Setting setting = mSettingsCache.get(id); |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 600 | SharedPreferences preferences = getSettingSource(source); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 601 | try { |
| 602 | preferences.getInt(setting.getKey(), 0); |
| 603 | return true; |
| 604 | } catch (NumberFormatException e) { |
| 605 | return false; |
| 606 | } |
| 607 | } |
| 608 | |
| 609 | /** |
| 610 | * Recover a Setting by converting it to a String if the type |
| 611 | * is known and the type conversion is successful, otherwise |
| 612 | * reset to the default. |
| 613 | */ |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 614 | private String recoverToString(int id, String source) { |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 615 | String value; |
| 616 | try { |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 617 | if (isBoolean(id, source)) { |
| 618 | value = (getBoolean(id, source) ? VALUE_ON : VALUE_OFF); |
| 619 | } else if (isInteger(id, source)) { |
| 620 | value = Integer.toString(getInt(id, source)); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 621 | } else { |
| 622 | throw new Exception(); |
| 623 | } |
| 624 | } catch (Exception e) { |
| 625 | value = mSettingsCache.get(id).getDefault(); |
| 626 | } |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 627 | set(id, source, value); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 628 | return value; |
| 629 | } |
| 630 | |
| 631 | /** |
| 632 | * Recover a Setting by converting it to a boolean if the type |
| 633 | * is known and the type conversion is successful, otherwise |
| 634 | * reset to the default. |
| 635 | */ |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 636 | private boolean recoverToBoolean(int id, String source) { |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 637 | boolean value; |
| 638 | try { |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 639 | if (isString(id, source)) { |
| 640 | value = VALUE_ON.equals(get(id, source)); |
| 641 | } else if (isInteger(id, source)) { |
| 642 | value = getInt(id, source) != 0; |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 643 | } else { |
| 644 | throw new Exception(); |
| 645 | } |
| 646 | } catch (Exception e) { |
| 647 | value = VALUE_ON.equals(mSettingsCache.get(id).getDefault()); |
| 648 | } |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 649 | setBoolean(id, source, value); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 650 | return value; |
| 651 | } |
| 652 | |
| 653 | /** |
| 654 | * Recover a Setting by converting it to an Integer if the type |
| 655 | * is known and the type conversion is successful, otherwise |
| 656 | * reset to the default. |
| 657 | */ |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 658 | private int recoverToInteger(int id, String source) { |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 659 | int value; |
| 660 | try { |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 661 | if (isString(id, source)) { |
| 662 | value = Integer.parseInt(get(id, source)); |
| 663 | } else if (isBoolean(id, source)) { |
| 664 | value = getBoolean(id, source) ? 1 : 0; |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 665 | } else { |
| 666 | throw new Exception(); |
| 667 | } |
| 668 | } catch (Exception e) { |
| 669 | value = Integer.parseInt(mSettingsCache.get(id).getDefault()); |
| 670 | } |
| 671 | setInt(id, value); |
| 672 | return value; |
| 673 | } |
| 674 | |
| 675 | /** |
| 676 | * Check if a String value is in the set of possible values for a Setting. |
| 677 | * We only keep track of possible values for String types for now. |
| 678 | */ |
| 679 | private String sanitize(Setting setting, String value) { |
| 680 | if (setting.getStringValues() != null && |
| 681 | getStringValueIndex(setting.getStringValues(), value) < 0) { |
| 682 | // If the set of possible values is not empty, and the value |
| 683 | // is not in the set of possible values, use the default, because |
| 684 | // the set of possible values probably changed. |
| 685 | return setting.getDefault(); |
| 686 | } |
| 687 | return value; |
| 688 | } |
| 689 | |
| 690 | /** |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 691 | * Get a Setting's String value based on Setting id. |
| 692 | */ |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 693 | // TODO: rename to something more descriptive like getString. |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 694 | public String get(int id) { |
| 695 | Setting setting = mSettingsCache.get(id); |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 696 | return get(id, setting.getSource()); |
| 697 | } |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 698 | |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 699 | /** |
| 700 | * Get a Setting's String value based on Setting id and a source file id. |
| 701 | */ |
| 702 | public String get(int id, String source) { |
| 703 | Setting setting = mSettingsCache.get(id); |
| 704 | SharedPreferences preferences = getSettingSource(source); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 705 | if (preferences != null) { |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 706 | try { |
| 707 | String value = preferences.getString(setting.getKey(), setting.getDefault()); |
| 708 | return sanitize(setting, value); |
| 709 | } catch (ClassCastException e) { |
| 710 | // If the api defines this Setting as a String, but the |
| 711 | // last set saved it as a different type, try to recover |
| 712 | // the value, but if impossible reset to default. |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 713 | return recoverToString(id, source); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 714 | } |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 715 | } else { |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 716 | throw new IllegalStateException( |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 717 | "Setting source=" + source + " is unitialized."); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 718 | } |
| 719 | } |
| 720 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 721 | /** |
| 722 | * Get a Setting's boolean value based on Setting id. |
| 723 | */ |
| 724 | public boolean getBoolean(int id) { |
| 725 | Setting setting = mSettingsCache.get(id); |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 726 | return getBoolean(id, setting.getSource()); |
| 727 | } |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 728 | |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 729 | /** |
| 730 | * Get a Setting's boolean value based on a Setting id and a source file id. |
| 731 | */ |
| 732 | public boolean getBoolean(int id, String source) { |
| 733 | Setting setting = mSettingsCache.get(id); |
| 734 | SharedPreferences preferences = getSettingSource(source); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 735 | boolean defaultValue = VALUE_ON.equals(setting.getDefault()); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 736 | if (preferences != null) { |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 737 | try { |
| 738 | return preferences.getBoolean(setting.getKey(), defaultValue); |
| 739 | } catch (ClassCastException e) { |
| 740 | // If the api defines this Setting as a boolean, but the |
| 741 | // last set saved it as a different type, try to recover |
| 742 | // the value, but if impossible reset to default. |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 743 | return recoverToBoolean(id, source); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 744 | } |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 745 | } else { |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 746 | throw new IllegalStateException( |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 747 | "Setting source=" + source + " is unitialized."); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 748 | } |
| 749 | } |
| 750 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 751 | /** |
| 752 | * Get a Setting's int value based on Setting id. |
| 753 | */ |
| 754 | public int getInt(int id) { |
| 755 | Setting setting = mSettingsCache.get(id); |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 756 | return getInt(id, setting.getSource()); |
| 757 | } |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 758 | |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 759 | /** |
| 760 | * Get a Setting's int value based on Setting id and a source file id. |
| 761 | */ |
| 762 | public int getInt(int id, String source) { |
| 763 | Setting setting = mSettingsCache.get(id); |
| 764 | SharedPreferences preferences = getSettingSource(source); |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 765 | int defaultValue = Integer.parseInt(setting.getDefault()); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 766 | if (preferences != null) { |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 767 | try { |
| 768 | return preferences.getInt(setting.getKey(), defaultValue); |
| 769 | } catch (NumberFormatException e) { |
| 770 | // If the api defines this Setting as an Integer, but the |
| 771 | // last set saved it as a different type, try to recover |
| 772 | // the value, but if impossible reset to default. |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 773 | return recoverToInteger(id, source); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 774 | } |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 775 | } else { |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 776 | throw new IllegalStateException( |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 777 | "Setting source=" + source + " is unitialized."); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 778 | } |
| 779 | } |
| 780 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 781 | /** |
| 782 | * Set a Setting with a String value based on Setting id. |
| 783 | */ |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 784 | // TODO: rename to something more descriptive. |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 785 | public void set(int id, String value) { |
| 786 | Setting setting = mSettingsCache.get(id); |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 787 | set(id, setting.getSource(), value); |
| 788 | } |
| 789 | |
| 790 | /** |
| 791 | * Set a Setting with a String value based on Setting id and a source file id. |
| 792 | */ |
| 793 | public void set(int id, String source, String value) { |
| 794 | Setting setting = mSettingsCache.get(id); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 795 | value = sanitize(setting, value); |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 796 | SharedPreferences preferences = getSettingSource(source); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 797 | if (preferences != null) { |
| 798 | preferences.edit().putString(setting.getKey(), value).apply(); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 799 | } else { |
| 800 | throw new IllegalStateException( |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 801 | "Setting source=" + source + " is unitialized."); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 802 | } |
| 803 | } |
| 804 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 805 | /** |
| 806 | * Set a Setting with a boolean value based on Setting id. |
| 807 | */ |
| 808 | public void setBoolean(int id, boolean value) { |
| 809 | Setting setting = mSettingsCache.get(id); |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 810 | setBoolean(id, setting.getSource(), value); |
| 811 | } |
| 812 | /** |
| 813 | * Set a Setting with a boolean value based on Setting id and a source file id. |
| 814 | */ |
| 815 | public void setBoolean(int id, String source, boolean value) { |
| 816 | Setting setting = mSettingsCache.get(id); |
| 817 | SharedPreferences preferences = getSettingSource(source); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 818 | if (preferences != null) { |
| 819 | preferences.edit().putBoolean(setting.getKey(), value).apply(); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 820 | } else { |
| 821 | throw new IllegalStateException( |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 822 | "Setting source=" + source + " is unitialized."); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 823 | } |
| 824 | } |
| 825 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 826 | /** |
| 827 | * Set a Setting with an int value based on Setting id. |
| 828 | */ |
| 829 | public void setInt(int id, int value) { |
| 830 | Setting setting = mSettingsCache.get(id); |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 831 | setInt(id, setting.getSource(), value); |
| 832 | } |
| 833 | |
| 834 | /** |
| 835 | * Set a Setting with an int value based on Setting id and a source file id. |
| 836 | */ |
| 837 | public void setInt(int id, String source, int value) { |
| 838 | Setting setting = mSettingsCache.get(id); |
| 839 | SharedPreferences preferences = getSettingSource(source); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 840 | if (preferences != null) { |
| 841 | preferences.edit().putInt(setting.getKey(), value).apply(); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 842 | } else { |
| 843 | throw new IllegalStateException( |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 844 | "Setting source=" + source + " is unitialized."); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 845 | } |
| 846 | } |
| 847 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 848 | /** |
| 849 | * Check if a Setting has ever been set based on Setting id. |
| 850 | */ |
| 851 | public boolean isSet(int id) { |
| 852 | Setting setting = mSettingsCache.get(id); |
Erin Dahlgren | 9182ac8 | 2014-03-17 12:26:48 -0700 | [diff] [blame] | 853 | return isSet(id, setting.getSource()); |
| 854 | } |
| 855 | |
| 856 | /** |
| 857 | * Check if a Setting has ever been set based on Setting id and a source file id. |
| 858 | */ |
| 859 | public boolean isSet(int id, String source) { |
| 860 | Setting setting = mSettingsCache.get(id); |
| 861 | SharedPreferences preferences = getSettingSource(source); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 862 | if (preferences != null) { |
| 863 | return preferences.contains(setting.getKey()); |
| 864 | } else { |
| 865 | throw new IllegalStateException( |
| 866 | "Setting source=" + setting.getSource() + " is unitialized."); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 867 | } |
| 868 | } |
| 869 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 870 | /** |
| 871 | * Set a Setting to its default value based on Setting id. |
| 872 | */ |
| 873 | public void setDefault(int id) { |
| 874 | Setting setting = mSettingsCache.get(id); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 875 | SharedPreferences preferences = getSettingSource(setting); |
| 876 | if (preferences != null) { |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 877 | preferences.edit().putString(setting.getKey(), setting.getDefault()); |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 878 | } else { |
| 879 | throw new IllegalStateException( |
| 880 | "Setting source=" + setting.getSource() + " is unitialized."); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 881 | } |
| 882 | } |
| 883 | |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 884 | /** |
| 885 | * Check if a Setting is set to its default value. |
| 886 | */ |
| 887 | public boolean isDefault(int id) { |
| 888 | Setting setting = mSettingsCache.get(id); |
| 889 | SharedPreferences preferences = getSettingSource(setting); |
| 890 | if (preferences != null) { |
| 891 | String type = setting.getType(); |
| 892 | if (TYPE_STRING.equals(type)) { |
| 893 | String value = get(id); |
| 894 | return (value.equals(setting.getDefault())); |
| 895 | } else if (TYPE_BOOLEAN.equals(type)) { |
| 896 | boolean value = getBoolean(id); |
| 897 | boolean defaultValue = VALUE_ON.equals(setting.getDefault()); |
| 898 | return (value == defaultValue); |
| 899 | } else if (TYPE_INTEGER.equals(type)) { |
| 900 | int value = getInt(id); |
| 901 | int defaultValue = Integer.parseInt(setting.getDefault()); |
| 902 | return (value == defaultValue); |
| 903 | } else { |
| 904 | throw new IllegalArgumentException("Type " + type + " is not known."); |
| 905 | } |
| 906 | } else { |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 907 | throw new IllegalStateException( |
| 908 | "Setting source=" + setting.getSource() + " is unitialized."); |
| 909 | } |
| 910 | } |
| 911 | |
| 912 | /** |
| 913 | * Remove a Setting from SharedPreferences. |
| 914 | */ |
| 915 | public void remove(int id) { |
| 916 | Setting setting = mSettingsCache.get(id); |
| 917 | SharedPreferences preferences = getSettingSource(setting); |
| 918 | if (preferences != null) { |
| 919 | preferences.edit().remove(setting.getKey()).apply(); |
| 920 | } else { |
| 921 | throw new IllegalStateException( |
| 922 | "Setting source=" + setting.getSource() + " is unitialized."); |
Erin Dahlgren | 1648c36 | 2014-01-06 15:06:04 -0800 | [diff] [blame] | 923 | } |
| 924 | } |
| 925 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 926 | public static Setting getLocationSetting(Context context) { |
| 927 | String defaultValue = context.getString(R.string.setting_none_value); |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 928 | String[] values = null; |
| 929 | return new Setting(SOURCE_DEFAULT, TYPE_BOOLEAN, defaultValue, KEY_RECORD_LOCATION, |
| 930 | values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 931 | } |
| 932 | |
Sascha Haeberling | 6ccec20 | 2014-03-11 09:44:34 -0700 | [diff] [blame] | 933 | public static Setting getPictureSizeBackSetting(Context context) { |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 934 | String defaultValue = null; |
| 935 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 936 | R.array.pref_camera_picturesize_entryvalues); |
Sascha Haeberling | 6ccec20 | 2014-03-11 09:44:34 -0700 | [diff] [blame] | 937 | return new Setting(SOURCE_DEFAULT, TYPE_STRING, defaultValue, KEY_PICTURE_SIZE_BACK, |
| 938 | values, FLUSH_OFF); |
| 939 | } |
| 940 | |
| 941 | public static Setting getPictureSizeFrontSetting(Context context) { |
| 942 | String defaultValue = null; |
| 943 | String[] values = context.getResources().getStringArray( |
| 944 | R.array.pref_camera_picturesize_entryvalues); |
| 945 | return new Setting(SOURCE_DEFAULT, TYPE_STRING, defaultValue, KEY_PICTURE_SIZE_FRONT, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 946 | values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 947 | } |
| 948 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 949 | public static Setting getDefaultCameraIdSetting(Context context, |
| 950 | SettingsCapabilities capabilities) { |
| 951 | String defaultValue = context.getString(R.string.pref_camera_id_default); |
| 952 | String[] values = null; |
| 953 | if (capabilities != null) { |
| 954 | values = capabilities.getSupportedCameraIds(); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 955 | } |
Erin Dahlgren | d186f22 | 2014-01-10 11:24:31 -0800 | [diff] [blame] | 956 | return new Setting(SOURCE_MODULE, TYPE_STRING, defaultValue, KEY_CAMERA_ID, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 957 | values, FLUSH_ON); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 958 | } |
| 959 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 960 | public static Setting getWhiteBalanceSetting(Context context) { |
| 961 | String defaultValue = context.getString(R.string.pref_camera_whitebalance_default); |
| 962 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 963 | R.array.pref_camera_whitebalance_entryvalues); |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 964 | return new Setting(SOURCE_CAMERA, TYPE_STRING, defaultValue, KEY_WHITE_BALANCE, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 965 | values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 966 | } |
| 967 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 968 | public static Setting getHdrSetting(Context context) { |
| 969 | String defaultValue = context.getString(R.string.pref_camera_hdr_default); |
| 970 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 971 | R.array.pref_camera_hdr_entryvalues); |
Erin Dahlgren | ba6994d | 2013-12-12 16:04:38 -0800 | [diff] [blame] | 972 | return new Setting(SOURCE_GLOBAL, TYPE_STRING, defaultValue, KEY_CAMERA_HDR, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 973 | values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 974 | } |
| 975 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 976 | public static Setting getHdrPlusSetting(Context context) { |
| 977 | String defaultValue = context.getString(R.string.pref_camera_hdr_plus_default); |
| 978 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 979 | R.array.pref_camera_hdr_plus_entryvalues); |
Erin Dahlgren | ba6994d | 2013-12-12 16:04:38 -0800 | [diff] [blame] | 980 | return new Setting(SOURCE_GLOBAL, TYPE_STRING, defaultValue, KEY_CAMERA_HDR_PLUS, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 981 | values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 982 | } |
| 983 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 984 | public static Setting getSceneModeSetting(Context context) { |
| 985 | String defaultValue = context.getString(R.string.pref_camera_scenemode_default); |
| 986 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 987 | R.array.pref_camera_scenemode_entryvalues); |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 988 | return new Setting(SOURCE_CAMERA, TYPE_STRING, defaultValue, KEY_SCENE_MODE, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 989 | values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 990 | } |
| 991 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 992 | public static Setting getFlashSetting(Context context) { |
| 993 | String defaultValue = context.getString(R.string.pref_camera_flashmode_default); |
| 994 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 995 | R.array.pref_camera_flashmode_entryvalues); |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 996 | return new Setting(SOURCE_CAMERA, TYPE_STRING, defaultValue, KEY_FLASH_MODE, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 997 | values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 998 | } |
| 999 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1000 | public static Setting getExposureSetting(Context context, |
| 1001 | SettingsCapabilities capabilities) { |
| 1002 | String defaultValue = context.getString(R.string.pref_exposure_default); |
| 1003 | String[] values = null; |
| 1004 | if (capabilities != null) { |
| 1005 | values = capabilities.getSupportedExposureValues(); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1006 | } |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1007 | return new Setting(SOURCE_CAMERA, TYPE_STRING, defaultValue, KEY_EXPOSURE, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1008 | values, FLUSH_ON); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1009 | } |
| 1010 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1011 | public static Setting getHintSetting(Context context) { |
| 1012 | String defaultValue = context.getString(R.string.setting_on_value); |
| 1013 | String[] values = null; |
| 1014 | return new Setting(SOURCE_GLOBAL, TYPE_BOOLEAN, defaultValue, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1015 | KEY_CAMERA_FIRST_USE_HINT_SHOWN, values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1016 | } |
| 1017 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1018 | public static Setting getFocusModeSetting(Context context) { |
| 1019 | String defaultValue = null; |
| 1020 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1021 | R.array.pref_camera_focusmode_entryvalues); |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1022 | return new Setting(SOURCE_CAMERA, TYPE_STRING, defaultValue, KEY_FOCUS_MODE, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1023 | values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1024 | } |
| 1025 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1026 | public static Setting getTimerSetting(Context context) { |
| 1027 | String defaultValue = context.getString(R.string.pref_camera_timer_default); |
| 1028 | String[] values = null; // TODO: get the values dynamically. |
| 1029 | return new Setting(SOURCE_GLOBAL, TYPE_STRING, defaultValue, KEY_TIMER, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1030 | values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1031 | } |
| 1032 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1033 | public static Setting getTimerSoundSetting(Context context) { |
| 1034 | String defaultValue = context.getString(R.string.pref_camera_timer_sound_default); |
| 1035 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1036 | R.array.pref_camera_timer_sound_entryvalues); |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1037 | return new Setting(SOURCE_GLOBAL, TYPE_STRING, defaultValue, KEY_TIMER_SOUND_EFFECTS, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1038 | values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1039 | } |
| 1040 | |
Sascha Haeberling | 6ccec20 | 2014-03-11 09:44:34 -0700 | [diff] [blame] | 1041 | public static Setting getVideoQualityBackSetting(Context context) { |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1042 | String defaultValue = context.getString(R.string.pref_video_quality_default); |
| 1043 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1044 | R.array.pref_video_quality_entryvalues); |
Sascha Haeberling | 6ccec20 | 2014-03-11 09:44:34 -0700 | [diff] [blame] | 1045 | return new Setting(SOURCE_DEFAULT, TYPE_STRING, defaultValue, KEY_VIDEO_QUALITY_BACK, |
| 1046 | values, FLUSH_OFF); |
| 1047 | } |
| 1048 | |
| 1049 | public static Setting getVideoQualityFrontSetting(Context context) { |
| 1050 | String defaultValue = context.getString(R.string.pref_video_quality_default); |
| 1051 | String[] values = context.getResources().getStringArray( |
| 1052 | R.array.pref_video_quality_entryvalues); |
| 1053 | return new Setting(SOURCE_DEFAULT, TYPE_STRING, defaultValue, KEY_VIDEO_QUALITY_FRONT, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1054 | values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1055 | } |
| 1056 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1057 | public static Setting getTimeLapseFrameIntervalSetting(Context context) { |
| 1058 | String defaultValue = context.getString( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1059 | R.string.pref_video_time_lapse_frame_interval_default); |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1060 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1061 | R.array.pref_video_time_lapse_frame_interval_entryvalues); |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1062 | return new Setting(SOURCE_GLOBAL, TYPE_STRING, defaultValue, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1063 | KEY_VIDEO_TIME_LAPSE_FRAME_INTERVAL, values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1064 | } |
| 1065 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1066 | public static Setting getJpegQualitySetting(Context context) { |
| 1067 | String defaultValue = context.getString( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1068 | R.string.pref_camera_jpeg_quality_normal); |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1069 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1070 | R.array.pref_camera_jpeg_quality_entryvalues); |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1071 | return new Setting(SOURCE_CAMERA, TYPE_STRING, defaultValue, KEY_JPEG_QUALITY, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1072 | values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1073 | } |
| 1074 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1075 | public static Setting getVideoFlashSetting(Context context) { |
| 1076 | String defaultValue = context.getString(R.string.pref_camera_video_flashmode_default); |
| 1077 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1078 | R.array.pref_camera_video_flashmode_entryvalues); |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1079 | return new Setting(SOURCE_CAMERA, TYPE_STRING, defaultValue, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1080 | KEY_VIDEOCAMERA_FLASH_MODE, values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1081 | } |
| 1082 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1083 | public static Setting getVideoEffectSetting(Context context) { |
| 1084 | String defaultValue = context.getString(R.string.pref_video_effect_default); |
| 1085 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1086 | R.array.pref_video_effect_entryvalues); |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1087 | return new Setting(SOURCE_GLOBAL, TYPE_STRING, defaultValue, KEY_VIDEO_EFFECT, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1088 | values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1089 | } |
| 1090 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1091 | public static Setting getHintVideoSetting(Context context) { |
| 1092 | String defaultValue = context.getString(R.string.setting_on_value); |
| 1093 | String[] values = null; |
| 1094 | return new Setting(SOURCE_GLOBAL, TYPE_STRING, defaultValue, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1095 | KEY_VIDEO_FIRST_USE_HINT_SHOWN, values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1096 | } |
| 1097 | |
Erin Dahlgren | e419b19 | 2013-12-03 13:10:27 -0800 | [diff] [blame] | 1098 | public static Setting getStartupModuleSetting(Context context) { |
| 1099 | String defaultValue = context.getString(R.string.pref_camera_startup_index_default); |
| 1100 | String[] values = null; |
| 1101 | return new Setting(SOURCE_DEFAULT, TYPE_INTEGER, defaultValue, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1102 | KEY_STARTUP_MODULE_INDEX, values, FLUSH_OFF); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1103 | } |
| 1104 | |
Doris Liu | cf8b653 | 2014-01-15 19:17:38 -0800 | [diff] [blame] | 1105 | public static Setting getLastUsedCameraModule(Context context) { |
| 1106 | String defaultValue = Integer.toString(context.getResources() |
| 1107 | .getInteger(R.integer.camera_mode_photo)); |
| 1108 | return new Setting(SOURCE_DEFAULT, TYPE_INTEGER, defaultValue, |
| 1109 | KEY_CAMERA_MODULE_LAST_USED, null, FLUSH_OFF); |
| 1110 | } |
| 1111 | |
Erin Dahlgren | a1fab41 | 2014-01-21 09:31:11 -0800 | [diff] [blame] | 1112 | public static Setting getPanoOrientationSetting(Context context) { |
| 1113 | String defaultValue = context.getString(R.string.pano_orientation_horizontal); |
| 1114 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1115 | R.array.pref_camera_pano_orientation_entryvalues); |
Erin Dahlgren | a1fab41 | 2014-01-21 09:31:11 -0800 | [diff] [blame] | 1116 | return new Setting(SOURCE_GLOBAL, TYPE_STRING, defaultValue, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1117 | KEY_CAMERA_PANO_ORIENTATION, values, FLUSH_OFF); |
Erin Dahlgren | a1fab41 | 2014-01-21 09:31:11 -0800 | [diff] [blame] | 1118 | } |
| 1119 | |
Erin Dahlgren | d5e5146 | 2014-02-07 12:38:57 -0800 | [diff] [blame] | 1120 | public static Setting getGridLinesSetting(Context context) { |
| 1121 | String defaultValue = context.getString(R.string.setting_off_value); |
| 1122 | String[] values = context.getResources().getStringArray( |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1123 | R.array.pref_camera_gridlines_entryvalues); |
Erin Dahlgren | d5e5146 | 2014-02-07 12:38:57 -0800 | [diff] [blame] | 1124 | return new Setting(SOURCE_GLOBAL, TYPE_STRING, defaultValue, |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1125 | KEY_CAMERA_GRID_LINES, values, FLUSH_OFF); |
Erin Dahlgren | d5e5146 | 2014-02-07 12:38:57 -0800 | [diff] [blame] | 1126 | } |
| 1127 | |
Sascha Haeberling | c26a328 | 2014-02-19 08:39:28 -0800 | [diff] [blame] | 1128 | public static Setting getReleaseDialogLastShownVersionSetting(Context context) { |
| 1129 | return new Setting(SOURCE_DEFAULT, TYPE_STRING, null, |
| 1130 | KEY_RELEASE_DIALOG_LAST_SHOWN_VERSION, null, FLUSH_OFF); |
| 1131 | } |
| 1132 | |
Erin Dahlgren | e346fb2 | 2014-02-19 17:23:01 -0800 | [diff] [blame] | 1133 | public static Setting getFlashSupportedBackCameraSetting(Context context) { |
| 1134 | String defaultValue = context.getString(R.string.setting_none_value); |
| 1135 | return new Setting(SOURCE_GLOBAL, TYPE_BOOLEAN, defaultValue, |
| 1136 | KEY_FLASH_SUPPORTED_BACK_CAMERA, null, FLUSH_OFF); |
| 1137 | } |
| 1138 | |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 1139 | public static Setting getStrictUpgradeVersionSetting(Context context) { |
| 1140 | String defaultValue = "0"; |
| 1141 | return new Setting(SOURCE_DEFAULT, TYPE_INTEGER, defaultValue, |
| 1142 | KEY_STRICT_UPGRADE_VERSION, null, FLUSH_OFF); |
| 1143 | } |
| 1144 | |
Erin Dahlgren | 1ba90e3 | 2014-03-03 12:05:57 -0800 | [diff] [blame] | 1145 | public static Setting getRequestReturnHdrPlusSetting(Context context) { |
| 1146 | String defaultValue = context.getString(R.string.setting_none_value); |
| 1147 | return new Setting(SOURCE_MODULE, TYPE_BOOLEAN, VALUE_OFF, |
| 1148 | KEY_REQUEST_RETURN_HDR_PLUS, null, FLUSH_OFF); |
| 1149 | } |
| 1150 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 1151 | // Utilities. |
Erin Dahlgren | 8a2933b | 2013-12-06 12:07:33 -0800 | [diff] [blame] | 1152 | |
| 1153 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1154 | * Returns whether the camera has been set to back facing in settings. |
Erin Dahlgren | 8a2933b | 2013-12-06 12:07:33 -0800 | [diff] [blame] | 1155 | */ |
| 1156 | public boolean isCameraBackFacing() { |
Erin Dahlgren | d186f22 | 2014-01-10 11:24:31 -0800 | [diff] [blame] | 1157 | String cameraFacing = get(SETTING_CAMERA_ID); |
| 1158 | String backFacing = mContext.getString(R.string.pref_camera_id_default); |
| 1159 | return (Integer.parseInt(cameraFacing) == Integer.parseInt(backFacing)); |
Erin Dahlgren | 8a2933b | 2013-12-06 12:07:33 -0800 | [diff] [blame] | 1160 | } |
| 1161 | |
Erin Dahlgren | a340f07 | 2014-01-06 17:31:23 -0800 | [diff] [blame] | 1162 | /** |
Erin Dahlgren | a340f07 | 2014-01-06 17:31:23 -0800 | [diff] [blame] | 1163 | * Returns whether hdr plus mode is set on. |
| 1164 | */ |
| 1165 | public boolean isHdrPlusOn() { |
| 1166 | String hdrOn = get(SettingsManager.SETTING_CAMERA_HDR); |
| 1167 | return hdrOn.equals(SettingsManager.VALUE_ON); |
| 1168 | } |
| 1169 | |
Erin Dahlgren | d5e5146 | 2014-02-07 12:38:57 -0800 | [diff] [blame] | 1170 | /** |
Erin Dahlgren | 1ba90e3 | 2014-03-03 12:05:57 -0800 | [diff] [blame] | 1171 | * Returns whether the app should return to hdr plus mode if possible. |
| 1172 | */ |
| 1173 | public boolean requestsReturnToHdrPlus() { |
| 1174 | return getBoolean(SettingsManager.SETTING_REQUEST_RETURN_HDR_PLUS); |
| 1175 | } |
| 1176 | |
| 1177 | /** |
Erin Dahlgren | d5e5146 | 2014-02-07 12:38:57 -0800 | [diff] [blame] | 1178 | * Returns whether grid lines are set on. |
| 1179 | */ |
| 1180 | public boolean areGridLinesOn() { |
| 1181 | String gridLinesOn = get(SettingsManager.SETTING_CAMERA_GRID_LINES); |
| 1182 | return gridLinesOn.equals(SettingsManager.VALUE_ON); |
| 1183 | } |
| 1184 | |
Erin Dahlgren | f80ac9e | 2014-02-18 11:20:34 -0800 | [diff] [blame] | 1185 | /** |
| 1186 | * Returns whether pano orientation is horizontal. |
| 1187 | */ |
| 1188 | public boolean isPanoOrientationHorizontal() { |
| 1189 | String orientation = get(SettingsManager.SETTING_CAMERA_PANO_ORIENTATION); |
| 1190 | String horizontal = mContext.getString(R.string.pano_orientation_horizontal); |
| 1191 | return orientation.equals(horizontal); |
| 1192 | } |
| 1193 | |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1194 | // TODO: refactor this into a separate utils module. |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1195 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 1196 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1197 | * Get a String value from first the ListPreference, and if not found from |
| 1198 | * the SettingsManager. This is a wrapper that adds backwards compatibility |
| 1199 | * to views that rely on PreferenceGroups. |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 1200 | */ |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1201 | public String getValueFromPreference(ListPreference pref) { |
| 1202 | String value = pref.getValue(); |
| 1203 | if (value == null) { |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 1204 | Integer id = mSettingsCache.getId(pref.getKey()); |
| 1205 | if (id == null) { |
| 1206 | return null; |
| 1207 | } |
| 1208 | value = get(id); |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1209 | } |
| 1210 | return value; |
| 1211 | } |
| 1212 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 1213 | /** |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1214 | * Set a String value first from the ListPreference, and if unable from the |
| 1215 | * SettingsManager. This is a wrapper that adds backwards compatibility to |
| 1216 | * views that rely on PreferenceGroups. |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 1217 | */ |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1218 | public void setValueFromPreference(ListPreference pref, String value) { |
| 1219 | boolean set = pref.setValue(value); |
| 1220 | if (!set) { |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 1221 | Integer id = mSettingsCache.getId(pref.getKey()); |
| 1222 | if (id != null) { |
| 1223 | set(id, value); |
| 1224 | } |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1225 | } |
| 1226 | } |
| 1227 | |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 1228 | /** |
| 1229 | * Set a String value first from the ListPreference based on a |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1230 | * ListPreference index, and if unable use the ListPreference key to set the |
| 1231 | * value using the SettingsManager. This is a wrapper that adds backwards |
| 1232 | * compatibility to views that rely on PreferenceGroups. |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 1233 | */ |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1234 | public void setValueIndexFromPreference(ListPreference pref, int index) { |
| 1235 | boolean set = pref.setValueIndex(index); |
| 1236 | if (!set) { |
Erin Dahlgren | 635a4b8 | 2013-11-25 15:21:18 -0800 | [diff] [blame] | 1237 | Integer id = mSettingsCache.getId(pref.getKey()); |
| 1238 | if (id != null) { |
| 1239 | String value = pref.getValueAtIndex(index); |
| 1240 | set(id, value); |
| 1241 | } |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1242 | } |
| 1243 | } |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1244 | |
| 1245 | /** |
| 1246 | * Sets the settings for whether location recording should be enabled or |
| 1247 | * not. Also makes sure to pass on the change to the location manager. |
| 1248 | */ |
| 1249 | public void setLocation(boolean on, LocationManager locationManager) { |
| 1250 | setBoolean(SettingsManager.SETTING_RECORD_LOCATION, on); |
| 1251 | locationManager.recordLocation(on); |
| 1252 | } |
| 1253 | |
| 1254 | /** |
| 1255 | * Reads the current location recording settings and passes it on to the |
| 1256 | * given location manager. |
| 1257 | */ |
| 1258 | public void syncLocationManager(LocationManager locationManager) { |
Erin Dahlgren | 4569b70 | 2014-02-24 14:21:11 -0800 | [diff] [blame] | 1259 | boolean value = getBoolean(SettingsManager.SETTING_RECORD_LOCATION); |
Sascha Haeberling | de30323 | 2014-02-07 02:30:53 +0100 | [diff] [blame] | 1260 | locationManager.recordLocation(value); |
| 1261 | } |
Erin Dahlgren | 357b767 | 2013-11-20 17:38:14 -0800 | [diff] [blame] | 1262 | } |