1549 lines
50 KiB
Java
1549 lines
50 KiB
Java
/*
|
|
* Copyright (C) 2007 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.util.EventLog;
|
|
import java.lang.SecurityException;
|
|
import java.util.Locale;
|
|
|
|
/**
|
|
* Manages settings state for a WebView. When a WebView is first created, it
|
|
* obtains a set of default settings. These default settings will be returned
|
|
* from any getter call. A WebSettings object obtained from
|
|
* WebView.getSettings() is tied to the life of the WebView. If a WebView has
|
|
* been destroyed, any method call on WebSettings will throw an
|
|
* IllegalStateException.
|
|
*/
|
|
public class WebSettings {
|
|
/**
|
|
* Enum for controlling the layout of html.
|
|
* NORMAL means no rendering changes.
|
|
* SINGLE_COLUMN moves all content into one column that is the width of the
|
|
* view.
|
|
* NARROW_COLUMNS makes all columns no wider than the screen if possible.
|
|
*/
|
|
// XXX: These must match LayoutAlgorithm in Settings.h in WebCore.
|
|
public enum LayoutAlgorithm {
|
|
NORMAL,
|
|
SINGLE_COLUMN,
|
|
NARROW_COLUMNS
|
|
}
|
|
|
|
/**
|
|
* Enum for specifying the text size.
|
|
* SMALLEST is 50%
|
|
* SMALLER is 75%
|
|
* NORMAL is 100%
|
|
* LARGER is 150%
|
|
* LARGEST is 200%
|
|
*/
|
|
public enum TextSize {
|
|
SMALLEST(50),
|
|
SMALLER(75),
|
|
NORMAL(100),
|
|
LARGER(150),
|
|
LARGEST(200);
|
|
TextSize(int size) {
|
|
value = size;
|
|
}
|
|
int value;
|
|
}
|
|
|
|
/**
|
|
* Enum for specifying the WebView's desired density.
|
|
* FAR makes 100% looking like in 240dpi
|
|
* MEDIUM makes 100% looking like in 160dpi
|
|
* CLOSE makes 100% looking like in 120dpi
|
|
*/
|
|
public enum ZoomDensity {
|
|
FAR(150), // 240dpi
|
|
MEDIUM(100), // 160dpi
|
|
CLOSE(75); // 120dpi
|
|
ZoomDensity(int size) {
|
|
value = size;
|
|
}
|
|
int value;
|
|
}
|
|
|
|
/**
|
|
* Default cache usage pattern Use with {@link #setCacheMode}.
|
|
*/
|
|
public static final int LOAD_DEFAULT = -1;
|
|
|
|
/**
|
|
* Normal cache usage pattern Use with {@link #setCacheMode}.
|
|
*/
|
|
public static final int LOAD_NORMAL = 0;
|
|
|
|
/**
|
|
* Use cache if content is there, even if expired (eg, history nav)
|
|
* If it is not in the cache, load from network.
|
|
* Use with {@link #setCacheMode}.
|
|
*/
|
|
public static final int LOAD_CACHE_ELSE_NETWORK = 1;
|
|
|
|
/**
|
|
* Don't use the cache, load from network
|
|
* Use with {@link #setCacheMode}.
|
|
*/
|
|
public static final int LOAD_NO_CACHE = 2;
|
|
|
|
/**
|
|
* Don't use the network, load from cache only.
|
|
* Use with {@link #setCacheMode}.
|
|
*/
|
|
public static final int LOAD_CACHE_ONLY = 3;
|
|
|
|
public enum RenderPriority {
|
|
NORMAL,
|
|
HIGH,
|
|
LOW
|
|
}
|
|
|
|
/**
|
|
* The plugin state effects how plugins are treated on a page. ON means
|
|
* that any object will be loaded even if a plugin does not exist to handle
|
|
* the content. ON_DEMAND means that if there is a plugin installed that
|
|
* can handle the content, a placeholder is shown until the user clicks on
|
|
* the placeholder. Once clicked, the plugin will be enabled on the page.
|
|
* OFF means that all plugins will be turned off and any fallback content
|
|
* will be used.
|
|
*/
|
|
public enum PluginState {
|
|
ON,
|
|
ON_DEMAND,
|
|
OFF
|
|
}
|
|
|
|
// WebView associated with this WebSettings.
|
|
private WebView 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 TextSize mTextSize = TextSize.NORMAL;
|
|
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 mDisplayPowerSaveModeEnabled = false;
|
|
private boolean mBlockNetworkImage = false;
|
|
private boolean mBlockNetworkLoads;
|
|
private boolean mJavaScriptEnabled = 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 boolean mInvertColor = false;
|
|
// 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;
|
|
// HTML5 configuration parameters
|
|
private long mAppCacheMaxSize = Long.MAX_VALUE;
|
|
private String mAppCachePath = "";
|
|
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 boolean mSaveFormData = true;
|
|
private boolean mSavePassword = true;
|
|
private boolean mLightTouchEnabled = false;
|
|
private boolean mNeedInitialFocus = true;
|
|
private boolean mNavDump = false;
|
|
private boolean mSupportZoom = true;
|
|
private boolean mBuiltInZoomControls = false;
|
|
private boolean mAllowFileAccess = true;
|
|
private boolean mAllowContentAccess = true;
|
|
private boolean mLoadWithOverviewMode = false;
|
|
private boolean mUseWebViewBackgroundOverscrollBackground = true;
|
|
private boolean mInpageVideoEnabled = false;
|
|
|
|
// 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 (WebSettings.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 (WebSettings.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 (Macintosh; U; Intel Mac OS X 10_5_7; en-us)"
|
|
+ " AppleWebKit/530.17 (KHTML, like Gecko) Version/4.0"
|
|
+ " Safari/530.17";
|
|
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.
|
|
*/
|
|
WebSettings(Context context, WebView 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;
|
|
}
|
|
|
|
/**
|
|
* Looks at sLocale and returns current AcceptLanguage String.
|
|
* @return Current AcceptLanguage String.
|
|
*/
|
|
private String getCurrentAcceptLanguage() {
|
|
Locale locale;
|
|
synchronized(sLockForLocaleSettings) {
|
|
locale = sLocale;
|
|
}
|
|
StringBuffer buffer = new StringBuffer();
|
|
final String language = locale.getLanguage();
|
|
if (language != null) {
|
|
buffer.append(language);
|
|
final String country = locale.getCountry();
|
|
if (country != null) {
|
|
buffer.append("-");
|
|
buffer.append(country);
|
|
}
|
|
}
|
|
if (!locale.equals(Locale.US)) {
|
|
buffer.append(", ");
|
|
java.util.Locale us = Locale.US;
|
|
if (us.getLanguage() != null) {
|
|
buffer.append(us.getLanguage());
|
|
final String country = us.getCountry();
|
|
if (country != null) {
|
|
buffer.append("-");
|
|
buffer.append(country);
|
|
}
|
|
}
|
|
}
|
|
|
|
return buffer.toString();
|
|
}
|
|
|
|
/**
|
|
* Looks at sLocale and mContext and returns current UserAgent String.
|
|
* @return Current UserAgent String.
|
|
*/
|
|
private synchronized String getCurrentUserAgent() {
|
|
Locale locale;
|
|
synchronized(sLockForLocaleSettings) {
|
|
locale = sLocale;
|
|
}
|
|
StringBuffer buffer = new StringBuffer();
|
|
// Add version
|
|
final String version = Build.VERSION.RELEASE;
|
|
if (version.length() > 0) {
|
|
buffer.append(version);
|
|
} else {
|
|
// default to "1.0"
|
|
buffer.append("1.0");
|
|
}
|
|
buffer.append("; ");
|
|
final String language = locale.getLanguage();
|
|
if (language != null) {
|
|
buffer.append(language.toLowerCase());
|
|
final String country = locale.getCountry();
|
|
if (country != null) {
|
|
buffer.append("-");
|
|
buffer.append(country.toLowerCase());
|
|
}
|
|
} else {
|
|
// default to "en"
|
|
buffer.append("en");
|
|
}
|
|
// 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);
|
|
}
|
|
final String base = mContext.getResources().getText(
|
|
com.android.internal.R.string.web_user_agent).toString();
|
|
return String.format(base, buffer);
|
|
}
|
|
|
|
/**
|
|
* Enables dumping the pages navigation cache to a text file.
|
|
*/
|
|
public void setNavDump(boolean enabled) {
|
|
mNavDump = enabled;
|
|
}
|
|
|
|
/**
|
|
* Returns true if dumping the navigation cache is enabled.
|
|
*/
|
|
public boolean getNavDump() {
|
|
return mNavDump;
|
|
}
|
|
|
|
/**
|
|
* Set whether the WebView supports zoom
|
|
*/
|
|
public void setSupportZoom(boolean support) {
|
|
mSupportZoom = support;
|
|
mWebView.updateMultiTouchSupport(mContext);
|
|
}
|
|
|
|
/**
|
|
* Returns whether the WebView supports zoom
|
|
*/
|
|
public boolean supportZoom() {
|
|
return mSupportZoom;
|
|
}
|
|
|
|
/**
|
|
* Sets whether the zoom mechanism built into WebView is used.
|
|
*/
|
|
public void setBuiltInZoomControls(boolean enabled) {
|
|
mBuiltInZoomControls = enabled;
|
|
mWebView.updateMultiTouchSupport(mContext);
|
|
}
|
|
|
|
/**
|
|
* Returns true if the zoom mechanism built into WebView is being used.
|
|
*/
|
|
public boolean getBuiltInZoomControls() {
|
|
return mBuiltInZoomControls;
|
|
}
|
|
|
|
/**
|
|
* Enable or disable file access within WebView. File access is enabled by
|
|
* default. Note that this enables or disables file system access only.
|
|
* Assets and resources are still accessible using file:///android_asset and
|
|
* file:///android_res.
|
|
*/
|
|
public void setAllowFileAccess(boolean allow) {
|
|
mAllowFileAccess = allow;
|
|
}
|
|
|
|
/**
|
|
* Returns true if this WebView supports file access.
|
|
*/
|
|
public boolean getAllowFileAccess() {
|
|
return mAllowFileAccess;
|
|
}
|
|
|
|
/**
|
|
* Enable or disable content url access within WebView. Content url access
|
|
* allows WebView to load content from a content provider installed in the
|
|
* system. The default is enabled.
|
|
* @hide
|
|
*/
|
|
public void setAllowContentAccess(boolean allow) {
|
|
mAllowContentAccess = allow;
|
|
}
|
|
|
|
/**
|
|
* Returns true if this WebView supports content url access.
|
|
* @hide
|
|
*/
|
|
public boolean getAllowContentAccess() {
|
|
return mAllowContentAccess;
|
|
}
|
|
|
|
/**
|
|
* Set whether the WebView loads a page with overview mode.
|
|
*/
|
|
public void setLoadWithOverviewMode(boolean overview) {
|
|
mLoadWithOverviewMode = overview;
|
|
}
|
|
|
|
/**
|
|
* Returns true if this WebView loads page with overview mode
|
|
*/
|
|
public boolean getLoadWithOverviewMode() {
|
|
return mLoadWithOverviewMode;
|
|
}
|
|
|
|
/**
|
|
* Set whether the WebView uses its background for over scroll background.
|
|
* If true, it will use the WebView's background. If false, it will use an
|
|
* internal pattern. Default is true.
|
|
*/
|
|
public void setUseWebViewBackgroundForOverscrollBackground(boolean view) {
|
|
mUseWebViewBackgroundOverscrollBackground = view;
|
|
}
|
|
|
|
/**
|
|
* Returns true if this WebView uses WebView's background instead of
|
|
* internal pattern for over scroll background.
|
|
*/
|
|
public boolean getUseWebViewBackgroundForOverscrollBackground() {
|
|
return mUseWebViewBackgroundOverscrollBackground;
|
|
}
|
|
|
|
/**
|
|
* Store whether the WebView is saving form data.
|
|
*/
|
|
public void setSaveFormData(boolean save) {
|
|
mSaveFormData = save;
|
|
}
|
|
|
|
/**
|
|
* Return whether the WebView is saving form data.
|
|
*/
|
|
public boolean getSaveFormData() {
|
|
return mSaveFormData;
|
|
}
|
|
|
|
/**
|
|
* Store whether the WebView is saving password.
|
|
*/
|
|
public void setSavePassword(boolean save) {
|
|
mSavePassword = save;
|
|
}
|
|
|
|
/**
|
|
* Return whether the WebView is saving password.
|
|
*/
|
|
public boolean getSavePassword() {
|
|
return mSavePassword;
|
|
}
|
|
|
|
/**
|
|
* Set the text size of the page.
|
|
* @param t A TextSize value for increasing or decreasing the text.
|
|
* @see WebSettings.TextSize
|
|
*/
|
|
public synchronized void setTextSize(TextSize t) {
|
|
if (WebView.mLogEvent && mTextSize != t ) {
|
|
EventLog.writeEvent(EventLogTags.BROWSER_TEXT_SIZE_CHANGE,
|
|
mTextSize.value, t.value);
|
|
}
|
|
mTextSize = t;
|
|
postSync();
|
|
}
|
|
|
|
/**
|
|
* Get the text size of the page.
|
|
* @return A TextSize enum value describing the text size.
|
|
* @see WebSettings.TextSize
|
|
*/
|
|
public synchronized TextSize getTextSize() {
|
|
return mTextSize;
|
|
}
|
|
|
|
/**
|
|
* Set the default zoom density of the page. This should be called from UI
|
|
* thread.
|
|
* @param zoom A ZoomDensity value
|
|
* @see WebSettings.ZoomDensity
|
|
*/
|
|
public void setDefaultZoom(ZoomDensity zoom) {
|
|
if (mDefaultZoom != zoom) {
|
|
mDefaultZoom = zoom;
|
|
mWebView.updateDefaultZoomDensity(zoom.value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the default zoom density of the page. This should be called from UI
|
|
* thread.
|
|
* @return A ZoomDensity value
|
|
* @see WebSettings.ZoomDensity
|
|
*/
|
|
public ZoomDensity getDefaultZoom() {
|
|
return mDefaultZoom;
|
|
}
|
|
|
|
/**
|
|
* Enables using light touches to make a selection and activate mouseovers.
|
|
*/
|
|
public void setLightTouchEnabled(boolean enabled) {
|
|
mLightTouchEnabled = enabled;
|
|
}
|
|
|
|
/**
|
|
* Returns true if light touches are enabled.
|
|
*/
|
|
public boolean getLightTouchEnabled() {
|
|
return mLightTouchEnabled;
|
|
}
|
|
|
|
/**
|
|
* @deprecated This setting controlled a rendering optimization
|
|
* that is no longer present. Setting it now has no effect.
|
|
*/
|
|
@Deprecated
|
|
public synchronized void setUseDoubleTree(boolean use) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* @deprecated This setting controlled a rendering optimization
|
|
* that is no longer present. Setting it now has no effect.
|
|
*/
|
|
@Deprecated
|
|
public synchronized boolean getUseDoubleTree() {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Tell the WebView about user-agent string.
|
|
* @param ua 0 if the WebView should use an Android user-agent string,
|
|
* 1 if the WebView should use a desktop user-agent string.
|
|
*
|
|
* @deprecated Please use setUserAgentString instead.
|
|
*/
|
|
@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);
|
|
}
|
|
|
|
/**
|
|
* Return user-agent as int
|
|
* @return int 0 if the WebView is using an Android user-agent string.
|
|
* 1 if the WebView is using a desktop user-agent string.
|
|
* -1 if the WebView is using user defined user-agent string.
|
|
*
|
|
* @deprecated Please use getUserAgentString instead.
|
|
*/
|
|
@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;
|
|
}
|
|
|
|
/**
|
|
* Tell the WebView to use the wide viewport
|
|
*/
|
|
public synchronized void setUseWideViewPort(boolean use) {
|
|
if (mUseWideViewport != use) {
|
|
mUseWideViewport = use;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return True if the WebView is using a wide viewport
|
|
*/
|
|
public synchronized boolean getUseWideViewPort() {
|
|
return mUseWideViewport;
|
|
}
|
|
|
|
/**
|
|
* Tell the WebView whether it supports multiple windows. TRUE means
|
|
* that {@link WebChromeClient#onCreateWindow(WebView, boolean,
|
|
* boolean, Message)} is implemented by the host application.
|
|
*/
|
|
public synchronized void setSupportMultipleWindows(boolean support) {
|
|
if (mSupportMultipleWindows != support) {
|
|
mSupportMultipleWindows = support;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return True if the WebView is supporting multiple windows. This means
|
|
* that {@link WebChromeClient#onCreateWindow(WebView, boolean,
|
|
* boolean, Message)} is implemented by the host application.
|
|
*/
|
|
public synchronized boolean supportMultipleWindows() {
|
|
return mSupportMultipleWindows;
|
|
}
|
|
|
|
/**
|
|
* Set the underlying layout algorithm. This will cause a relayout of the
|
|
* WebView.
|
|
* @param l A LayoutAlgorithm enum specifying the algorithm to use.
|
|
* @see WebSettings.LayoutAlgorithm
|
|
*/
|
|
public synchronized void setLayoutAlgorithm(LayoutAlgorithm l) {
|
|
// XXX: This will only be affective if libwebcore was built with
|
|
// ANDROID_LAYOUT defined.
|
|
if (mLayoutAlgorithm != l) {
|
|
mLayoutAlgorithm = l;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the current layout algorithm. The default is NARROW_COLUMNS.
|
|
* @return LayoutAlgorithm enum value describing the layout algorithm
|
|
* being used.
|
|
* @see WebSettings.LayoutAlgorithm
|
|
*/
|
|
public synchronized LayoutAlgorithm getLayoutAlgorithm() {
|
|
return mLayoutAlgorithm;
|
|
}
|
|
|
|
/**
|
|
* Set the standard font family name.
|
|
* @param font A font family name.
|
|
*/
|
|
public synchronized void setStandardFontFamily(String font) {
|
|
if (font != null && !font.equals(mStandardFontFamily)) {
|
|
mStandardFontFamily = font;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the standard font family name. The default is "sans-serif".
|
|
* @return The standard font family name as a string.
|
|
*/
|
|
public synchronized String getStandardFontFamily() {
|
|
return mStandardFontFamily;
|
|
}
|
|
|
|
/**
|
|
* Set the fixed font family name.
|
|
* @param font A font family name.
|
|
*/
|
|
public synchronized void setFixedFontFamily(String font) {
|
|
if (font != null && !font.equals(mFixedFontFamily)) {
|
|
mFixedFontFamily = font;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the fixed font family name. The default is "monospace".
|
|
* @return The fixed font family name as a string.
|
|
*/
|
|
public synchronized String getFixedFontFamily() {
|
|
return mFixedFontFamily;
|
|
}
|
|
|
|
/**
|
|
* Set the sans-serif font family name.
|
|
* @param font A font family name.
|
|
*/
|
|
public synchronized void setSansSerifFontFamily(String font) {
|
|
if (font != null && !font.equals(mSansSerifFontFamily)) {
|
|
mSansSerifFontFamily = font;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the sans-serif font family name.
|
|
* @return The sans-serif font family name as a string.
|
|
*/
|
|
public synchronized String getSansSerifFontFamily() {
|
|
return mSansSerifFontFamily;
|
|
}
|
|
|
|
/**
|
|
* Set the serif font family name. The default is "sans-serif".
|
|
* @param font A font family name.
|
|
*/
|
|
public synchronized void setSerifFontFamily(String font) {
|
|
if (font != null && !font.equals(mSerifFontFamily)) {
|
|
mSerifFontFamily = font;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the serif font family name. The default is "serif".
|
|
* @return The serif font family name as a string.
|
|
*/
|
|
public synchronized String getSerifFontFamily() {
|
|
return mSerifFontFamily;
|
|
}
|
|
|
|
/**
|
|
* Set the cursive font family name.
|
|
* @param font A font family name.
|
|
*/
|
|
public synchronized void setCursiveFontFamily(String font) {
|
|
if (font != null && !font.equals(mCursiveFontFamily)) {
|
|
mCursiveFontFamily = font;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the cursive font family name. The default is "cursive".
|
|
* @return The cursive font family name as a string.
|
|
*/
|
|
public synchronized String getCursiveFontFamily() {
|
|
return mCursiveFontFamily;
|
|
}
|
|
|
|
/**
|
|
* Set the fantasy font family name.
|
|
* @param font A font family name.
|
|
*/
|
|
public synchronized void setFantasyFontFamily(String font) {
|
|
if (font != null && !font.equals(mFantasyFontFamily)) {
|
|
mFantasyFontFamily = font;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the fantasy font family name. The default is "fantasy".
|
|
* @return The fantasy font family name as a string.
|
|
*/
|
|
public synchronized String getFantasyFontFamily() {
|
|
return mFantasyFontFamily;
|
|
}
|
|
|
|
/**
|
|
* Set the minimum font size.
|
|
* @param size A non-negative integer between 1 and 72.
|
|
* Any number outside the specified range will be pinned.
|
|
*/
|
|
public synchronized void setMinimumFontSize(int size) {
|
|
size = pin(size);
|
|
if (mMinimumFontSize != size) {
|
|
mMinimumFontSize = size;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the minimum font size. The default is 8.
|
|
* @return A non-negative integer between 1 and 72.
|
|
*/
|
|
public synchronized int getMinimumFontSize() {
|
|
return mMinimumFontSize;
|
|
}
|
|
|
|
/**
|
|
* Set the minimum logical font size.
|
|
* @param size A non-negative integer between 1 and 72.
|
|
* Any number outside the specified range will be pinned.
|
|
*/
|
|
public synchronized void setMinimumLogicalFontSize(int size) {
|
|
size = pin(size);
|
|
if (mMinimumLogicalFontSize != size) {
|
|
mMinimumLogicalFontSize = size;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the minimum logical font size. The default is 8.
|
|
* @return A non-negative integer between 1 and 72.
|
|
*/
|
|
public synchronized int getMinimumLogicalFontSize() {
|
|
return mMinimumLogicalFontSize;
|
|
}
|
|
|
|
/**
|
|
* Set the default font size.
|
|
* @param size A non-negative integer between 1 and 72.
|
|
* Any number outside the specified range will be pinned.
|
|
*/
|
|
public synchronized void setDefaultFontSize(int size) {
|
|
size = pin(size);
|
|
if (mDefaultFontSize != size) {
|
|
mDefaultFontSize = size;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the default font size. The default is 16.
|
|
* @return A non-negative integer between 1 and 72.
|
|
*/
|
|
public synchronized int getDefaultFontSize() {
|
|
return mDefaultFontSize;
|
|
}
|
|
|
|
/**
|
|
* Set the default fixed font size.
|
|
* @param size A non-negative integer between 1 and 72.
|
|
* Any number outside the specified range will be pinned.
|
|
*/
|
|
public synchronized void setDefaultFixedFontSize(int size) {
|
|
size = pin(size);
|
|
if (mDefaultFixedFontSize != size) {
|
|
mDefaultFixedFontSize = size;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the default fixed font size. The default is 16.
|
|
* @return A non-negative integer between 1 and 72.
|
|
*/
|
|
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).
|
|
* @hide
|
|
*/
|
|
public synchronized void setPageCacheCapacity(int size) {
|
|
if (size < 0) size = 0;
|
|
if (size > 20) size = 20;
|
|
if (mPageCacheCapacity != size) {
|
|
mPageCacheCapacity = size;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tell the WebView to load image resources automatically.
|
|
* @param flag True if the WebView should load images automatically.
|
|
*/
|
|
public synchronized void setLoadsImagesAutomatically(boolean flag) {
|
|
if (mLoadsImagesAutomatically != flag) {
|
|
mLoadsImagesAutomatically = flag;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if the WebView will load image resources automatically.
|
|
* The default is true.
|
|
* @return True if the WebView loads images automatically.
|
|
*/
|
|
public synchronized boolean getLoadsImagesAutomatically() {
|
|
return mLoadsImagesAutomatically;
|
|
}
|
|
|
|
/**
|
|
* Tell the WebView to enable power save mode.
|
|
* @param flag True if the WebView should enable power save mode.
|
|
* @hide
|
|
*/
|
|
public synchronized void setDisplayPowerSaveModeEnabled(boolean flag) {
|
|
if (mDisplayPowerSaveModeEnabled != flag) {
|
|
mDisplayPowerSaveModeEnabled = flag;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if the WebView display power save mode is enabled.
|
|
* The default is true.
|
|
* @return True if the WebView display power save mode is enabled.
|
|
* @hide
|
|
*/
|
|
public synchronized boolean getDisplayPowerSaveModeEnabled() {
|
|
return mDisplayPowerSaveModeEnabled;
|
|
}
|
|
|
|
/**
|
|
* Tell the WebView to block network images. This is only checked when
|
|
* {@link #getLoadsImagesAutomatically} is true. If you set the value to
|
|
* false, images will automatically be loaded. Use this api to reduce
|
|
* bandwidth only. Use {@link #setBlockNetworkLoads} if possible.
|
|
* @param flag True if the WebView should block network images.
|
|
* @see #setBlockNetworkLoads
|
|
*/
|
|
public synchronized void setBlockNetworkImage(boolean flag) {
|
|
if (mBlockNetworkImage != flag) {
|
|
mBlockNetworkImage = flag;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if the WebView will block network images. The default is
|
|
* false.
|
|
* @return True if the WebView blocks network images.
|
|
*/
|
|
public synchronized boolean getBlockNetworkImage() {
|
|
return mBlockNetworkImage;
|
|
}
|
|
|
|
/**
|
|
* Tell the WebView to block all network load requests. If you set the
|
|
* value to false, you must call {@link android.webkit.WebView#reload} to
|
|
* fetch remote resources. This flag supercedes the value passed to
|
|
* {@link #setBlockNetworkImage}.
|
|
* @param flag True if the WebView should block all network loads.
|
|
* @see android.webkit.WebView#reload
|
|
*/
|
|
public synchronized void setBlockNetworkLoads(boolean flag) {
|
|
if (mBlockNetworkLoads != flag) {
|
|
mBlockNetworkLoads = flag;
|
|
verifyNetworkAccess();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if the WebView will block all network loads. The default is
|
|
* false.
|
|
* @return True if the WebView blocks all network loads.
|
|
*/
|
|
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");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tell the WebView to enable javascript execution.
|
|
* @param flag True if the WebView should execute javascript.
|
|
*/
|
|
public synchronized void setJavaScriptEnabled(boolean flag) {
|
|
if (mJavaScriptEnabled != flag) {
|
|
mJavaScriptEnabled = flag;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tell the WebView to enable plugins.
|
|
* @param flag True if the WebView should load plugins.
|
|
* @deprecated This method has been deprecated in favor of
|
|
* {@link #setPluginState}
|
|
*/
|
|
@Deprecated
|
|
public synchronized void setPluginsEnabled(boolean flag) {
|
|
setPluginState(PluginState.ON);
|
|
}
|
|
|
|
/**
|
|
* Tell the WebView to enable, disable, or have plugins on demand. On
|
|
* demand mode means that if a plugin exists that can handle the embedded
|
|
* content, a placeholder icon will be shown instead of the plugin. When
|
|
* the placeholder is clicked, the plugin will be enabled.
|
|
* @param state One of the PluginState values.
|
|
*/
|
|
public synchronized void setPluginState(PluginState state) {
|
|
if (mPluginState != state) {
|
|
mPluginState = state;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set a custom path to plugins used by the WebView. This method is
|
|
* obsolete since each plugin is now loaded from its own package.
|
|
* @param pluginsPath String path to the directory containing plugins.
|
|
* @deprecated This method is no longer used as plugins are loaded from
|
|
* their own APK via the system's package manager.
|
|
*/
|
|
@Deprecated
|
|
public synchronized void setPluginsPath(String pluginsPath) {
|
|
}
|
|
|
|
/**
|
|
* Set the path to where database storage API databases should be saved.
|
|
* Nota that the WebCore Database Tracker only allows the path to be set once.
|
|
* This will update WebCore when the Sync runs in the C++ side.
|
|
* @param databasePath String path to the directory where databases should
|
|
* be saved. May be the empty string but should never be null.
|
|
*/
|
|
public synchronized void setDatabasePath(String databasePath) {
|
|
if (databasePath != null && !mDatabasePathHasBeenSet) {
|
|
mDatabasePath = databasePath;
|
|
mDatabasePathHasBeenSet = true;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the path where the Geolocation permissions database should be saved.
|
|
* This will update WebCore when the Sync runs in the C++ side.
|
|
* @param databasePath String path to the directory where the Geolocation
|
|
* permissions database should be saved. May be the empty string but
|
|
* should never be null.
|
|
*/
|
|
public synchronized void setGeolocationDatabasePath(String databasePath) {
|
|
if (databasePath != null
|
|
&& !databasePath.equals(mGeolocationDatabasePath)) {
|
|
mGeolocationDatabasePath = databasePath;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tell the WebView to enable Application Caches API.
|
|
* @param flag True if the WebView should enable Application Caches.
|
|
*/
|
|
public synchronized void setAppCacheEnabled(boolean flag) {
|
|
if (mAppCacheEnabled != flag) {
|
|
mAppCacheEnabled = flag;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set a custom path to the Application Caches files. The client
|
|
* must ensure it exists before this call.
|
|
* @param appCachePath String path to the directory containing Application
|
|
* Caches files. The appCache path can be the empty string but should not
|
|
* be null. Passing null for this parameter will result in a no-op.
|
|
*/
|
|
public synchronized void setAppCachePath(String appCachePath) {
|
|
if (appCachePath != null && !appCachePath.equals(mAppCachePath)) {
|
|
mAppCachePath = appCachePath;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the maximum size for the Application Caches content.
|
|
* @param appCacheMaxSize the maximum size in bytes.
|
|
*/
|
|
public synchronized void setAppCacheMaxSize(long appCacheMaxSize) {
|
|
if (appCacheMaxSize != mAppCacheMaxSize) {
|
|
mAppCacheMaxSize = appCacheMaxSize;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set whether the database storage API is enabled.
|
|
* @param flag boolean True if the WebView should use the database storage
|
|
* API.
|
|
*/
|
|
public synchronized void setDatabaseEnabled(boolean flag) {
|
|
if (mDatabaseEnabled != flag) {
|
|
mDatabaseEnabled = flag;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set whether the DOM storage API is enabled.
|
|
* @param flag boolean True if the WebView should use the DOM storage
|
|
* API.
|
|
*/
|
|
public synchronized void setDomStorageEnabled(boolean flag) {
|
|
if (mDomStorageEnabled != flag) {
|
|
mDomStorageEnabled = flag;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the DOM Storage API's are enabled.
|
|
* @return True if the DOM Storage API's are enabled.
|
|
*/
|
|
public synchronized boolean getDomStorageEnabled() {
|
|
return mDomStorageEnabled;
|
|
}
|
|
|
|
/**
|
|
* Return the path to where database storage API databases are saved for
|
|
* the current WebView.
|
|
* @return the String path to the database storage API databases.
|
|
*/
|
|
public synchronized String getDatabasePath() {
|
|
return mDatabasePath;
|
|
}
|
|
|
|
/**
|
|
* Returns true if database storage API is enabled.
|
|
* @return True if the database storage API is enabled.
|
|
*/
|
|
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.
|
|
* @hide pending api council approval
|
|
*/
|
|
public synchronized void setWorkersEnabled(boolean flag) {
|
|
if (mWorkersEnabled != flag) {
|
|
mWorkersEnabled = flag;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets whether Geolocation is enabled.
|
|
* @param flag Whether Geolocation should be enabled.
|
|
*/
|
|
public synchronized void setGeolocationEnabled(boolean flag) {
|
|
if (mGeolocationEnabled != flag) {
|
|
mGeolocationEnabled = flag;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if javascript is enabled. <b>Note: The default is false.</b>
|
|
* @return True if javascript is enabled.
|
|
*/
|
|
public synchronized boolean getJavaScriptEnabled() {
|
|
return mJavaScriptEnabled;
|
|
}
|
|
|
|
/**
|
|
* Return true if plugins are enabled.
|
|
* @return True if plugins are enabled.
|
|
* @deprecated This method has been replaced by {@link #getPluginState}
|
|
*/
|
|
@Deprecated
|
|
public synchronized boolean getPluginsEnabled() {
|
|
return mPluginState == PluginState.ON;
|
|
}
|
|
|
|
/**
|
|
* Return the current plugin state.
|
|
* @return A value corresponding to the enum PluginState.
|
|
*/
|
|
public synchronized PluginState getPluginState() {
|
|
return mPluginState;
|
|
}
|
|
|
|
/**
|
|
* Returns the directory that contains the plugin libraries. This method is
|
|
* obsolete since each plugin is now loaded from its own package.
|
|
* @return An empty string.
|
|
* @deprecated This method is no longer used as plugins are loaded from
|
|
* their own APK via the system's package manager.
|
|
*/
|
|
@Deprecated
|
|
public synchronized String getPluginsPath() {
|
|
return "";
|
|
}
|
|
|
|
/**
|
|
* Tell javascript to open windows automatically. This applies to the
|
|
* javascript function window.open().
|
|
* @param flag True if javascript can open windows automatically.
|
|
*/
|
|
public synchronized void setJavaScriptCanOpenWindowsAutomatically(
|
|
boolean flag) {
|
|
if (mJavaScriptCanOpenWindowsAutomatically != flag) {
|
|
mJavaScriptCanOpenWindowsAutomatically = flag;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if javascript can open windows automatically. The default
|
|
* is false.
|
|
* @return True if javascript can open windows automatically during
|
|
* window.open().
|
|
*/
|
|
public synchronized boolean getJavaScriptCanOpenWindowsAutomatically() {
|
|
return mJavaScriptCanOpenWindowsAutomatically;
|
|
}
|
|
|
|
/**
|
|
* Set the default text encoding name to use when decoding html pages.
|
|
* @param encoding The text encoding name.
|
|
*/
|
|
public synchronized void setDefaultTextEncodingName(String encoding) {
|
|
if (encoding != null && !encoding.equals(mDefaultTextEncoding)) {
|
|
mDefaultTextEncoding = encoding;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the default text encoding name. The default is "Latin-1".
|
|
* @return The default text encoding name as a string.
|
|
*/
|
|
public synchronized String getDefaultTextEncodingName() {
|
|
return mDefaultTextEncoding;
|
|
}
|
|
|
|
/**
|
|
* Set the WebView's user-agent string. If the string "ua" is null or empty,
|
|
* it will use the system default user-agent string.
|
|
*/
|
|
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();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the WebView's user-agent string.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* Tell the WebView whether it needs to set a node to have focus when
|
|
* {@link WebView#requestFocus(int, android.graphics.Rect)} is called.
|
|
*
|
|
* @param flag
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* Set the priority of the Render thread. Unlike the other settings, this
|
|
* one only needs to be called once per process. The default is NORMAL.
|
|
*
|
|
* @param priority RenderPriority, can be normal, high or low.
|
|
*/
|
|
public synchronized void setRenderPriority(RenderPriority priority) {
|
|
if (mRenderPriority != priority) {
|
|
mRenderPriority = priority;
|
|
mEventHandler.sendMessage(Message.obtain(null,
|
|
EventHandler.PRIORITY));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Override the way the cache is used. The way the cache is used is based
|
|
* on the navigation option. For a normal page load, the cache is checked
|
|
* and content is re-validated as needed. When navigating back, content is
|
|
* not revalidated, instead the content is just pulled from the cache.
|
|
* This function allows the client to override this behavior.
|
|
* @param mode One of the LOAD_ values.
|
|
*/
|
|
public void setCacheMode(int mode) {
|
|
if (mode != mOverrideCacheMode) {
|
|
mOverrideCacheMode = mode;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the current setting for overriding the cache mode. For a full
|
|
* description, see the {@link #setCacheMode(int)} function.
|
|
*/
|
|
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.
|
|
* {@hide}
|
|
*/
|
|
public void setShrinksStandaloneImagesToFit(boolean shrink) {
|
|
if (mShrinksStandaloneImagesToFit != shrink) {
|
|
mShrinksStandaloneImagesToFit = shrink;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public synchronized void setInvertColor(boolean invert) {
|
|
if (mInvertColor != invert) {
|
|
mInvertColor = invert;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public synchronized boolean getInvertColor() {
|
|
return mInvertColor;
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public synchronized void setInpageVideoEnabled(boolean flag) {
|
|
if (mInpageVideoEnabled != flag) {
|
|
mInpageVideoEnabled = flag;
|
|
postSync();
|
|
}
|
|
}
|
|
|
|
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));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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);
|
|
}
|