blob: 2f93d5752354dec2f03e599118979b2010eea53b [file] [log] [blame]
The Android Open Source Project0c908882009-03-03 19:32:16 -08001/*
John Reck35e9dd62011-04-25 09:01:54 -07002 * Copyright (C) 2011 The Android Open Source Project
The Android Open Source Project0c908882009-03-03 19:32:16 -08003 *
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
Bijan Amirzada41242f22014-03-21 12:12:18 -070017package com.android.browser;
The Android Open Source Project0c908882009-03-03 19:32:16 -080018
The Android Open Source Project0c908882009-03-03 19:32:16 -080019import android.content.ContentResolver;
20import android.content.Context;
The Android Open Source Project0c908882009-03-03 19:32:16 -080021import android.content.SharedPreferences;
John Reck1da81882011-10-04 17:21:10 -070022import android.content.SharedPreferences.Editor;
John Reck812d2d62011-01-18 14:16:15 -080023import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
Victoria Lease96497832012-03-23 14:19:56 -070024import android.net.ConnectivityManager;
25import android.net.NetworkInfo;
John Reckf48314f2011-04-27 17:52:17 -070026import android.os.Build;
Ben Murdoch0cb81892010-10-08 12:41:33 +010027import android.preference.PreferenceManager;
Mathew Inwood825fba72011-10-04 14:52:52 +010028import android.provider.Settings;
Bijan Amirzadae75909d2014-05-06 14:18:54 -070029import android.text.TextUtils;
John Reck5ba3c762011-09-14 15:00:15 -070030import android.util.DisplayMetrics;
The Android Open Source Project0c908882009-03-03 19:32:16 -080031import android.webkit.WebIconDatabase;
Nicolas Roard78a98e42009-05-11 13:34:17 +010032import android.webkit.WebStorage;
The Android Open Source Project0c908882009-03-03 19:32:16 -080033
Bijan Amirzada41242f22014-03-21 12:12:18 -070034import com.android.browser.R;
35import com.android.browser.homepages.HomeProvider;
Bijan Amirzada3f04dc72014-06-25 11:48:36 -070036import com.android.browser.platformsupport.Browser;
Bijan Amirzada41242f22014-03-21 12:12:18 -070037import com.android.browser.provider.BrowserProvider;
Bijan Amirzada41242f22014-03-21 12:12:18 -070038import com.android.browser.search.SearchEngine;
39import com.android.browser.search.SearchEngines;
John Reck46500332011-06-07 14:36:10 -070040
John Reck35e9dd62011-04-25 09:01:54 -070041import java.lang.ref.WeakReference;
42import java.util.Iterator;
43import java.util.LinkedList;
qqzhou8c5b0a32013-07-22 15:31:03 +080044import java.util.Locale;
John Reckb8b2af82011-05-20 15:58:33 -070045import java.util.WeakHashMap;
The Android Open Source Project0c908882009-03-03 19:32:16 -080046
Bijan Amirzada9b1e9882014-02-26 17:15:46 -080047import org.codeaurora.swe.AutoFillProfile;
48import org.codeaurora.swe.CookieManager;
49import org.codeaurora.swe.GeolocationPermissions;
50import org.codeaurora.swe.WebSettings.LayoutAlgorithm;
51import org.codeaurora.swe.WebSettings.PluginState;
52import org.codeaurora.swe.WebSettings.TextSize;
53import org.codeaurora.swe.WebSettings.ZoomDensity;
54import org.codeaurora.swe.WebSettings;
55import org.codeaurora.swe.WebView;
Vivek Sekhare8a8ec22014-07-10 14:52:43 -070056import org.codeaurora.swe.WebViewDatabase;
John Reck35e9dd62011-04-25 09:01:54 -070057/**
58 * Class for managing settings
The Android Open Source Project0c908882009-03-03 19:32:16 -080059 */
John Reck35e9dd62011-04-25 09:01:54 -070060public class BrowserSettings implements OnSharedPreferenceChangeListener,
61 PreferenceKeys {
Andrei Popescu01068702009-08-03 16:03:24 +010062
John Reck35e9dd62011-04-25 09:01:54 -070063 // TODO: Do something with this UserAgent stuff
John Reck7fd1e8f2011-04-27 18:22:57 -070064 private static final String DESKTOP_USERAGENT = "Mozilla/5.0 (X11; " +
65 "Linux x86_64) AppleWebKit/534.24 (KHTML, like Gecko) " +
66 "Chrome/11.0.696.34 Safari/534.24";
The Android Open Source Project0c908882009-03-03 19:32:16 -080067
68 private static final String IPHONE_USERAGENT = "Mozilla/5.0 (iPhone; U; " +
John Reck35e9dd62011-04-25 09:01:54 -070069 "CPU iPhone OS 4_0 like Mac OS X; en-us) AppleWebKit/532.9 " +
70 "(KHTML, like Gecko) Version/4.0.5 Mobile/8A293 Safari/6531.22.7";
Bart Searsf6915fb2010-07-08 19:58:22 -070071
72 private static final String IPAD_USERAGENT = "Mozilla/5.0 (iPad; U; " +
John Reck35e9dd62011-04-25 09:01:54 -070073 "CPU OS 3_2 like Mac OS X; en-us) AppleWebKit/531.21.10 " +
74 "(KHTML, like Gecko) Version/4.0.4 Mobile/7B367 Safari/531.21.10";
Bart Searsf6915fb2010-07-08 19:58:22 -070075
76 private static final String FROYO_USERAGENT = "Mozilla/5.0 (Linux; U; " +
John Reck35e9dd62011-04-25 09:01:54 -070077 "Android 2.2; en-us; Nexus One Build/FRF91) AppleWebKit/533.1 " +
78 "(KHTML, like Gecko) Version/4.0 Mobile Safari/533.1";
The Android Open Source Project0c908882009-03-03 19:32:16 -080079
John Reck7fd1e8f2011-04-27 18:22:57 -070080 private static final String HONEYCOMB_USERAGENT = "Mozilla/5.0 (Linux; U; " +
81 "Android 3.1; en-us; Xoom Build/HMJ25) AppleWebKit/534.13 " +
82 "(KHTML, like Gecko) Version/4.0 Safari/534.13";
83
John Reck35e9dd62011-04-25 09:01:54 -070084 private static final String USER_AGENTS[] = { null,
85 DESKTOP_USERAGENT,
86 IPHONE_USERAGENT,
87 IPAD_USERAGENT,
John Reck7fd1e8f2011-04-27 18:22:57 -070088 FROYO_USERAGENT,
89 HONEYCOMB_USERAGENT,
John Reck35e9dd62011-04-25 09:01:54 -070090 };
The Android Open Source Project0c908882009-03-03 19:32:16 -080091
qqzhoue6ff8b42013-07-23 17:28:48 +080092 private static final String TAG = "BrowserSettings";
John Reck8fc22a12011-06-16 14:57:41 -070093 // The minimum min font size
94 // Aka, the lower bounds for the min font size range
95 // which is 1:5..24
96 private static final int MIN_FONT_SIZE_OFFSET = 5;
John Reck7dc444b2011-06-16 17:44:29 -070097 // The initial value in the text zoom range
98 // This is what represents 100% in the SeekBarPreference range
99 private static final int TEXT_ZOOM_START_VAL = 10;
100 // The size of a single step in the text zoom range, in percent
101 private static final int TEXT_ZOOM_STEP = 5;
Mangesh Ghiware67f45c22011-10-12 14:43:32 -0700102 // The initial value in the double tap zoom range
103 // This is what represents 100% in the SeekBarPreference range
104 private static final int DOUBLE_TAP_ZOOM_START_VAL = 5;
105 // The size of a single step in the double tap zoom range, in percent
106 private static final int DOUBLE_TAP_ZOOM_STEP = 5;
John Reck8fc22a12011-06-16 14:57:41 -0700107
John Reck35e9dd62011-04-25 09:01:54 -0700108 private static BrowserSettings sInstance;
Jeff Davidson43610292010-07-16 16:03:58 -0700109
John Reck35e9dd62011-04-25 09:01:54 -0700110 private Context mContext;
111 private SharedPreferences mPrefs;
112 private LinkedList<WeakReference<WebSettings>> mManagedSettings;
Michael Kolb8233fac2010-10-26 16:08:53 -0700113 private Controller mController;
John Reck35e9dd62011-04-25 09:01:54 -0700114 private WebStorageSizeManager mWebStorageSizeManager;
115 private AutofillHandler mAutofillHandler;
John Reckb8b2af82011-05-20 15:58:33 -0700116 private WeakHashMap<WebSettings, String> mCustomUserAgents;
Ben Murdochaaa1f372011-07-25 15:40:58 +0100117 private static boolean sInitialized = false;
John Reckc477e712011-08-17 11:27:15 -0700118 private boolean mNeedsSharedSync = true;
John Reck5ba3c762011-09-14 15:00:15 -0700119 private float mFontSizeMult = 1.0f;
Tarun Nainanic8e6dda2014-04-17 13:11:25 -0700120 private boolean enableWideViewport = true;
John Reck78a6a1d2011-07-21 13:54:03 -0700121
Victoria Lease96497832012-03-23 14:19:56 -0700122 // Current state of network-dependent settings
123 private boolean mLinkPrefetchAllowed = true;
124
John Reck78a6a1d2011-07-21 13:54:03 -0700125 // Cached values
126 private int mPageCacheCapacity = 1;
127 private String mAppCachePath;
The Android Open Source Project0c908882009-03-03 19:32:16 -0800128
John Reck35e9dd62011-04-25 09:01:54 -0700129 // Cached settings
130 private SearchEngine mSearchEngine;
The Android Open Source Project0c908882009-03-03 19:32:16 -0800131
Ben Murdochaaa1f372011-07-25 15:40:58 +0100132 private static String sFactoryResetUrl;
133
Bijan Amirzada3bb46302014-06-17 16:31:31 -0700134 public static synchronized void initialize(final Context context) {
135 if (sInstance == null)
136 sInstance = new BrowserSettings(context);
John Reck35e9dd62011-04-25 09:01:54 -0700137 }
The Android Open Source Project0c908882009-03-03 19:32:16 -0800138
Vivek Sekhar6f4f82a2014-03-21 19:24:51 -0700139 public static BrowserSettings getInstance() {
John Reck35e9dd62011-04-25 09:01:54 -0700140 return sInstance;
141 }
Ben Murdochef671652010-11-25 17:17:58 +0000142
John Reck35e9dd62011-04-25 09:01:54 -0700143 private BrowserSettings(Context context) {
Ben Murdoch914c5592011-08-01 13:58:47 +0100144 mContext = context.getApplicationContext();
John Reck35e9dd62011-04-25 09:01:54 -0700145 mPrefs = PreferenceManager.getDefaultSharedPreferences(mContext);
146 mAutofillHandler = new AutofillHandler(mContext);
147 mManagedSettings = new LinkedList<WeakReference<WebSettings>>();
John Reckb8b2af82011-05-20 15:58:33 -0700148 mCustomUserAgents = new WeakHashMap<WebSettings, String>();
John Reckcadae722011-07-25 11:36:17 -0700149 BackgroundHandler.execute(mSetup);
John Reck35e9dd62011-04-25 09:01:54 -0700150 }
151
152 public void setController(Controller controller) {
153 mController = controller;
John Reckc477e712011-08-17 11:27:15 -0700154 if (sInitialized) {
155 syncSharedSettings();
156 }
Ben Murdochef671652010-11-25 17:17:58 +0000157 }
158
Bijan Amirzada9b1e9882014-02-26 17:15:46 -0800159 public void startManagingSettings(final WebSettings settings) {
Jonathan Dixone1d6dfc2012-12-17 13:39:17 -0800160
John Reckc477e712011-08-17 11:27:15 -0700161 if (mNeedsSharedSync) {
162 syncSharedSettings();
163 }
Jonathan Dixone1d6dfc2012-12-17 13:39:17 -0800164
John Reck35e9dd62011-04-25 09:01:54 -0700165 synchronized (mManagedSettings) {
Jonathan Dixone1d6dfc2012-12-17 13:39:17 -0800166 syncStaticSettings(settings);
167 syncSetting(settings);
John Reck35e9dd62011-04-25 09:01:54 -0700168 mManagedSettings.add(new WeakReference<WebSettings>(settings));
The Android Open Source Project0c908882009-03-03 19:32:16 -0800169 }
170 }
171
John Reckd1d87312012-03-08 13:25:00 -0800172 public void stopManagingSettings(WebSettings settings) {
173 Iterator<WeakReference<WebSettings>> iter = mManagedSettings.iterator();
174 while (iter.hasNext()) {
175 WeakReference<WebSettings> ref = iter.next();
176 if (ref.get() == settings) {
177 iter.remove();
178 return;
179 }
180 }
181 }
182
John Reckcadae722011-07-25 11:36:17 -0700183 private Runnable mSetup = new Runnable() {
John Reck78a6a1d2011-07-21 13:54:03 -0700184
185 @Override
186 public void run() {
John Reck5ba3c762011-09-14 15:00:15 -0700187 DisplayMetrics metrics = mContext.getResources().getDisplayMetrics();
188 mFontSizeMult = metrics.scaledDensity / metrics.density;
John Reck78a6a1d2011-07-21 13:54:03 -0700189 // the cost of one cached page is ~3M (measured using nytimes.com). For
190 // low end devices, we only cache one page. For high end devices, we try
191 // to cache more pages, currently choose 5.
Bijan Amirzada9b1e9882014-02-26 17:15:46 -0800192
193 // SWE_TODO : assume a high-memory device
194 //if (ActivityManager.staticGetMemoryClass() > 16) {
John Reck78a6a1d2011-07-21 13:54:03 -0700195 mPageCacheCapacity = 5;
Bijan Amirzada9b1e9882014-02-26 17:15:46 -0800196 //}
John Reck78a6a1d2011-07-21 13:54:03 -0700197 mWebStorageSizeManager = new WebStorageSizeManager(mContext,
198 new WebStorageSizeManager.StatFsDiskInfo(getAppCachePath()),
199 new WebStorageSizeManager.WebKitAppCacheInfo(getAppCachePath()));
John Reck276b1352011-09-02 15:47:33 -0700200 // Workaround b/5254577
201 mPrefs.registerOnSharedPreferenceChangeListener(BrowserSettings.this);
John Reck78a6a1d2011-07-21 13:54:03 -0700202 if (Build.VERSION.CODENAME.equals("REL")) {
203 // This is a release build, always startup with debug disabled
204 setDebugEnabled(false);
205 }
206 if (mPrefs.contains(PREF_TEXT_SIZE)) {
207 /*
208 * Update from TextSize enum to zoom percent
209 * SMALLEST is 50%
210 * SMALLER is 75%
211 * NORMAL is 100%
212 * LARGER is 150%
213 * LARGEST is 200%
214 */
215 switch (getTextSize()) {
216 case SMALLEST:
217 setTextZoom(50);
218 break;
219 case SMALLER:
220 setTextZoom(75);
221 break;
222 case LARGER:
223 setTextZoom(150);
224 break;
225 case LARGEST:
226 setTextZoom(200);
227 break;
228 }
229 mPrefs.edit().remove(PREF_TEXT_SIZE).apply();
230 }
Ben Murdochaaa1f372011-07-25 15:40:58 +0100231
qqzhou8c5b0a32013-07-22 15:31:03 +0800232 // add for carrier homepage feature
Bijan Amirzadae75909d2014-05-06 14:18:54 -0700233 sFactoryResetUrl = mContext.getResources().getString(R.string.homepage_base);
qqzhou8c5b0a32013-07-22 15:31:03 +0800234
kaiyizbf086ea2013-08-02 11:03:58 +0800235 if (!mPrefs.contains(PREF_DEFAULT_TEXT_ENCODING)) {
Bijan Amirzadae75909d2014-05-06 14:18:54 -0700236 mPrefs.edit().putString(PREF_DEFAULT_TEXT_ENCODING, "UTF-8").apply();
kaiyizbf086ea2013-08-02 11:03:58 +0800237 }
Bijan Amirzadae75909d2014-05-06 14:18:54 -0700238
Ben Murdochaaa1f372011-07-25 15:40:58 +0100239 if (sFactoryResetUrl.indexOf("{CID}") != -1) {
240 sFactoryResetUrl = sFactoryResetUrl.replace("{CID}",
241 BrowserProvider.getClientId(mContext.getContentResolver()));
242 }
243
Ben Murdochaaa1f372011-07-25 15:40:58 +0100244 synchronized (BrowserSettings.class) {
245 sInitialized = true;
246 BrowserSettings.class.notifyAll();
John Reck78a6a1d2011-07-21 13:54:03 -0700247 }
248 }
249 };
250
Ben Murdochaaa1f372011-07-25 15:40:58 +0100251 private static void requireInitialization() {
252 synchronized (BrowserSettings.class) {
253 while (!sInitialized) {
John Reck78a6a1d2011-07-21 13:54:03 -0700254 try {
Ben Murdochaaa1f372011-07-25 15:40:58 +0100255 BrowserSettings.class.wait();
John Reck78a6a1d2011-07-21 13:54:03 -0700256 } catch (InterruptedException e) {
257 }
258 }
259 }
260 }
261
The Android Open Source Project0c908882009-03-03 19:32:16 -0800262 /**
John Reck35e9dd62011-04-25 09:01:54 -0700263 * Syncs all the settings that have a Preference UI
The Android Open Source Project0c908882009-03-03 19:32:16 -0800264 */
Jonathan Dixone1d6dfc2012-12-17 13:39:17 -0800265 private void syncSetting(WebSettings settings) {
John Reck35e9dd62011-04-25 09:01:54 -0700266 settings.setGeolocationEnabled(enableGeolocation());
267 settings.setJavaScriptEnabled(enableJavascript());
268 settings.setLightTouchEnabled(enableLightTouch());
269 settings.setNavDump(enableNavDump());
John Reck35e9dd62011-04-25 09:01:54 -0700270 settings.setDefaultTextEncodingName(getDefaultTextEncoding());
271 settings.setDefaultZoom(getDefaultZoom());
272 settings.setMinimumFontSize(getMinimumFontSize());
273 settings.setMinimumLogicalFontSize(getMinimumFontSize());
John Reck7dc444b2011-06-16 17:44:29 -0700274 settings.setTextZoom(getTextZoom());
John Reck35e9dd62011-04-25 09:01:54 -0700275 settings.setLayoutAlgorithm(getLayoutAlgorithm());
Steve Blockdc657fa2011-08-03 19:27:13 +0100276 settings.setJavaScriptCanOpenWindowsAutomatically(!blockPopupWindows());
John Reck35e9dd62011-04-25 09:01:54 -0700277 settings.setLoadsImagesAutomatically(loadImages());
278 settings.setLoadWithOverviewMode(loadPageInOverviewMode());
279 settings.setSavePassword(rememberPasswords());
280 settings.setSaveFormData(saveFormdata());
281 settings.setUseWideViewPort(isWideViewport());
Panos Thomasb10bbda2014-06-23 10:18:36 -0700282 settings.setDoNotTrack(doNotTrack());
Bijan Amirzadae75909d2014-05-06 14:18:54 -0700283 setUserAgent(settings);
John Reck2fd9d0e2011-07-15 11:13:48 -0700284
Bijan Amirzada9b1e9882014-02-26 17:15:46 -0800285 WebSettings settingsClassic = (WebSettings) settings;
Jonathan Dixone1d6dfc2012-12-17 13:39:17 -0800286 settingsClassic.setHardwareAccelSkiaEnabled(isSkiaHardwareAccelerated());
287 settingsClassic.setShowVisualIndicator(enableVisualIndicator());
288 settingsClassic.setForceUserScalable(forceEnableUserScalable());
289 settingsClassic.setDoubleTapZoom(getDoubleTapZoom());
290 settingsClassic.setAutoFillEnabled(isAutofillEnabled());
Jonathan Dixone1d6dfc2012-12-17 13:39:17 -0800291
John Reckea17e782011-10-27 17:15:59 -0700292 boolean useInverted = useInvertedRendering();
Jonathan Dixone1d6dfc2012-12-17 13:39:17 -0800293 settingsClassic.setProperty(WebViewProperties.gfxInvertedScreen,
John Reckea17e782011-10-27 17:15:59 -0700294 useInverted ? "true" : "false");
295 if (useInverted) {
Jonathan Dixone1d6dfc2012-12-17 13:39:17 -0800296 settingsClassic.setProperty(WebViewProperties.gfxInvertedScreenContrast,
John Reckea17e782011-10-27 17:15:59 -0700297 Float.toString(getInvertedContrast()));
298 }
Nicolas Roard5d513102011-08-03 15:35:34 -0700299
John Reckea17e782011-10-27 17:15:59 -0700300 if (isDebugEnabled()) {
Jonathan Dixone1d6dfc2012-12-17 13:39:17 -0800301 settingsClassic.setProperty(WebViewProperties.gfxEnableCpuUploadPath,
John Reckea17e782011-10-27 17:15:59 -0700302 enableCpuUploadPath() ? "true" : "false");
303 }
Victoria Lease96497832012-03-23 14:19:56 -0700304
Jonathan Dixone1d6dfc2012-12-17 13:39:17 -0800305 settingsClassic.setLinkPrefetchEnabled(mLinkPrefetchAllowed);
Ben Murdochef671652010-11-25 17:17:58 +0000306 }
The Android Open Source Project0c908882009-03-03 19:32:16 -0800307
Bijan Amirzadae75909d2014-05-06 14:18:54 -0700308 private void setUserAgent(WebSettings settings){
309 String ua = mContext.getResources().getString(R.string.def_useragent);
310
311 if (!TextUtils.isEmpty(ua))
312 ua = constructUserAgent(ua);
313
314 if (TextUtils.isEmpty(ua))
315 ua = mCustomUserAgents.get(settings);
316
317 if (!TextUtils.isEmpty(ua)){
318 settings.setUserAgentString(ua);
319 } else {
320 settings.setUserAgentString(USER_AGENTS[getUserAgent()]);
321 }
322 }
323
324 private String constructUserAgent(String userAgent) {
325 try {
326 userAgent = userAgent.replaceAll("<%build_model>", Build.MODEL);
327 userAgent = userAgent.replaceAll("<%build_version>", Build.VERSION.RELEASE);
328 userAgent = userAgent.replaceAll("<%build_id>", Build.ID);
329 userAgent = userAgent.replaceAll("<%language>", Locale.getDefault().getLanguage());
330 userAgent = userAgent.replaceAll("<%country>", Locale.getDefault().getCountry());
331 return userAgent;
332 } catch (Exception ex) {
333 return null;
334 }
335 }
336
John Reck35e9dd62011-04-25 09:01:54 -0700337 /**
338 * Syncs all the settings that have no UI
339 * These cannot change, so we only need to set them once per WebSettings
340 */
Jonathan Dixone1d6dfc2012-12-17 13:39:17 -0800341 private void syncStaticSettings(WebSettings settings) {
John Reck35e9dd62011-04-25 09:01:54 -0700342 settings.setDefaultFontSize(16);
343 settings.setDefaultFixedFontSize(13);
Ben Murdochef671652010-11-25 17:17:58 +0000344
John Reck35e9dd62011-04-25 09:01:54 -0700345 // WebView inside Browser doesn't want initial focus to be set.
346 settings.setNeedInitialFocus(false);
347 // Browser supports multiple windows
348 settings.setSupportMultipleWindows(true);
349 // enable smooth transition for better performance during panning or
350 // zooming
351 settings.setEnableSmoothTransition(true);
352 // disable content url access
Bijan Amirzada59d4a342014-03-27 13:20:12 -0700353 settings.setAllowContentAccess(true);
John Reck35e9dd62011-04-25 09:01:54 -0700354
355 // HTML5 API flags
356 settings.setAppCacheEnabled(true);
357 settings.setDatabaseEnabled(true);
358 settings.setDomStorageEnabled(true);
John Reck35e9dd62011-04-25 09:01:54 -0700359
360 // HTML5 configuration parametersettings.
John Reck78a6a1d2011-07-21 13:54:03 -0700361 settings.setAppCacheMaxSize(getWebStorageSizeManager().getAppCacheMaxSize());
John Reck35e9dd62011-04-25 09:01:54 -0700362 settings.setAppCachePath(getAppCachePath());
363 settings.setDatabasePath(mContext.getDir("databases", 0).getPath());
364 settings.setGeolocationDatabasePath(mContext.getDir("geolocation", 0).getPath());
Selim Gurun37bf0442012-03-29 18:27:04 -0700365 // origin policy for file access
366 settings.setAllowUniversalAccessFromFileURLs(false);
367 settings.setAllowFileAccessFromFileURLs(false);
Jonathan Dixone1d6dfc2012-12-17 13:39:17 -0800368
Bijan Amirzada9b1e9882014-02-26 17:15:46 -0800369 //if (!(settings instanceof WebSettingsClassic)) return;
370 /*
Jonathan Dixone1d6dfc2012-12-17 13:39:17 -0800371
372 WebSettingsClassic settingsClassic = (WebSettingsClassic) settings;
373 settingsClassic.setPageCacheCapacity(getPageCacheCapacity());
374 // WebView should be preserving the memory as much as possible.
375 // However, apps like browser wish to turn on the performance mode which
376 // would require more memory.
377 // TODO: We need to dynamically allocate/deallocate temporary memory for
378 // apps which are trying to use minimal memory. Currently, double
379 // buffering is always turned on, which is unnecessary.
380 settingsClassic.setProperty(WebViewProperties.gfxUseMinimalMemory, "false");
381 settingsClassic.setWorkersEnabled(true); // This only affects V8.
Bijan Amirzada9b1e9882014-02-26 17:15:46 -0800382 */
John Reck35e9dd62011-04-25 09:01:54 -0700383 }
384
385 private void syncSharedSettings() {
John Reckc477e712011-08-17 11:27:15 -0700386 mNeedsSharedSync = false;
Axesh R. Ajmera579c70c2014-04-17 13:24:56 -0700387 CookieManager.getInstance().setAcceptCookie(acceptCookies());
388
John Reck35e9dd62011-04-25 09:01:54 -0700389 if (mController != null) {
390 mController.setShouldShowErrorConsole(enableJavascriptConsole());
Shimeng (Simon) Wange83e9062010-03-29 16:13:09 -0700391 }
John Reck35e9dd62011-04-25 09:01:54 -0700392 }
Ramanan Rajeswarandd4f4292009-03-24 20:41:19 -0700393
John Reck35e9dd62011-04-25 09:01:54 -0700394 private void syncManagedSettings() {
395 syncSharedSettings();
396 synchronized (mManagedSettings) {
397 Iterator<WeakReference<WebSettings>> iter = mManagedSettings.iterator();
398 while (iter.hasNext()) {
399 WeakReference<WebSettings> ref = iter.next();
Bijan Amirzada9b1e9882014-02-26 17:15:46 -0800400 WebSettings settings = (WebSettings)ref.get();
John Reck35e9dd62011-04-25 09:01:54 -0700401 if (settings == null) {
402 iter.remove();
403 continue;
404 }
405 syncSetting(settings);
Ben Murdochef671652010-11-25 17:17:58 +0000406 }
John Reck35e9dd62011-04-25 09:01:54 -0700407 }
408 }
Ben Murdochef671652010-11-25 17:17:58 +0000409
John Reck35e9dd62011-04-25 09:01:54 -0700410 @Override
411 public void onSharedPreferenceChanged(
412 SharedPreferences sharedPreferences, String key) {
413 syncManagedSettings();
414 if (PREF_SEARCH_ENGINE.equals(key)) {
415 updateSearchEngine(false);
Victoria Lease96497832012-03-23 14:19:56 -0700416 } else if (PREF_FULLSCREEN.equals(key)) {
Magnus Hallqvist47ed4b82012-08-31 13:30:39 +0200417 if (mController != null && mController.getUi() != null) {
Michael Kolbc38c6042011-04-27 10:46:06 -0700418 mController.getUi().setFullscreen(useFullscreen());
419 }
Michael Kolb0241e752011-07-07 14:58:50 -0700420 } else if (PREF_ENABLE_QUICK_CONTROLS.equals(key)) {
Magnus Hallqvist47ed4b82012-08-31 13:30:39 +0200421 if (mController != null && mController.getUi() != null) {
Michael Kolb0241e752011-07-07 14:58:50 -0700422 mController.getUi().setUseQuickControls(sharedPreferences.getBoolean(key, false));
423 }
Victoria Lease96497832012-03-23 14:19:56 -0700424 } else if (PREF_LINK_PREFETCH.equals(key)) {
425 updateConnectionType();
Michael Kolbc38c6042011-04-27 10:46:06 -0700426 }
John Reck35e9dd62011-04-25 09:01:54 -0700427 }
428
John Reck961d35d2011-06-23 09:45:54 -0700429 public static String getFactoryResetHomeUrl(Context context) {
Ben Murdochaaa1f372011-07-25 15:40:58 +0100430 requireInitialization();
431 return sFactoryResetUrl;
John Reck35e9dd62011-04-25 09:01:54 -0700432 }
433
434 public LayoutAlgorithm getLayoutAlgorithm() {
435 LayoutAlgorithm layoutAlgorithm = LayoutAlgorithm.NORMAL;
436 if (autofitPages()) {
Tarun Nainani003bec52014-07-02 02:20:34 -0700437 layoutAlgorithm = LayoutAlgorithm.TEXT_AUTOSIZING;
John Reck35e9dd62011-04-25 09:01:54 -0700438 }
439 if (isDebugEnabled()) {
440 if (isSmallScreen()) {
441 layoutAlgorithm = LayoutAlgorithm.SINGLE_COLUMN;
Ben Murdochef671652010-11-25 17:17:58 +0000442 } else {
John Reck35e9dd62011-04-25 09:01:54 -0700443 if (isNormalLayout()) {
444 layoutAlgorithm = LayoutAlgorithm.NORMAL;
445 } else {
446 layoutAlgorithm = LayoutAlgorithm.NARROW_COLUMNS;
447 }
Ben Murdochef671652010-11-25 17:17:58 +0000448 }
John Reck35e9dd62011-04-25 09:01:54 -0700449 }
450 return layoutAlgorithm;
451 }
Ben Murdochef671652010-11-25 17:17:58 +0000452
John Reck35e9dd62011-04-25 09:01:54 -0700453 public int getPageCacheCapacity() {
John Reck78a6a1d2011-07-21 13:54:03 -0700454 requireInitialization();
455 return mPageCacheCapacity;
The Android Open Source Project0c908882009-03-03 19:32:16 -0800456 }
457
John Reck35e9dd62011-04-25 09:01:54 -0700458 public WebStorageSizeManager getWebStorageSizeManager() {
John Reck78a6a1d2011-07-21 13:54:03 -0700459 requireInitialization();
John Reck35e9dd62011-04-25 09:01:54 -0700460 return mWebStorageSizeManager;
461 }
462
John Reck35e9dd62011-04-25 09:01:54 -0700463 private String getAppCachePath() {
John Reck78a6a1d2011-07-21 13:54:03 -0700464 if (mAppCachePath == null) {
465 mAppCachePath = mContext.getDir("appcache", 0).getPath();
466 }
467 return mAppCachePath;
John Reck35e9dd62011-04-25 09:01:54 -0700468 }
469
470 private void updateSearchEngine(boolean force) {
471 String searchEngineName = getSearchEngineName();
472 if (force || mSearchEngine == null ||
473 !mSearchEngine.getName().equals(searchEngineName)) {
John Reck35e9dd62011-04-25 09:01:54 -0700474 mSearchEngine = SearchEngines.get(mContext, searchEngineName);
Narayan Kamath5119edd2011-02-23 15:49:17 +0000475 }
476 }
477
Bjorn Bringertd69f51d2010-09-13 14:06:41 +0100478 public SearchEngine getSearchEngine() {
John Reck35e9dd62011-04-25 09:01:54 -0700479 if (mSearchEngine == null) {
480 updateSearchEngine(false);
Ben Murdoch23da30e2010-10-26 15:18:44 +0100481 }
John Reck35e9dd62011-04-25 09:01:54 -0700482 return mSearchEngine;
Ben Murdoch0cb81892010-10-08 12:41:33 +0100483 }
484
John Reck35e9dd62011-04-25 09:01:54 -0700485 public boolean isDebugEnabled() {
John Reckc477e712011-08-17 11:27:15 -0700486 requireInitialization();
John Reck35e9dd62011-04-25 09:01:54 -0700487 return mPrefs.getBoolean(PREF_DEBUG_MENU, false);
Ben Murdoch0cb81892010-10-08 12:41:33 +0100488 }
489
John Reck35e9dd62011-04-25 09:01:54 -0700490 public void setDebugEnabled(boolean value) {
John Reck1da81882011-10-04 17:21:10 -0700491 Editor edit = mPrefs.edit();
492 edit.putBoolean(PREF_DEBUG_MENU, value);
493 if (!value) {
494 // Reset to "safe" value
495 edit.putBoolean(PREF_ENABLE_HARDWARE_ACCEL_SKIA, false);
496 }
497 edit.apply();
Ben Murdoch6fa32ba2010-10-20 14:01:25 +0100498 }
499
John Reck35e9dd62011-04-25 09:01:54 -0700500 public void clearCache() {
The Android Open Source Project0c908882009-03-03 19:32:16 -0800501 WebIconDatabase.getInstance().removeAllIcons();
Michael Kolb8233fac2010-10-26 16:08:53 -0700502 if (mController != null) {
503 WebView current = mController.getCurrentWebView();
The Android Open Source Project0c908882009-03-03 19:32:16 -0800504 if (current != null) {
505 current.clearCache(true);
506 }
507 }
508 }
509
John Reck35e9dd62011-04-25 09:01:54 -0700510 public void clearCookies() {
The Android Open Source Project0c908882009-03-03 19:32:16 -0800511 CookieManager.getInstance().removeAllCookie();
512 }
513
John Reck35e9dd62011-04-25 09:01:54 -0700514 public void clearHistory() {
515 ContentResolver resolver = mContext.getContentResolver();
The Android Open Source Project0c908882009-03-03 19:32:16 -0800516 Browser.clearHistory(resolver);
517 Browser.clearSearches(resolver);
518 }
519
John Reck35e9dd62011-04-25 09:01:54 -0700520 public void clearFormData() {
521 WebViewDatabase.getInstance(mContext).clearFormData();
Michael Kolb8233fac2010-10-26 16:08:53 -0700522 if (mController!= null) {
523 WebView currentTopView = mController.getCurrentTopWebView();
Henrik Baard794dc722010-02-19 16:28:06 +0100524 if (currentTopView != null) {
525 currentTopView.clearFormData();
526 }
The Android Open Source Project0c908882009-03-03 19:32:16 -0800527 }
528 }
529
Bijan Amirzada3bbb3a42014-06-17 12:06:18 -0700530 public WebView getTopWebView(){
531 if (mController!= null)
532 return mController.getCurrentTopWebView();
533
534 return null;
535 }
536
John Reck35e9dd62011-04-25 09:01:54 -0700537 public void clearPasswords() {
Panos Thomasfa948b82014-03-09 03:42:42 -0700538 // Clear password store maintained by SWE engine
539 WebSettings settings = null;
540 // find a valid settings object
541 Iterator<WeakReference<WebSettings>> iter = mManagedSettings.iterator();
542 while (iter.hasNext()) {
543 WeakReference<WebSettings> ref = iter.next();
544 settings = (WebSettings)ref.get();
545 if (settings != null) {
546 break;
547 }
548 }
549 if (settings != null) {
Panos Thomasdbaea4e2014-05-22 06:48:47 -0700550 settings.clearPasswords();
Panos Thomasfa948b82014-03-09 03:42:42 -0700551 }
Vivek Sekhare8a8ec22014-07-10 14:52:43 -0700552
553 // Clear passwords in WebView database
554 WebViewDatabase db = WebViewDatabase.getInstance(mContext);
555 db.clearHttpAuthUsernamePassword();
The Android Open Source Project0c908882009-03-03 19:32:16 -0800556 }
557
John Reck35e9dd62011-04-25 09:01:54 -0700558 public void clearDatabases() {
Andrei Popescu824faeb2009-07-21 18:24:06 +0100559 WebStorage.getInstance().deleteAllData();
Steve Blockf344d032009-07-30 10:50:45 +0100560 }
561
John Reck35e9dd62011-04-25 09:01:54 -0700562 public void clearLocationAccess() {
Steve Blockf344d032009-07-30 10:50:45 +0100563 GeolocationPermissions.getInstance().clearAll();
Nicolas Roard78a98e42009-05-11 13:34:17 +0100564 }
565
John Reck35e9dd62011-04-25 09:01:54 -0700566 public void resetDefaultPreferences() {
John Reckbd315192011-07-29 10:05:47 -0700567 mPrefs.edit()
568 .clear()
John Reckbd315192011-07-29 10:05:47 -0700569 .apply();
Björn Isakssonc885a242012-06-05 17:19:04 +0200570 resetCachedValues();
John Reck35e9dd62011-04-25 09:01:54 -0700571 syncManagedSettings();
Grace Klobaf2c5c1b2009-05-26 10:48:31 -0700572 }
573
Björn Isakssonc885a242012-06-05 17:19:04 +0200574 private void resetCachedValues() {
575 updateSearchEngine(false);
576 }
577
John Reck35e9dd62011-04-25 09:01:54 -0700578 public AutoFillProfile getAutoFillProfile() {
Bijan Amirzada9b1e9882014-02-26 17:15:46 -0800579 // query the profile from components autofill database 524
580 if (mAutofillHandler.mAutoFillProfile == null &&
581 !mAutofillHandler.mAutoFillActiveProfileId.equals("")) {
582 WebSettings settings = null;
583 // find a valid settings object
584 Iterator<WeakReference<WebSettings>> iter = mManagedSettings.iterator();
585 while (iter.hasNext()) {
586 WeakReference<WebSettings> ref = iter.next();
587 settings = (WebSettings)ref.get();
588 if (settings != null) {
589 break;
590 }
591 }
592 if (settings != null) {
593 AutoFillProfile profile =
594 settings.getAutoFillProfile(mAutofillHandler.mAutoFillActiveProfileId);
595 mAutofillHandler.setAutoFillProfile(profile);
596 }
597 }
John Reck35e9dd62011-04-25 09:01:54 -0700598 return mAutofillHandler.getAutoFillProfile();
The Android Open Source Project0c908882009-03-03 19:32:16 -0800599 }
600
Bijan Amirzada9b1e9882014-02-26 17:15:46 -0800601 public String getAutoFillProfileId() {
602 return mAutofillHandler.getAutoFillProfileId();
Shimeng (Simon) Wangf7392712010-03-10 16:44:31 -0800603 }
604
Bijan Amirzada9b1e9882014-02-26 17:15:46 -0800605 public void updateAutoFillProfile(AutoFillProfile profile) {
606 syncAutoFillProfile(profile);
607 }
608
609 private void syncAutoFillProfile(AutoFillProfile profile) {
610 synchronized (mManagedSettings) {
611 Iterator<WeakReference<WebSettings>> iter = mManagedSettings.iterator();
612 while (iter.hasNext()) {
613 WeakReference<WebSettings> ref = iter.next();
614 WebSettings settings = (WebSettings)ref.get();
615 if (settings == null) {
616 iter.remove();
617 continue;
618 }
619 // update the profile only once.
620 settings.setAutoFillProfile(profile);
621 // Now we should have the guid
622 mAutofillHandler.setAutoFillProfile(profile);
623 break;
624 }
625 }
626 }
John Reck35e9dd62011-04-25 09:01:54 -0700627 public void toggleDebugSettings() {
628 setDebugEnabled(!isDebugEnabled());
The Android Open Source Project0c908882009-03-03 19:32:16 -0800629 }
Ben Murdoch0cb81892010-10-08 12:41:33 +0100630
John Reckb8b2af82011-05-20 15:58:33 -0700631 public boolean hasDesktopUseragent(WebView view) {
632 return view != null && mCustomUserAgents.get(view.getSettings()) != null;
633 }
634
635 public void toggleDesktopUseragent(WebView view) {
John Reckb0a86db2011-05-24 14:05:58 -0700636 if (view == null) {
637 return;
638 }
John Reckb8b2af82011-05-20 15:58:33 -0700639 WebSettings settings = view.getSettings();
640 if (mCustomUserAgents.get(settings) != null) {
641 mCustomUserAgents.remove(settings);
Bijan Amirzadae75909d2014-05-06 14:18:54 -0700642 setUserAgent(settings);
John Reckb8b2af82011-05-20 15:58:33 -0700643 } else {
644 mCustomUserAgents.put(settings, DESKTOP_USERAGENT);
645 settings.setUserAgentString(DESKTOP_USERAGENT);
646 }
647 }
648
John Reck7dc444b2011-06-16 17:44:29 -0700649 public static int getAdjustedMinimumFontSize(int rawValue) {
650 rawValue++; // Preference starts at 0, min font at 1
651 if (rawValue > 1) {
652 rawValue += (MIN_FONT_SIZE_OFFSET - 2);
653 }
654 return rawValue;
655 }
656
John Reck5ba3c762011-09-14 15:00:15 -0700657 public int getAdjustedTextZoom(int rawValue) {
John Reck7dc444b2011-06-16 17:44:29 -0700658 rawValue = (rawValue - TEXT_ZOOM_START_VAL) * TEXT_ZOOM_STEP;
John Reck5ba3c762011-09-14 15:00:15 -0700659 return (int) ((rawValue + 100) * mFontSizeMult);
John Reck7dc444b2011-06-16 17:44:29 -0700660 }
661
662 static int getRawTextZoom(int percent) {
663 return (percent - 100) / TEXT_ZOOM_STEP + TEXT_ZOOM_START_VAL;
664 }
665
Mangesh Ghiware67f45c22011-10-12 14:43:32 -0700666 public int getAdjustedDoubleTapZoom(int rawValue) {
667 rawValue = (rawValue - DOUBLE_TAP_ZOOM_START_VAL) * DOUBLE_TAP_ZOOM_STEP;
668 return (int) ((rawValue + 100) * mFontSizeMult);
669 }
670
671 static int getRawDoubleTapZoom(int percent) {
672 return (percent - 100) / DOUBLE_TAP_ZOOM_STEP + DOUBLE_TAP_ZOOM_START_VAL;
673 }
674
John Reckcadae722011-07-25 11:36:17 -0700675 public SharedPreferences getPreferences() {
676 return mPrefs;
677 }
678
Victoria Lease96497832012-03-23 14:19:56 -0700679 // update connectivity-dependent options
680 public void updateConnectionType() {
681 ConnectivityManager cm = (ConnectivityManager)
682 mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
683 String linkPrefetchPreference = getLinkPrefetchEnabled();
684 boolean linkPrefetchAllowed = linkPrefetchPreference.
685 equals(getLinkPrefetchAlwaysPreferenceString(mContext));
686 NetworkInfo ni = cm.getActiveNetworkInfo();
687 if (ni != null) {
688 switch (ni.getType()) {
689 case ConnectivityManager.TYPE_WIFI:
690 case ConnectivityManager.TYPE_ETHERNET:
691 case ConnectivityManager.TYPE_BLUETOOTH:
692 linkPrefetchAllowed |= linkPrefetchPreference.
693 equals(getLinkPrefetchOnWifiOnlyPreferenceString(mContext));
694 break;
695 case ConnectivityManager.TYPE_MOBILE:
696 case ConnectivityManager.TYPE_MOBILE_DUN:
697 case ConnectivityManager.TYPE_MOBILE_MMS:
698 case ConnectivityManager.TYPE_MOBILE_SUPL:
699 case ConnectivityManager.TYPE_WIMAX:
700 default:
701 break;
702 }
703 }
704 if (mLinkPrefetchAllowed != linkPrefetchAllowed) {
705 mLinkPrefetchAllowed = linkPrefetchAllowed;
706 syncManagedSettings();
707 }
708 }
709
luxiaol62677b02013-07-22 07:54:49 +0800710 public String getDownloadPath() {
711 return mPrefs.getString(PREF_DOWNLOAD_PATH,
712 DownloadHandler.getDefaultDownloadPath(mContext));
713 }
John Reck35e9dd62011-04-25 09:01:54 -0700714 // -----------------------------
715 // getter/setters for accessibility_preferences.xml
716 // -----------------------------
Ben Murdoch0cb81892010-10-08 12:41:33 +0100717
John Reck7dc444b2011-06-16 17:44:29 -0700718 @Deprecated
719 private TextSize getTextSize() {
John Reck35e9dd62011-04-25 09:01:54 -0700720 String textSize = mPrefs.getString(PREF_TEXT_SIZE, "NORMAL");
721 return TextSize.valueOf(textSize);
Ben Murdoch23da30e2010-10-26 15:18:44 +0100722 }
723
John Reck35e9dd62011-04-25 09:01:54 -0700724 public int getMinimumFontSize() {
John Reck8fc22a12011-06-16 14:57:41 -0700725 int minFont = mPrefs.getInt(PREF_MIN_FONT_SIZE, 0);
John Reck7dc444b2011-06-16 17:44:29 -0700726 return getAdjustedMinimumFontSize(minFont);
Ben Murdoch0cb81892010-10-08 12:41:33 +0100727 }
728
John Reck92f25f82011-04-26 16:57:10 -0700729 public boolean forceEnableUserScalable() {
730 return mPrefs.getBoolean(PREF_FORCE_USERSCALABLE, false);
731 }
732
John Reck7dc444b2011-06-16 17:44:29 -0700733 public int getTextZoom() {
John Reck78a6a1d2011-07-21 13:54:03 -0700734 requireInitialization();
John Reck7dc444b2011-06-16 17:44:29 -0700735 int textZoom = mPrefs.getInt(PREF_TEXT_ZOOM, 10);
736 return getAdjustedTextZoom(textZoom);
737 }
738
739 public void setTextZoom(int percent) {
740 mPrefs.edit().putInt(PREF_TEXT_ZOOM, getRawTextZoom(percent)).apply();
741 }
742
Mangesh Ghiware67f45c22011-10-12 14:43:32 -0700743 public int getDoubleTapZoom() {
744 requireInitialization();
745 int doubleTapZoom = mPrefs.getInt(PREF_DOUBLE_TAP_ZOOM, 5);
746 return getAdjustedDoubleTapZoom(doubleTapZoom);
747 }
748
749 public void setDoubleTapZoom(int percent) {
750 mPrefs.edit().putInt(PREF_DOUBLE_TAP_ZOOM, getRawDoubleTapZoom(percent)).apply();
751 }
752
John Reck35e9dd62011-04-25 09:01:54 -0700753 // -----------------------------
754 // getter/setters for advanced_preferences.xml
755 // -----------------------------
Ben Murdoch23da30e2010-10-26 15:18:44 +0100756
John Reck35e9dd62011-04-25 09:01:54 -0700757 public String getSearchEngineName() {
luxiaol221b3932013-07-19 15:27:57 +0800758 String defaultSearchEngineValue = mContext.getString(R.string.default_search_engine_value);
759 if (defaultSearchEngineValue == null) {
760 defaultSearchEngineValue = SearchEngine.GOOGLE;
761 }
762 return mPrefs.getString(PREF_SEARCH_ENGINE, defaultSearchEngineValue);
Ben Murdoch23da30e2010-10-26 15:18:44 +0100763 }
John Reck63bb6872010-12-01 19:29:32 -0800764
Michael Kolb8d772b02012-01-19 13:56:00 -0800765 public boolean allowAppTabs() {
766 return mPrefs.getBoolean(PREF_ALLOW_APP_TABS, false);
767 }
768
John Reck35e9dd62011-04-25 09:01:54 -0700769 public boolean openInBackground() {
770 return mPrefs.getBoolean(PREF_OPEN_IN_BACKGROUND, false);
John Reck63bb6872010-12-01 19:29:32 -0800771 }
John Reck35e9dd62011-04-25 09:01:54 -0700772
773 public boolean enableJavascript() {
774 return mPrefs.getBoolean(PREF_ENABLE_JAVASCRIPT, true);
775 }
776
Bijan Amirzada9b1e9882014-02-26 17:15:46 -0800777 public boolean enableMemoryMonitor() {
778 return mPrefs.getBoolean(PREF_ENABLE_MEMORY_MONITOR, true);
779 }
780
John Reck35e9dd62011-04-25 09:01:54 -0700781 // TODO: Cache
John Reck35e9dd62011-04-25 09:01:54 -0700782 public ZoomDensity getDefaultZoom() {
783 String zoom = mPrefs.getString(PREF_DEFAULT_ZOOM, "MEDIUM");
Tarun Nainanic8e6dda2014-04-17 13:11:25 -0700784 ZoomDensity zoomDensity = ZoomDensity.valueOf(zoom);
785 //SWE: If zoomDensity is not MEDIUM, set enableWideViewport to false.
786 if(zoomDensity != ZoomDensity.MEDIUM)
787 enableWideViewport = false;
788 else
789 enableWideViewport = true;
790 return zoomDensity;
John Reck35e9dd62011-04-25 09:01:54 -0700791 }
792
793 public boolean loadPageInOverviewMode() {
794 return mPrefs.getBoolean(PREF_LOAD_PAGE, true);
795 }
796
797 public boolean autofitPages() {
798 return mPrefs.getBoolean(PREF_AUTOFIT_PAGES, true);
799 }
800
801 public boolean blockPopupWindows() {
802 return mPrefs.getBoolean(PREF_BLOCK_POPUP_WINDOWS, true);
803 }
804
805 public boolean loadImages() {
806 return mPrefs.getBoolean(PREF_LOAD_IMAGES, true);
807 }
808
809 public String getDefaultTextEncoding() {
810 return mPrefs.getString(PREF_DEFAULT_TEXT_ENCODING, null);
811 }
812
813 // -----------------------------
814 // getter/setters for general_preferences.xml
815 // -----------------------------
816
817 public String getHomePage() {
John Reck35e9dd62011-04-25 09:01:54 -0700818 return mPrefs.getString(PREF_HOMEPAGE, getFactoryResetHomeUrl(mContext));
819 }
820
821 public void setHomePage(String value) {
822 mPrefs.edit().putString(PREF_HOMEPAGE, value).apply();
823 }
824
825 public boolean isAutofillEnabled() {
826 return mPrefs.getBoolean(PREF_AUTOFILL_ENABLED, true);
827 }
828
829 public void setAutofillEnabled(boolean value) {
830 mPrefs.edit().putBoolean(PREF_AUTOFILL_ENABLED, value).apply();
831 }
832
833 // -----------------------------
834 // getter/setters for debug_preferences.xml
835 // -----------------------------
836
837 public boolean isHardwareAccelerated() {
John Reckf48314f2011-04-27 17:52:17 -0700838 if (!isDebugEnabled()) {
John Reck35e9dd62011-04-25 09:01:54 -0700839 return true;
840 }
841 return mPrefs.getBoolean(PREF_ENABLE_HARDWARE_ACCEL, true);
842 }
843
Derek Sollenberger31adf672011-07-08 11:31:30 -0400844 public boolean isSkiaHardwareAccelerated() {
845 if (!isDebugEnabled()) {
846 return false;
847 }
848 return mPrefs.getBoolean(PREF_ENABLE_HARDWARE_ACCEL_SKIA, false);
849 }
850
John Reck35e9dd62011-04-25 09:01:54 -0700851 public int getUserAgent() {
John Reckf48314f2011-04-27 17:52:17 -0700852 if (!isDebugEnabled()) {
John Reck35e9dd62011-04-25 09:01:54 -0700853 return 0;
854 }
855 return Integer.parseInt(mPrefs.getString(PREF_USER_AGENT, "0"));
856 }
857
858 // -----------------------------
859 // getter/setters for hidden_debug_preferences.xml
860 // -----------------------------
861
862 public boolean enableVisualIndicator() {
863 if (!isDebugEnabled()) {
864 return false;
865 }
866 return mPrefs.getBoolean(PREF_ENABLE_VISUAL_INDICATOR, false);
867 }
868
Teng-Hui Zhu85de57a2011-09-22 15:34:29 -0700869 public boolean enableCpuUploadPath() {
870 if (!isDebugEnabled()) {
Teng-Hui Zhudbe001b2011-09-30 10:37:01 -0700871 return false;
Teng-Hui Zhu85de57a2011-09-22 15:34:29 -0700872 }
Teng-Hui Zhudbe001b2011-09-30 10:37:01 -0700873 return mPrefs.getBoolean(PREF_ENABLE_CPU_UPLOAD_PATH, false);
Teng-Hui Zhu85de57a2011-09-22 15:34:29 -0700874 }
875
John Reck35e9dd62011-04-25 09:01:54 -0700876 public boolean enableJavascriptConsole() {
877 if (!isDebugEnabled()) {
878 return false;
879 }
880 return mPrefs.getBoolean(PREF_JAVASCRIPT_CONSOLE, true);
881 }
882
883 public boolean isSmallScreen() {
884 if (!isDebugEnabled()) {
885 return false;
886 }
887 return mPrefs.getBoolean(PREF_SMALL_SCREEN, false);
888 }
889
890 public boolean isWideViewport() {
891 if (!isDebugEnabled()) {
Tarun Nainanic8e6dda2014-04-17 13:11:25 -0700892 return enableWideViewport;
John Reck35e9dd62011-04-25 09:01:54 -0700893 }
Tarun Nainanic8e6dda2014-04-17 13:11:25 -0700894 return mPrefs.getBoolean(PREF_WIDE_VIEWPORT, enableWideViewport);
John Reck35e9dd62011-04-25 09:01:54 -0700895 }
896
897 public boolean isNormalLayout() {
898 if (!isDebugEnabled()) {
899 return false;
900 }
901 return mPrefs.getBoolean(PREF_NORMAL_LAYOUT, false);
902 }
903
904 public boolean isTracing() {
905 if (!isDebugEnabled()) {
906 return false;
907 }
908 return mPrefs.getBoolean(PREF_ENABLE_TRACING, false);
909 }
910
911 public boolean enableLightTouch() {
912 if (!isDebugEnabled()) {
913 return false;
914 }
915 return mPrefs.getBoolean(PREF_ENABLE_LIGHT_TOUCH, false);
916 }
917
918 public boolean enableNavDump() {
919 if (!isDebugEnabled()) {
920 return false;
921 }
922 return mPrefs.getBoolean(PREF_ENABLE_NAV_DUMP, false);
923 }
924
925 public String getJsEngineFlags() {
926 if (!isDebugEnabled()) {
927 return "";
928 }
929 return mPrefs.getString(PREF_JS_ENGINE_FLAGS, "");
930 }
931
932 // -----------------------------
933 // getter/setters for lab_preferences.xml
934 // -----------------------------
935
936 public boolean useQuickControls() {
937 return mPrefs.getBoolean(PREF_ENABLE_QUICK_CONTROLS, false);
938 }
939
940 public boolean useMostVisitedHomepage() {
John Reck961d35d2011-06-23 09:45:54 -0700941 return HomeProvider.MOST_VISITED.equals(getHomePage());
John Reck35e9dd62011-04-25 09:01:54 -0700942 }
943
Michael Kolbc38c6042011-04-27 10:46:06 -0700944 public boolean useFullscreen() {
945 return mPrefs.getBoolean(PREF_FULLSCREEN, false);
946 }
947
John Reck2fd9d0e2011-07-15 11:13:48 -0700948 public boolean useInvertedRendering() {
949 return mPrefs.getBoolean(PREF_INVERTED, false);
950 }
951
Nicolas Roard5d513102011-08-03 15:35:34 -0700952 public float getInvertedContrast() {
953 return 1 + (mPrefs.getInt(PREF_INVERTED_CONTRAST, 0) / 10f);
954 }
955
John Reck35e9dd62011-04-25 09:01:54 -0700956 // -----------------------------
957 // getter/setters for privacy_security_preferences.xml
958 // -----------------------------
959
960 public boolean showSecurityWarnings() {
961 return mPrefs.getBoolean(PREF_SHOW_SECURITY_WARNINGS, true);
962 }
963
Axesh R. Ajmera2e241242014-05-19 15:53:38 -0700964 public boolean doNotTrack() {
965 return mPrefs.getBoolean(PREF_DO_NOT_TRACK, true);
966 }
967
John Reck35e9dd62011-04-25 09:01:54 -0700968 public boolean acceptCookies() {
969 return mPrefs.getBoolean(PREF_ACCEPT_COOKIES, true);
970 }
971
972 public boolean saveFormdata() {
973 return mPrefs.getBoolean(PREF_SAVE_FORMDATA, true);
974 }
975
976 public boolean enableGeolocation() {
977 return mPrefs.getBoolean(PREF_ENABLE_GEOLOCATION, true);
978 }
979
980 public boolean rememberPasswords() {
981 return mPrefs.getBoolean(PREF_REMEMBER_PASSWORDS, true);
982 }
983
Michael Kolb14612442011-06-24 13:06:29 -0700984 // -----------------------------
985 // getter/setters for bandwidth_preferences.xml
986 // -----------------------------
987
Mathew Inwood467813f2011-09-02 15:43:17 +0100988 public static String getPreloadOnWifiOnlyPreferenceString(Context context) {
989 return context.getResources().getString(R.string.pref_data_preload_value_wifi_only);
Michael Kolb14612442011-06-24 13:06:29 -0700990 }
Mathew Inwood467813f2011-09-02 15:43:17 +0100991
992 public static String getPreloadAlwaysPreferenceString(Context context) {
993 return context.getResources().getString(R.string.pref_data_preload_value_always);
994 }
995
Mathew Inwood825fba72011-10-04 14:52:52 +0100996 private static final String DEAULT_PRELOAD_SECURE_SETTING_KEY =
997 "browser_default_preload_setting";
998
999 public String getDefaultPreloadSetting() {
1000 String preload = Settings.Secure.getString(mContext.getContentResolver(),
1001 DEAULT_PRELOAD_SECURE_SETTING_KEY);
1002 if (preload == null) {
1003 preload = mContext.getResources().getString(R.string.pref_data_preload_default_value);
1004 }
1005 return preload;
Mathew Inwood467813f2011-09-02 15:43:17 +01001006 }
1007
1008 public String getPreloadEnabled() {
1009 return mPrefs.getString(PREF_DATA_PRELOAD, getDefaultPreloadSetting());
1010 }
1011
Victoria Lease96497832012-03-23 14:19:56 -07001012 public static String getLinkPrefetchOnWifiOnlyPreferenceString(Context context) {
1013 return context.getResources().getString(R.string.pref_link_prefetch_value_wifi_only);
1014 }
1015
1016 public static String getLinkPrefetchAlwaysPreferenceString(Context context) {
1017 return context.getResources().getString(R.string.pref_link_prefetch_value_always);
1018 }
1019
1020 private static final String DEFAULT_LINK_PREFETCH_SECURE_SETTING_KEY =
1021 "browser_default_link_prefetch_setting";
1022
1023 public String getDefaultLinkPrefetchSetting() {
1024 String preload = Settings.Secure.getString(mContext.getContentResolver(),
1025 DEFAULT_LINK_PREFETCH_SECURE_SETTING_KEY);
1026 if (preload == null) {
1027 preload = mContext.getResources().getString(R.string.pref_link_prefetch_default_value);
1028 }
1029 return preload;
1030 }
1031
1032 public String getLinkPrefetchEnabled() {
1033 return mPrefs.getString(PREF_LINK_PREFETCH, getDefaultLinkPrefetchSetting());
1034 }
1035
George Mount3636d0a2011-11-21 09:08:21 -08001036 // -----------------------------
1037 // getter/setters for browser recovery
1038 // -----------------------------
1039 /**
1040 * The last time browser was started.
1041 * @return The last browser start time as System.currentTimeMillis. This
1042 * can be 0 if this is the first time or the last tab was closed.
1043 */
1044 public long getLastRecovered() {
1045 return mPrefs.getLong(KEY_LAST_RECOVERED, 0);
1046 }
1047
1048 /**
1049 * Sets the last browser start time.
1050 * @param time The last time as System.currentTimeMillis that the browser
1051 * was started. This should be set to 0 if the last tab is closed.
1052 */
1053 public void setLastRecovered(long time) {
1054 mPrefs.edit()
1055 .putLong(KEY_LAST_RECOVERED, time)
1056 .apply();
1057 }
1058
1059 /**
1060 * Used to determine whether or not the previous browser run crashed. Once
1061 * the previous state has been determined, the value will be set to false
1062 * until a pause is received.
1063 * @return true if the last browser run was paused or false if it crashed.
1064 */
1065 public boolean wasLastRunPaused() {
1066 return mPrefs.getBoolean(KEY_LAST_RUN_PAUSED, false);
1067 }
1068
1069 /**
1070 * Sets whether or not the last run was a pause or crash.
1071 * @param isPaused Set to true When a pause is received or false after
1072 * resuming.
1073 */
1074 public void setLastRunPaused(boolean isPaused) {
1075 mPrefs.edit()
1076 .putBoolean(KEY_LAST_RUN_PAUSED, isPaused)
1077 .apply();
1078 }
The Android Open Source Project0c908882009-03-03 19:32:16 -08001079}