/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.webkit;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Handler;
import android.os.Message;
import android.provider.Settings;
import android.provider.Settings.SettingNotFoundException;
import android.util.EventLog;
import java.util.Locale;
/**
* WebSettings implementation for the WebViewClassic implementation of WebView.
* @hide
*/
public class WebSettingsClassic extends WebSettings {
// TODO: Keep this up to date
private static final String PREVIOUS_VERSION = "4.1.1";
// WebView associated with this WebSettings.
private WebViewClassic mWebView;
// BrowserFrame used to access the native frame pointer.
private BrowserFrame mBrowserFrame;
// Flag to prevent multiple SYNC messages at one time.
private boolean mSyncPending = false;
// Custom handler that queues messages until the WebCore thread is active.
private final EventHandler mEventHandler;
// Private settings so we don't have to go into native code to
// retrieve the values. After setXXX, postSync() needs to be called.
//
// The default values need to match those in WebSettings.cpp
// If the defaults change, please also update the JavaDocs so developers
// know what they are.
private LayoutAlgorithm mLayoutAlgorithm = LayoutAlgorithm.NARROW_COLUMNS;
private Context mContext;
private int mTextSize = 100;
private String mStandardFontFamily = "sans-serif";
private String mFixedFontFamily = "monospace";
private String mSansSerifFontFamily = "sans-serif";
private String mSerifFontFamily = "serif";
private String mCursiveFontFamily = "cursive";
private String mFantasyFontFamily = "fantasy";
private String mDefaultTextEncoding;
private String mUserAgent;
private boolean mUseDefaultUserAgent;
private String mAcceptLanguage;
private int mMinimumFontSize = 8;
private int mMinimumLogicalFontSize = 8;
private int mDefaultFontSize = 16;
private int mDefaultFixedFontSize = 13;
private int mPageCacheCapacity = 0;
private boolean mLoadsImagesAutomatically = true;
private boolean mBlockNetworkImage = false;
private boolean mBlockNetworkLoads;
private boolean mJavaScriptEnabled = false;
private boolean mAllowUniversalAccessFromFileURLs = false;
private boolean mAllowFileAccessFromFileURLs = false;
private boolean mHardwareAccelSkia = false;
private boolean mShowVisualIndicator = false;
private PluginState mPluginState = PluginState.OFF;
private boolean mJavaScriptCanOpenWindowsAutomatically = false;
private boolean mUseDoubleTree = false;
private boolean mUseWideViewport = false;
private boolean mSupportMultipleWindows = false;
private boolean mShrinksStandaloneImagesToFit = false;
private long mMaximumDecodedImageSize = 0; // 0 means default
private boolean mPrivateBrowsingEnabled = false;
private boolean mSyntheticLinksEnabled = true;
// HTML5 API flags
private boolean mAppCacheEnabled = false;
private boolean mDatabaseEnabled = false;
private boolean mDomStorageEnabled = false;
private boolean mWorkersEnabled = false; // only affects V8.
private boolean mGeolocationEnabled = true;
private boolean mXSSAuditorEnabled = false;
private boolean mLinkPrefetchEnabled = false;
// HTML5 configuration parameters
private long mAppCacheMaxSize = Long.MAX_VALUE;
private String mAppCachePath = null;
private String mDatabasePath = "";
// The WebCore DatabaseTracker only allows the database path to be set
// once. Keep track of when the path has been set.
private boolean mDatabasePathHasBeenSet = false;
private String mGeolocationDatabasePath = "";
// Don't need to synchronize the get/set methods as they
// are basic types, also none of these values are used in
// native WebCore code.
private ZoomDensity mDefaultZoom = ZoomDensity.MEDIUM;
private RenderPriority mRenderPriority = RenderPriority.NORMAL;
private int mOverrideCacheMode = LOAD_DEFAULT;
private int mDoubleTapZoom = 100;
private boolean mSaveFormData = true;
private boolean mAutoFillEnabled = false;
private boolean mSavePassword = true;
private boolean mLightTouchEnabled = false;
private boolean mNeedInitialFocus = true;
private boolean mNavDump = false;
private boolean mSupportZoom = true;
private boolean mMediaPlaybackRequiresUserGesture = true;
private boolean mBuiltInZoomControls = false;
private boolean mDisplayZoomControls = true;
private boolean mAllowFileAccess = true;
private boolean mAllowContentAccess = true;
private boolean mLoadWithOverviewMode = false;
private boolean mEnableSmoothTransition = false;
private boolean mForceUserScalable = false;
private boolean mPasswordEchoEnabled = true;
// AutoFill Profile data
public static class AutoFillProfile {
private int mUniqueId;
private String mFullName;
private String mEmailAddress;
private String mCompanyName;
private String mAddressLine1;
private String mAddressLine2;
private String mCity;
private String mState;
private String mZipCode;
private String mCountry;
private String mPhoneNumber;
public AutoFillProfile(int uniqueId, String fullName, String email,
String companyName, String addressLine1, String addressLine2,
String city, String state, String zipCode, String country,
String phoneNumber) {
mUniqueId = uniqueId;
mFullName = fullName;
mEmailAddress = email;
mCompanyName = companyName;
mAddressLine1 = addressLine1;
mAddressLine2 = addressLine2;
mCity = city;
mState = state;
mZipCode = zipCode;
mCountry = country;
mPhoneNumber = phoneNumber;
}
public int getUniqueId() { return mUniqueId; }
public String getFullName() { return mFullName; }
public String getEmailAddress() { return mEmailAddress; }
public String getCompanyName() { return mCompanyName; }
public String getAddressLine1() { return mAddressLine1; }
public String getAddressLine2() { return mAddressLine2; }
public String getCity() { return mCity; }
public String getState() { return mState; }
public String getZipCode() { return mZipCode; }
public String getCountry() { return mCountry; }
public String getPhoneNumber() { return mPhoneNumber; }
}
private AutoFillProfile mAutoFillProfile;
private boolean mUseWebViewBackgroundForOverscroll = true;
// private WebSettings, not accessible by the host activity
static private int mDoubleTapToastCount = 3;
private static final String PREF_FILE = "WebViewSettings";
private static final String DOUBLE_TAP_TOAST_COUNT = "double_tap_toast_count";
// Class to handle messages before WebCore is ready.
private class EventHandler {
// Message id for syncing
static final int SYNC = 0;
// Message id for setting priority
static final int PRIORITY = 1;
// Message id for writing double-tap toast count
static final int SET_DOUBLE_TAP_TOAST_COUNT = 2;
// Actual WebCore thread handler
private Handler mHandler;
private synchronized void createHandler() {
// as mRenderPriority can be set before thread is running, sync up
setRenderPriority();
// create a new handler
mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case SYNC:
synchronized (WebSettingsClassic.this) {
if (mBrowserFrame.mNativeFrame != 0) {
nativeSync(mBrowserFrame.mNativeFrame);
}
mSyncPending = false;
}
break;
case PRIORITY: {
setRenderPriority();
break;
}
case SET_DOUBLE_TAP_TOAST_COUNT: {
SharedPreferences.Editor editor = mContext
.getSharedPreferences(PREF_FILE,
Context.MODE_PRIVATE).edit();
editor.putInt(DOUBLE_TAP_TOAST_COUNT,
mDoubleTapToastCount);
editor.commit();
break;
}
}
}
};
}
private void setRenderPriority() {
synchronized (WebSettingsClassic.this) {
if (mRenderPriority == RenderPriority.NORMAL) {
android.os.Process.setThreadPriority(
android.os.Process.THREAD_PRIORITY_DEFAULT);
} else if (mRenderPriority == RenderPriority.HIGH) {
android.os.Process.setThreadPriority(
android.os.Process.THREAD_PRIORITY_FOREGROUND +
android.os.Process.THREAD_PRIORITY_LESS_FAVORABLE);
} else if (mRenderPriority == RenderPriority.LOW) {
android.os.Process.setThreadPriority(
android.os.Process.THREAD_PRIORITY_BACKGROUND);
}
}
}
/**
* Send a message to the private queue or handler.
*/
private synchronized boolean sendMessage(Message msg) {
if (mHandler != null) {
mHandler.sendMessage(msg);
return true;
} else {
return false;
}
}
}
// User agent strings.
private static final String DESKTOP_USERAGENT = "Mozilla/5.0 (X11; " +
"Linux x86_64) AppleWebKit/534.24 (KHTML, like Gecko) " +
"Chrome/11.0.696.34 Safari/534.24";
private static final String IPHONE_USERAGENT =
"Mozilla/5.0 (iPhone; U; CPU iPhone OS 3_0 like Mac OS X; en-us)"
+ " AppleWebKit/528.18 (KHTML, like Gecko) Version/4.0"
+ " Mobile/7A341 Safari/528.16";
private static Locale sLocale;
private static Object sLockForLocaleSettings;
/**
* Package constructor to prevent clients from creating a new settings
* instance.
*/
WebSettingsClassic(Context context, WebViewClassic webview) {
mEventHandler = new EventHandler();
mContext = context;
mWebView = webview;
mDefaultTextEncoding = context.getString(com.android.internal.
R.string.default_text_encoding);
if (sLockForLocaleSettings == null) {
sLockForLocaleSettings = new Object();
sLocale = Locale.getDefault();
}
mAcceptLanguage = getCurrentAcceptLanguage();
mUserAgent = getCurrentUserAgent();
mUseDefaultUserAgent = true;
mBlockNetworkLoads = mContext.checkPermission(
"android.permission.INTERNET", android.os.Process.myPid(),
android.os.Process.myUid()) != PackageManager.PERMISSION_GRANTED;
// SDK specific settings. See issue 6212665
if (mContext.getApplicationInfo().targetSdkVersion <
Build.VERSION_CODES.JELLY_BEAN) {
mAllowUniversalAccessFromFileURLs = true;
mAllowFileAccessFromFileURLs = true;
}
try {
mPasswordEchoEnabled =
Settings.System.getInt(context.getContentResolver(),
Settings.System.TEXT_SHOW_PASSWORD) != 0;
} catch (SettingNotFoundException e) {
mPasswordEchoEnabled = true;
}
}
private static final String ACCEPT_LANG_FOR_US_LOCALE = "en-US";
/**
* Looks at sLocale and returns current AcceptLanguage String.
* @return Current AcceptLanguage String.
*/
private String getCurrentAcceptLanguage() {
Locale locale;
synchronized(sLockForLocaleSettings) {
locale = sLocale;
}
StringBuilder buffer = new StringBuilder();
addLocaleToHttpAcceptLanguage(buffer, locale);
if (!Locale.US.equals(locale)) {
if (buffer.length() > 0) {
buffer.append(", ");
}
buffer.append(ACCEPT_LANG_FOR_US_LOCALE);
}
return buffer.toString();
}
/**
* Convert obsolete language codes, including Hebrew/Indonesian/Yiddish,
* to new standard.
*/
private static String convertObsoleteLanguageCodeToNew(String langCode) {
if (langCode == null) {
return null;
}
if ("iw".equals(langCode)) {
// Hebrew
return "he";
} else if ("in".equals(langCode)) {
// Indonesian
return "id";
} else if ("ji".equals(langCode)) {
// Yiddish
return "yi";
}
return langCode;
}
private static void addLocaleToHttpAcceptLanguage(StringBuilder builder,
Locale locale) {
String language = convertObsoleteLanguageCodeToNew(locale.getLanguage());
if (language != null) {
builder.append(language);
String country = locale.getCountry();
if (country != null) {
builder.append("-");
builder.append(country);
}
}
}
/**
* Looks at sLocale and mContext and returns current UserAgent String.
* @return Current UserAgent String.
*/
private synchronized String getCurrentUserAgent() {
Locale locale;
synchronized(sLockForLocaleSettings) {
locale = sLocale;
}
return getDefaultUserAgentForLocale(mContext, locale);
}
/**
* Returns the default User-Agent used by a WebView.
* An instance of WebView could use a different User-Agent if a call
* is made to {@link WebSettings#setUserAgent(int)} or
* {@link WebSettings#setUserAgentString(String)}.
*
* @param context a Context object used to access application assets
* @param locale The Locale to use in the User-Agent string.
* @see WebViewFactoryProvider#getDefaultUserAgent(Context)
* @see WebView#getDefaultUserAgent(Context)
*/
public static String getDefaultUserAgentForLocale(Context context, Locale locale) {
StringBuffer buffer = new StringBuffer();
// Add version
final String version = Build.VERSION.RELEASE;
if (version.length() > 0) {
if (Character.isDigit(version.charAt(0))) {
// Release is a version, eg "3.1"
buffer.append(version);
} else {
// Release is a codename, eg "Honeycomb"
// In this case, use the previous release's version
buffer.append(PREVIOUS_VERSION);
}
} else {
// default to "1.0"
buffer.append("1.0");
}
buffer.append("; ");
final String language = locale.getLanguage();
if (language != null) {
buffer.append(convertObsoleteLanguageCodeToNew(language));
final String country = locale.getCountry();
if (country != null) {
buffer.append("-");
buffer.append(country.toLowerCase());
}
} else {
// default to "en"
buffer.append("en");
}
buffer.append(";");
// add the model for the release build
if ("REL".equals(Build.VERSION.CODENAME)) {
final String model = Build.MODEL;
if (model.length() > 0) {
buffer.append(" ");
buffer.append(model);
}
}
final String id = Build.ID;
if (id.length() > 0) {
buffer.append(" Build/");
buffer.append(id);
}
String mobile = context.getResources().getText(
com.android.internal.R.string.web_user_agent_target_content).toString();
final String base = context.getResources().getText(
com.android.internal.R.string.web_user_agent).toString();
return String.format(base, buffer, mobile);
}
/**
* @see android.webkit.WebSettings#setNavDump(boolean)
*/
@Override
@Deprecated
public void setNavDump(boolean enabled) {
mNavDump = enabled;
}
/**
* @see android.webkit.WebSettings#getNavDump()
*/
@Override
@Deprecated
public boolean getNavDump() {
return mNavDump;
}
/**
* @see android.webkit.WebSettings#setSupportZoom(boolean)
*/
@Override
public void setSupportZoom(boolean support) {
mSupportZoom = support;
mWebView.updateMultiTouchSupport(mContext);
}
/**
* @see android.webkit.WebSettings#supportZoom()
*/
@Override
public boolean supportZoom() {
return mSupportZoom;
}
/**
* @see android.webkit.WebSettings#setMediaPlaybackRequiresUserGesture(boolean)
*/
@Override
public void setMediaPlaybackRequiresUserGesture(boolean support) {
if (mMediaPlaybackRequiresUserGesture != support) {
mMediaPlaybackRequiresUserGesture = support;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getMediaPlaybackRequiresUserGesture()
*/
@Override
public boolean getMediaPlaybackRequiresUserGesture() {
return mMediaPlaybackRequiresUserGesture;
}
/**
* @see android.webkit.WebSettings#setBuiltInZoomControls(boolean)
*/
@Override
public void setBuiltInZoomControls(boolean enabled) {
mBuiltInZoomControls = enabled;
mWebView.updateMultiTouchSupport(mContext);
}
/**
* @see android.webkit.WebSettings#getBuiltInZoomControls()
*/
@Override
public boolean getBuiltInZoomControls() {
return mBuiltInZoomControls;
}
/**
* @see android.webkit.WebSettings#setDisplayZoomControls(boolean)
*/
@Override
public void setDisplayZoomControls(boolean enabled) {
mDisplayZoomControls = enabled;
mWebView.updateMultiTouchSupport(mContext);
}
/**
* @see android.webkit.WebSettings#getDisplayZoomControls()
*/
@Override
public boolean getDisplayZoomControls() {
return mDisplayZoomControls;
}
/**
* @see android.webkit.WebSettings#setAllowFileAccess(boolean)
*/
@Override
public void setAllowFileAccess(boolean allow) {
mAllowFileAccess = allow;
}
/**
* @see android.webkit.WebSettings#getAllowFileAccess()
*/
@Override
public boolean getAllowFileAccess() {
return mAllowFileAccess;
}
/**
* @see android.webkit.WebSettings#setAllowContentAccess(boolean)
*/
@Override
public void setAllowContentAccess(boolean allow) {
mAllowContentAccess = allow;
}
/**
* @see android.webkit.WebSettings#getAllowContentAccess()
*/
@Override
public boolean getAllowContentAccess() {
return mAllowContentAccess;
}
/**
* @see android.webkit.WebSettings#setLoadWithOverviewMode(boolean)
*/
@Override
public void setLoadWithOverviewMode(boolean overview) {
mLoadWithOverviewMode = overview;
}
/**
* @see android.webkit.WebSettings#getLoadWithOverviewMode()
*/
@Override
public boolean getLoadWithOverviewMode() {
return mLoadWithOverviewMode;
}
/**
* @see android.webkit.WebSettings#setEnableSmoothTransition(boolean)
*/
@Override
public void setEnableSmoothTransition(boolean enable) {
mEnableSmoothTransition = enable;
}
/**
* @see android.webkit.WebSettings#enableSmoothTransition()
*/
@Override
public boolean enableSmoothTransition() {
return mEnableSmoothTransition;
}
/**
* @see android.webkit.WebSettings#setUseWebViewBackgroundForOverscrollBackground(boolean)
*/
@Override
@Deprecated
public void setUseWebViewBackgroundForOverscrollBackground(boolean view) {
mUseWebViewBackgroundForOverscroll = view;
}
/**
* @see android.webkit.WebSettings#getUseWebViewBackgroundForOverscrollBackground()
*/
@Override
@Deprecated
public boolean getUseWebViewBackgroundForOverscrollBackground() {
return mUseWebViewBackgroundForOverscroll;
}
/**
* @see android.webkit.WebSettings#setSaveFormData(boolean)
*/
@Override
public void setSaveFormData(boolean save) {
mSaveFormData = save;
}
/**
* @see android.webkit.WebSettings#getSaveFormData()
*/
@Override
public boolean getSaveFormData() {
return mSaveFormData && !mPrivateBrowsingEnabled;
}
/**
* @see android.webkit.WebSettings#setSavePassword(boolean)
*/
@Override
public void setSavePassword(boolean save) {
mSavePassword = save;
}
/**
* @see android.webkit.WebSettings#getSavePassword()
*/
@Override
public boolean getSavePassword() {
return mSavePassword;
}
/**
* @see android.webkit.WebSettings#setTextZoom(int)
*/
@Override
public synchronized void setTextZoom(int textZoom) {
if (mTextSize != textZoom) {
mTextSize = textZoom;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getTextZoom()
*/
@Override
public synchronized int getTextZoom() {
return mTextSize;
}
/**
* Set the double-tap zoom of the page in percent. Default is 100.
* @param doubleTapZoom A percent value for increasing or decreasing the double-tap zoom.
*/
public void setDoubleTapZoom(int doubleTapZoom) {
if (mDoubleTapZoom != doubleTapZoom) {
mDoubleTapZoom = doubleTapZoom;
mWebView.updateDoubleTapZoom(doubleTapZoom);
}
}
/**
* Get the double-tap zoom of the page in percent.
* @return A percent value describing the double-tap zoom.
*/
public int getDoubleTapZoom() {
return mDoubleTapZoom;
}
/**
* @see android.webkit.WebSettings#setDefaultZoom(android.webkit.WebSettingsClassic.ZoomDensity)
*/
@Override
public void setDefaultZoom(ZoomDensity zoom) {
if (mDefaultZoom != zoom) {
mDefaultZoom = zoom;
mWebView.adjustDefaultZoomDensity(zoom.value);
}
}
/**
* @see android.webkit.WebSettings#getDefaultZoom()
*/
@Override
public ZoomDensity getDefaultZoom() {
return mDefaultZoom;
}
/**
* @see android.webkit.WebSettings#setLightTouchEnabled(boolean)
*/
@Override
public void setLightTouchEnabled(boolean enabled) {
mLightTouchEnabled = enabled;
}
/**
* @see android.webkit.WebSettings#getLightTouchEnabled()
*/
@Override
public boolean getLightTouchEnabled() {
return mLightTouchEnabled;
}
/**
* @see android.webkit.WebSettings#setUseDoubleTree(boolean)
*/
@Override
@Deprecated
public synchronized void setUseDoubleTree(boolean use) {
return;
}
/**
* @see android.webkit.WebSettings#getUseDoubleTree()
*/
@Override
@Deprecated
public synchronized boolean getUseDoubleTree() {
return false;
}
/**
* @see android.webkit.WebSettings#setUserAgent(int)
*/
@Override
@Deprecated
public synchronized void setUserAgent(int ua) {
String uaString = null;
if (ua == 1) {
if (DESKTOP_USERAGENT.equals(mUserAgent)) {
return; // do nothing
} else {
uaString = DESKTOP_USERAGENT;
}
} else if (ua == 2) {
if (IPHONE_USERAGENT.equals(mUserAgent)) {
return; // do nothing
} else {
uaString = IPHONE_USERAGENT;
}
} else if (ua != 0) {
return; // do nothing
}
setUserAgentString(uaString);
}
/**
* @see android.webkit.WebSettings#getUserAgent()
*/
@Override
@Deprecated
public synchronized int getUserAgent() {
if (DESKTOP_USERAGENT.equals(mUserAgent)) {
return 1;
} else if (IPHONE_USERAGENT.equals(mUserAgent)) {
return 2;
} else if (mUseDefaultUserAgent) {
return 0;
}
return -1;
}
/**
* @see android.webkit.WebSettings#setUseWideViewPort(boolean)
*/
@Override
public synchronized void setUseWideViewPort(boolean use) {
if (mUseWideViewport != use) {
mUseWideViewport = use;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getUseWideViewPort()
*/
@Override
public synchronized boolean getUseWideViewPort() {
return mUseWideViewport;
}
/**
* @see android.webkit.WebSettings#setSupportMultipleWindows(boolean)
*/
@Override
public synchronized void setSupportMultipleWindows(boolean support) {
if (mSupportMultipleWindows != support) {
mSupportMultipleWindows = support;
postSync();
}
}
/**
* @see android.webkit.WebSettings#supportMultipleWindows()
*/
@Override
public synchronized boolean supportMultipleWindows() {
return mSupportMultipleWindows;
}
/**
* @see android.webkit.WebSettings#setLayoutAlgorithm(android.webkit.WebSettingsClassic.LayoutAlgorithm)
*/
@Override
public synchronized void setLayoutAlgorithm(LayoutAlgorithm l) {
if (l == LayoutAlgorithm.TEXT_AUTOSIZING) {
throw new IllegalArgumentException(
"WebViewClassic does not support TEXT_AUTOSIZING layout mode");
}
// XXX: This will only be affective if libwebcore was built with
// ANDROID_LAYOUT defined.
if (mLayoutAlgorithm != l) {
mLayoutAlgorithm = l;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getLayoutAlgorithm()
*/
@Override
public synchronized LayoutAlgorithm getLayoutAlgorithm() {
return mLayoutAlgorithm;
}
/**
* @see android.webkit.WebSettings#setStandardFontFamily(java.lang.String)
*/
@Override
public synchronized void setStandardFontFamily(String font) {
if (font != null && !font.equals(mStandardFontFamily)) {
mStandardFontFamily = font;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getStandardFontFamily()
*/
@Override
public synchronized String getStandardFontFamily() {
return mStandardFontFamily;
}
/**
* @see android.webkit.WebSettings#setFixedFontFamily(java.lang.String)
*/
@Override
public synchronized void setFixedFontFamily(String font) {
if (font != null && !font.equals(mFixedFontFamily)) {
mFixedFontFamily = font;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getFixedFontFamily()
*/
@Override
public synchronized String getFixedFontFamily() {
return mFixedFontFamily;
}
/**
* @see android.webkit.WebSettings#setSansSerifFontFamily(java.lang.String)
*/
@Override
public synchronized void setSansSerifFontFamily(String font) {
if (font != null && !font.equals(mSansSerifFontFamily)) {
mSansSerifFontFamily = font;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getSansSerifFontFamily()
*/
@Override
public synchronized String getSansSerifFontFamily() {
return mSansSerifFontFamily;
}
/**
* @see android.webkit.WebSettings#setSerifFontFamily(java.lang.String)
*/
@Override
public synchronized void setSerifFontFamily(String font) {
if (font != null && !font.equals(mSerifFontFamily)) {
mSerifFontFamily = font;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getSerifFontFamily()
*/
@Override
public synchronized String getSerifFontFamily() {
return mSerifFontFamily;
}
/**
* @see android.webkit.WebSettings#setCursiveFontFamily(java.lang.String)
*/
@Override
public synchronized void setCursiveFontFamily(String font) {
if (font != null && !font.equals(mCursiveFontFamily)) {
mCursiveFontFamily = font;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getCursiveFontFamily()
*/
@Override
public synchronized String getCursiveFontFamily() {
return mCursiveFontFamily;
}
/**
* @see android.webkit.WebSettings#setFantasyFontFamily(java.lang.String)
*/
@Override
public synchronized void setFantasyFontFamily(String font) {
if (font != null && !font.equals(mFantasyFontFamily)) {
mFantasyFontFamily = font;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getFantasyFontFamily()
*/
@Override
public synchronized String getFantasyFontFamily() {
return mFantasyFontFamily;
}
/**
* @see android.webkit.WebSettings#setMinimumFontSize(int)
*/
@Override
public synchronized void setMinimumFontSize(int size) {
size = pin(size);
if (mMinimumFontSize != size) {
mMinimumFontSize = size;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getMinimumFontSize()
*/
@Override
public synchronized int getMinimumFontSize() {
return mMinimumFontSize;
}
/**
* @see android.webkit.WebSettings#setMinimumLogicalFontSize(int)
*/
@Override
public synchronized void setMinimumLogicalFontSize(int size) {
size = pin(size);
if (mMinimumLogicalFontSize != size) {
mMinimumLogicalFontSize = size;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getMinimumLogicalFontSize()
*/
@Override
public synchronized int getMinimumLogicalFontSize() {
return mMinimumLogicalFontSize;
}
/**
* @see android.webkit.WebSettings#setDefaultFontSize(int)
*/
@Override
public synchronized void setDefaultFontSize(int size) {
size = pin(size);
if (mDefaultFontSize != size) {
mDefaultFontSize = size;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getDefaultFontSize()
*/
@Override
public synchronized int getDefaultFontSize() {
return mDefaultFontSize;
}
/**
* @see android.webkit.WebSettings#setDefaultFixedFontSize(int)
*/
@Override
public synchronized void setDefaultFixedFontSize(int size) {
size = pin(size);
if (mDefaultFixedFontSize != size) {
mDefaultFixedFontSize = size;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getDefaultFixedFontSize()
*/
@Override
public synchronized int getDefaultFixedFontSize() {
return mDefaultFixedFontSize;
}
/**
* Set the number of pages cached by the WebKit for the history navigation.
* @param size A non-negative integer between 0 (no cache) and 20 (max).
*/
public synchronized void setPageCacheCapacity(int size) {
if (size < 0) size = 0;
if (size > 20) size = 20;
if (mPageCacheCapacity != size) {
mPageCacheCapacity = size;
postSync();
}
}
/**
* @see android.webkit.WebSettings#setLoadsImagesAutomatically(boolean)
*/
@Override
public synchronized void setLoadsImagesAutomatically(boolean flag) {
if (mLoadsImagesAutomatically != flag) {
mLoadsImagesAutomatically = flag;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getLoadsImagesAutomatically()
*/
@Override
public synchronized boolean getLoadsImagesAutomatically() {
return mLoadsImagesAutomatically;
}
/**
* @see android.webkit.WebSettings#setBlockNetworkImage(boolean)
*/
@Override
public synchronized void setBlockNetworkImage(boolean flag) {
if (mBlockNetworkImage != flag) {
mBlockNetworkImage = flag;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getBlockNetworkImage()
*/
@Override
public synchronized boolean getBlockNetworkImage() {
return mBlockNetworkImage;
}
/**
* @see android.webkit.WebSettings#setBlockNetworkLoads(boolean)
*/
@Override
public synchronized void setBlockNetworkLoads(boolean flag) {
if (mBlockNetworkLoads != flag) {
mBlockNetworkLoads = flag;
verifyNetworkAccess();
postSync();
}
}
/**
* @see android.webkit.WebSettings#getBlockNetworkLoads()
*/
@Override
public synchronized boolean getBlockNetworkLoads() {
return mBlockNetworkLoads;
}
private void verifyNetworkAccess() {
if (!mBlockNetworkLoads) {
if (mContext.checkPermission("android.permission.INTERNET",
android.os.Process.myPid(), android.os.Process.myUid()) !=
PackageManager.PERMISSION_GRANTED) {
throw new SecurityException
("Permission denied - " +
"application missing INTERNET permission");
}
}
}
/**
* @see android.webkit.WebSettings#setJavaScriptEnabled(boolean)
*/
@Override
public synchronized void setJavaScriptEnabled(boolean flag) {
if (mJavaScriptEnabled != flag) {
mJavaScriptEnabled = flag;
postSync();
mWebView.updateJavaScriptEnabled(flag);
}
}
/**
* @see android.webkit.WebSettings#setAllowUniversalAccessFromFileURLs
*/
@Override
public synchronized void setAllowUniversalAccessFromFileURLs(boolean flag) {
if (mAllowUniversalAccessFromFileURLs != flag) {
mAllowUniversalAccessFromFileURLs = flag;
postSync();
}
}
/**
* @see android.webkit.WebSettings#setAllowFileAccessFromFileURLs
*/
@Override
public synchronized void setAllowFileAccessFromFileURLs(boolean flag) {
if (mAllowFileAccessFromFileURLs != flag) {
mAllowFileAccessFromFileURLs = flag;
postSync();
}
}
/**
* Tell the WebView to use Skia's hardware accelerated rendering path
* @param flag True if the WebView should use Skia's hw-accel path
*/
public synchronized void setHardwareAccelSkiaEnabled(boolean flag) {
if (mHardwareAccelSkia != flag) {
mHardwareAccelSkia = flag;
postSync();
}
}
/**
* @return True if the WebView is using hardware accelerated skia
*/
public synchronized boolean getHardwareAccelSkiaEnabled() {
return mHardwareAccelSkia;
}
/**
* Tell the WebView to show the visual indicator
* @param flag True if the WebView should show the visual indicator
*/
public synchronized void setShowVisualIndicator(boolean flag) {
if (mShowVisualIndicator != flag) {
mShowVisualIndicator = flag;
postSync();
}
}
/**
* @return True if the WebView is showing the visual indicator
*/
public synchronized boolean getShowVisualIndicator() {
return mShowVisualIndicator;
}
/**
* @see android.webkit.WebSettings#setPluginsEnabled(boolean)
*/
@Override
@Deprecated
public synchronized void setPluginsEnabled(boolean flag) {
setPluginState(flag ? PluginState.ON : PluginState.OFF);
}
/**
* @see android.webkit.WebSettings#setPluginState(android.webkit.WebSettingsClassic.PluginState)
*/
@Override
public synchronized void setPluginState(PluginState state) {
if (mPluginState != state) {
mPluginState = state;
postSync();
}
}
/**
* @see android.webkit.WebSettings#setPluginsPath(java.lang.String)
*/
@Override
@Deprecated
public synchronized void setPluginsPath(String pluginsPath) {
}
/**
* @see android.webkit.WebSettings#setDatabasePath(java.lang.String)
*/
@Override
public synchronized void setDatabasePath(String databasePath) {
if (databasePath != null && !mDatabasePathHasBeenSet) {
mDatabasePath = databasePath;
mDatabasePathHasBeenSet = true;
postSync();
}
}
/**
* @see android.webkit.WebSettings#setGeolocationDatabasePath(java.lang.String)
*/
@Override
public synchronized void setGeolocationDatabasePath(String databasePath) {
if (databasePath != null
&& !databasePath.equals(mGeolocationDatabasePath)) {
mGeolocationDatabasePath = databasePath;
postSync();
}
}
/**
* @see android.webkit.WebSettings#setAppCacheEnabled(boolean)
*/
@Override
public synchronized void setAppCacheEnabled(boolean flag) {
if (mAppCacheEnabled != flag) {
mAppCacheEnabled = flag;
postSync();
}
}
/**
* @see android.webkit.WebSettings#setAppCachePath(java.lang.String)
*/
@Override
public synchronized void setAppCachePath(String path) {
// We test for a valid path and for repeated setting on the native
// side, but we can avoid syncing in some simple cases.
if (mAppCachePath == null && path != null && !path.isEmpty()) {
mAppCachePath = path;
postSync();
}
}
/**
* @see android.webkit.WebSettings#setAppCacheMaxSize(long)
*/
@Override
public synchronized void setAppCacheMaxSize(long appCacheMaxSize) {
if (appCacheMaxSize != mAppCacheMaxSize) {
mAppCacheMaxSize = appCacheMaxSize;
postSync();
}
}
/**
* @see android.webkit.WebSettings#setDatabaseEnabled(boolean)
*/
@Override
public synchronized void setDatabaseEnabled(boolean flag) {
if (mDatabaseEnabled != flag) {
mDatabaseEnabled = flag;
postSync();
}
}
/**
* @see android.webkit.WebSettings#setDomStorageEnabled(boolean)
*/
@Override
public synchronized void setDomStorageEnabled(boolean flag) {
if (mDomStorageEnabled != flag) {
mDomStorageEnabled = flag;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getDomStorageEnabled()
*/
@Override
public synchronized boolean getDomStorageEnabled() {
return mDomStorageEnabled;
}
/**
* @see android.webkit.WebSettings#getDatabasePath()
*/
@Override
public synchronized String getDatabasePath() {
return mDatabasePath;
}
/**
* @see android.webkit.WebSettings#getDatabaseEnabled()
*/
@Override
public synchronized boolean getDatabaseEnabled() {
return mDatabaseEnabled;
}
/**
* Tell the WebView to enable WebWorkers API.
* @param flag True if the WebView should enable WebWorkers.
* Note that this flag only affects V8. JSC does not have
* an equivalent setting.
*/
public synchronized void setWorkersEnabled(boolean flag) {
if (mWorkersEnabled != flag) {
mWorkersEnabled = flag;
postSync();
}
}
/**
* @see android.webkit.WebSettings#setGeolocationEnabled(boolean)
*/
@Override
public synchronized void setGeolocationEnabled(boolean flag) {
if (mGeolocationEnabled != flag) {
mGeolocationEnabled = flag;
postSync();
}
}
/**
* Sets whether XSS Auditor is enabled.
* Only used by LayoutTestController.
* @param flag Whether XSS Auditor should be enabled.
*/
public synchronized void setXSSAuditorEnabled(boolean flag) {
if (mXSSAuditorEnabled != flag) {
mXSSAuditorEnabled = flag;
postSync();
}
}
/**
* Enables/disables HTML5 link "prefetch" parameter.
*/
public synchronized void setLinkPrefetchEnabled(boolean flag) {
if (mLinkPrefetchEnabled != flag) {
mLinkPrefetchEnabled = flag;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getJavaScriptEnabled()
*/
@Override
public synchronized boolean getJavaScriptEnabled() {
return mJavaScriptEnabled;
}
/**
* @see android.webkit.WebSettings#getAllowUniversalFileAccessFromFileURLs
*/
@Override
public synchronized boolean getAllowUniversalAccessFromFileURLs() {
return mAllowUniversalAccessFromFileURLs;
}
/**
* @see android.webkit.WebSettings#getAllowFileAccessFromFileURLs
*/
@Override
public synchronized boolean getAllowFileAccessFromFileURLs() {
return mAllowFileAccessFromFileURLs;
}
/**
* @see android.webkit.WebSettings#getPluginsEnabled()
*/
@Override
@Deprecated
public synchronized boolean getPluginsEnabled() {
return mPluginState == PluginState.ON;
}
/**
* @see android.webkit.WebSettings#getPluginState()
*/
@Override
public synchronized PluginState getPluginState() {
return mPluginState;
}
/**
* @see android.webkit.WebSettings#getPluginsPath()
*/
@Override
@Deprecated
public synchronized String getPluginsPath() {
return "";
}
/**
* @see android.webkit.WebSettings#setJavaScriptCanOpenWindowsAutomatically(boolean)
*/
@Override
public synchronized void setJavaScriptCanOpenWindowsAutomatically(
boolean flag) {
if (mJavaScriptCanOpenWindowsAutomatically != flag) {
mJavaScriptCanOpenWindowsAutomatically = flag;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getJavaScriptCanOpenWindowsAutomatically()
*/
@Override
public synchronized boolean getJavaScriptCanOpenWindowsAutomatically() {
return mJavaScriptCanOpenWindowsAutomatically;
}
/**
* @see android.webkit.WebSettings#setDefaultTextEncodingName(java.lang.String)
*/
@Override
public synchronized void setDefaultTextEncodingName(String encoding) {
if (encoding != null && !encoding.equals(mDefaultTextEncoding)) {
mDefaultTextEncoding = encoding;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getDefaultTextEncodingName()
*/
@Override
public synchronized String getDefaultTextEncodingName() {
return mDefaultTextEncoding;
}
/**
* @see android.webkit.WebSettings#setUserAgentString(java.lang.String)
*/
@Override
public synchronized void setUserAgentString(String ua) {
if (ua == null || ua.length() == 0) {
synchronized(sLockForLocaleSettings) {
Locale currentLocale = Locale.getDefault();
if (!sLocale.equals(currentLocale)) {
sLocale = currentLocale;
mAcceptLanguage = getCurrentAcceptLanguage();
}
}
ua = getCurrentUserAgent();
mUseDefaultUserAgent = true;
} else {
mUseDefaultUserAgent = false;
}
if (!ua.equals(mUserAgent)) {
mUserAgent = ua;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getUserAgentString()
*/
@Override
public synchronized String getUserAgentString() {
if (DESKTOP_USERAGENT.equals(mUserAgent) ||
IPHONE_USERAGENT.equals(mUserAgent) ||
!mUseDefaultUserAgent) {
return mUserAgent;
}
boolean doPostSync = false;
synchronized(sLockForLocaleSettings) {
Locale currentLocale = Locale.getDefault();
if (!sLocale.equals(currentLocale)) {
sLocale = currentLocale;
mUserAgent = getCurrentUserAgent();
mAcceptLanguage = getCurrentAcceptLanguage();
doPostSync = true;
}
}
if (doPostSync) {
postSync();
}
return mUserAgent;
}
/* package api to grab the Accept Language string. */
/*package*/ synchronized String getAcceptLanguage() {
synchronized(sLockForLocaleSettings) {
Locale currentLocale = Locale.getDefault();
if (!sLocale.equals(currentLocale)) {
sLocale = currentLocale;
mAcceptLanguage = getCurrentAcceptLanguage();
}
}
return mAcceptLanguage;
}
/* package */ boolean isNarrowColumnLayout() {
return getLayoutAlgorithm() == LayoutAlgorithm.NARROW_COLUMNS;
}
/**
* @see android.webkit.WebSettings#setNeedInitialFocus(boolean)
*/
@Override
public void setNeedInitialFocus(boolean flag) {
if (mNeedInitialFocus != flag) {
mNeedInitialFocus = flag;
}
}
/* Package api to get the choice whether it needs to set initial focus. */
/* package */ boolean getNeedInitialFocus() {
return mNeedInitialFocus;
}
/**
* @see android.webkit.WebSettings#setRenderPriority(android.webkit.WebSettingsClassic.RenderPriority)
*/
@Override
public synchronized void setRenderPriority(RenderPriority priority) {
if (mRenderPriority != priority) {
mRenderPriority = priority;
mEventHandler.sendMessage(Message.obtain(null,
EventHandler.PRIORITY));
}
}
/**
* @see android.webkit.WebSettings#setCacheMode(int)
*/
@Override
public void setCacheMode(int mode) {
if (mode != mOverrideCacheMode) {
mOverrideCacheMode = mode;
postSync();
}
}
/**
* @see android.webkit.WebSettings#getCacheMode()
*/
@Override
public int getCacheMode() {
return mOverrideCacheMode;
}
/**
* If set, webkit alternately shrinks and expands images viewed outside
* of an HTML page to fit the screen. This conflicts with attempts by
* the UI to zoom in and out of an image, so it is set false by default.
* @param shrink Set true to let webkit shrink the standalone image to fit.
*/
public void setShrinksStandaloneImagesToFit(boolean shrink) {
if (mShrinksStandaloneImagesToFit != shrink) {
mShrinksStandaloneImagesToFit = shrink;
postSync();
}
}
/**
* Specify the maximum decoded image size. The default is
* 2 megs for small memory devices and 8 megs for large memory devices.
* @param size The maximum decoded size, or zero to set to the default.
*/
public void setMaximumDecodedImageSize(long size) {
if (mMaximumDecodedImageSize != size) {
mMaximumDecodedImageSize = size;
postSync();
}
}
/**
* Returns whether to use fixed viewport. Use fixed viewport
* whenever wide viewport is on.
*/
/* package */ boolean getUseFixedViewport() {
return getUseWideViewPort();
}
/**
* Returns whether private browsing is enabled.
*/
/* package */ boolean isPrivateBrowsingEnabled() {
return mPrivateBrowsingEnabled;
}
/**
* Sets whether private browsing is enabled.
* @param flag Whether private browsing should be enabled.
*/
/* package */ synchronized void setPrivateBrowsingEnabled(boolean flag) {
if (mPrivateBrowsingEnabled != flag) {
mPrivateBrowsingEnabled = flag;
// AutoFill is dependant on private browsing being enabled so
// reset it to take account of the new value of mPrivateBrowsingEnabled.
setAutoFillEnabled(mAutoFillEnabled);
postSync();
}
}
/**
* Returns whether the viewport metatag can disable zooming
*/
public boolean forceUserScalable() {
return mForceUserScalable;
}
/**
* Sets whether viewport metatag can disable zooming.
* @param flag Whether or not to forceably enable user scalable.
*/
public synchronized void setForceUserScalable(boolean flag) {
mForceUserScalable = flag;
}
synchronized void setSyntheticLinksEnabled(boolean flag) {
if (mSyntheticLinksEnabled != flag) {
mSyntheticLinksEnabled = flag;
postSync();
}
}
public synchronized void setAutoFillEnabled(boolean enabled) {
// AutoFill is always disabled in private browsing mode.
boolean autoFillEnabled = enabled && !mPrivateBrowsingEnabled;
if (mAutoFillEnabled != autoFillEnabled) {
mAutoFillEnabled = autoFillEnabled;
postSync();
}
}
public synchronized boolean getAutoFillEnabled() {
return mAutoFillEnabled;
}
public synchronized void setAutoFillProfile(AutoFillProfile profile) {
if (mAutoFillProfile != profile) {
mAutoFillProfile = profile;
postSync();
}
}
public synchronized AutoFillProfile getAutoFillProfile() {
return mAutoFillProfile;
}
int getDoubleTapToastCount() {
return mDoubleTapToastCount;
}
void setDoubleTapToastCount(int count) {
if (mDoubleTapToastCount != count) {
mDoubleTapToastCount = count;
// write the settings in the non-UI thread
mEventHandler.sendMessage(Message.obtain(null,
EventHandler.SET_DOUBLE_TAP_TOAST_COUNT));
}
}
public void setProperty(String key, String value) {
if (mWebView.nativeSetProperty(key, value)) {
mWebView.invalidate();
}
}
public String getProperty(String key) {
return mWebView.nativeGetProperty(key);
}
/**
* Transfer messages from the queue to the new WebCoreThread. Called from
* WebCore thread.
*/
/*package*/
synchronized void syncSettingsAndCreateHandler(BrowserFrame frame) {
mBrowserFrame = frame;
if (DebugFlags.WEB_SETTINGS) {
junit.framework.Assert.assertTrue(frame.mNativeFrame != 0);
}
SharedPreferences sp = mContext.getSharedPreferences(PREF_FILE,
Context.MODE_PRIVATE);
if (mDoubleTapToastCount > 0) {
mDoubleTapToastCount = sp.getInt(DOUBLE_TAP_TOAST_COUNT,
mDoubleTapToastCount);
}
nativeSync(frame.mNativeFrame);
mSyncPending = false;
mEventHandler.createHandler();
}
/**
* Let the Settings object know that our owner is being destroyed.
*/
/*package*/
synchronized void onDestroyed() {
}
private int pin(int size) {
// FIXME: 72 is just an arbitrary max text size value.
if (size < 1) {
return 1;
} else if (size > 72) {
return 72;
}
return size;
}
/* Post a SYNC message to handle syncing the native settings. */
private synchronized void postSync() {
// Only post if a sync is not pending
if (!mSyncPending) {
mSyncPending = mEventHandler.sendMessage(
Message.obtain(null, EventHandler.SYNC));
}
}
// Synchronize the native and java settings.
private native void nativeSync(int nativeFrame);
}