/**@class android.webkit.WebSettings
@extends java.lang.Object

 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.
*/
var WebSettings = {

/** Default cache usage mode. If the navigation type doesn't impose any
 specific behavior, use cached resources when they are available
 and not expired, otherwise load resources from the network.
 Use with {@link #setCacheMode}.
*/
LOAD_DEFAULT : "-1",
/** Normal cache usage mode. Use with {@link #setCacheMode}.

 @deprecated This value is obsolete, as from API level
 {@link android.os.Build.VERSION_CODES#HONEYCOMB} and onwards it has the
 same effect as {@link #LOAD_DEFAULT}.
*/
LOAD_NORMAL : "0",
/** Use cached resources when they are available, even if they have expired.
 Otherwise load resources from the network.
 Use with {@link #setCacheMode}.
*/
LOAD_CACHE_ELSE_NETWORK : "1",
/** Don't use the cache, load from the network.
 Use with {@link #setCacheMode}.
*/
LOAD_NO_CACHE : "2",
/** Don't use the network, load from the cache.
 Use with {@link #setCacheMode}.
*/
LOAD_CACHE_ONLY : "3",
/** Used with {@link #setMixedContentMode}

 In this mode, the WebView will allow a secure origin to load content from any other origin,
 even if that origin is insecure. This is the least secure mode of operation for the WebView,
 and where possible apps should not set this mode.
*/
MIXED_CONTENT_ALWAYS_ALLOW : "0",
/** Used with {@link #setMixedContentMode}

 In this mode, the WebView will not allow a secure origin to load content from an insecure
 origin. This is the preferred and most secure mode of operation for the WebView and apps are
 strongly advised to use this mode.
*/
MIXED_CONTENT_NEVER_ALLOW : "1",
/** Used with {@link #setMixedContentMode}

 In this mode, the WebView will attempt to be compatible with the approach of a modern web
 browser with regard to mixed content. Some insecure content may be allowed to be loaded by
 a secure origin and other types of content will be blocked. The types of content are allowed
 or blocked may change release to release and are not explicitly defined.

 This mode is intended to be used by apps that are not in control of the content that they
 render but desire to operate in a reasonably secure environment. For highest security, apps
 are recommended to use {@link #MIXED_CONTENT_NEVER_ALLOW}.
*/
MIXED_CONTENT_COMPATIBILITY_MODE : "2",
/**Enables dumping the pages navigation cache to a text file. The default
 is false.
@deprecated This method is now obsolete.
@hide Since API level {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1}
*/
setNavDump : function(  ) {},

/**Gets whether dumping the navigation cache is enabled.
@return {Boolean} whether dumping the navigation cache is enabled
@see #setNavDump
@deprecated This method is now obsolete.
@hide Since API level {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1}
*/
getNavDump : function(  ) {},

/**Sets whether the WebView should support zooming using its on-screen zoom
 controls and gestures. The particular zoom mechanisms that should be used
 can be set with {@link #setBuiltInZoomControls}. This setting does not
 affect zooming performed using the {@link android.webkit.WebView#zoomIn()} and
 {@link android.webkit.WebView#zoomOut()} methods. The default is true.
@param {Boolean} support whether the WebView should support zoom
*/
setSupportZoom : function(  ) {},

/**Gets whether the WebView supports zoom.
@return {Boolean} true if the WebView supports zoom
@see #setSupportZoom
*/
supportZoom : function(  ) {},

/**Sets whether the WebView requires a user gesture to play media.
 The default is true.
@param {Boolean} require whether the WebView requires a user gesture to play media
*/
setMediaPlaybackRequiresUserGesture : function(  ) {},

/**Gets whether the WebView requires a user gesture to play media.
@return {Boolean} true if the WebView requires a user gesture to play media
@see #setMediaPlaybackRequiresUserGesture
*/
getMediaPlaybackRequiresUserGesture : function(  ) {},

/**Sets whether the WebView should use its built-in zoom mechanisms. The
 built-in zoom mechanisms comprise on-screen zoom controls, which are
 displayed over the WebView's content, and the use of a pinch gesture to
 control zooming. Whether or not these on-screen controls are displayed
 can be set with {@link #setDisplayZoomControls}. The default is false.
 <p>
 The built-in mechanisms are the only currently supported zoom
 mechanisms, so it is recommended that this setting is always enabled.
@param {Boolean} enabled whether the WebView should use its built-in zoom mechanisms
*/
setBuiltInZoomControls : function(  ) {},

/**Gets whether the zoom mechanisms built into WebView are being used.
@return {Boolean} true if the zoom mechanisms built into WebView are being used
@see #setBuiltInZoomControls
*/
getBuiltInZoomControls : function(  ) {},

/**Sets whether the WebView should display on-screen zoom controls when
 using the built-in zoom mechanisms. See {@link #setBuiltInZoomControls}.
 The default is true.
@param {Boolean} enabled whether the WebView should display on-screen zoom controls
*/
setDisplayZoomControls : function(  ) {},

/**Gets whether the WebView displays on-screen zoom controls when using
 the built-in zoom mechanisms.
@return {Boolean} true if the WebView displays on-screen zoom controls when using
         the built-in zoom mechanisms
@see #setDisplayZoomControls
*/
getDisplayZoomControls : function(  ) {},

/**Enables or disables 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.
*/
setAllowFileAccess : function(  ) {},

/**Gets whether this WebView supports file access.
@see #setAllowFileAccess
*/
getAllowFileAccess : function(  ) {},

/**Enables or disables 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.
*/
setAllowContentAccess : function(  ) {},

/**Gets whether this WebView supports content URL access.
@see #setAllowContentAccess
*/
getAllowContentAccess : function(  ) {},

/**Sets whether the WebView loads pages in overview mode, that is,
 zooms out the content to fit on screen by width. This setting is
 taken into account when the content width is greater than the width
 of the WebView control, for example, when {@link #getUseWideViewPort}
 is enabled. The default is false.
*/
setLoadWithOverviewMode : function(  ) {},

/**Gets whether this WebView loads pages in overview mode.
@return {Boolean} whether this WebView loads pages in overview mode
@see #setLoadWithOverviewMode
*/
getLoadWithOverviewMode : function(  ) {},

/**Sets whether the WebView will enable smooth transition while panning or
 zooming or while the window hosting the WebView does not have focus.
 If it is true, WebView will choose a solution to maximize the performance.
 e.g. the WebView's content may not be updated during the transition.
 If it is false, WebView will keep its fidelity. The default value is false.
@deprecated This method is now obsolete, and will become a no-op in future.
*/
setEnableSmoothTransition : function(  ) {},

/**Gets whether the WebView enables smooth transition while panning or
 zooming.
@see #setEnableSmoothTransition
@deprecated This method is now obsolete, and will become a no-op in future.
*/
enableSmoothTransition : function(  ) {},

/**Sets 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.
@deprecated This method is now obsolete.
@hide Since API level {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1}
*/
setUseWebViewBackgroundForOverscrollBackground : function(  ) {},

/**Gets whether this WebView uses WebView's background instead of
 internal pattern for over scroll background.
@see #setUseWebViewBackgroundForOverscrollBackground
@deprecated This method is now obsolete.
@hide Since API level {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1}
*/
getUseWebViewBackgroundForOverscrollBackground : function(  ) {},

/**Sets whether the WebView should save form data. The default is true.
*/
setSaveFormData : function(  ) {},

/**Gets whether the WebView saves form data.
@return {Boolean} whether the WebView saves form data
@see #setSaveFormData
*/
getSaveFormData : function(  ) {},

/**Sets whether the WebView should save passwords. The default is true.
@deprecated Saving passwords in WebView will not be supported in future versions.
*/
setSavePassword : function(  ) {},

/**Gets whether the WebView saves passwords.
@return {Boolean} whether the WebView saves passwords
@see #setSavePassword
@deprecated Saving passwords in WebView will not be supported in future versions.
*/
getSavePassword : function(  ) {},

/**Sets the text zoom of the page in percent. The default is 100.
@param {Number} textZoom the text zoom in percent
*/
setTextZoom : function(  ) {},

/**Gets the text zoom of the page in percent.
@return {Number} the text zoom of the page in percent
@see #setTextZoom
*/
getTextZoom : function(  ) {},

/**Sets policy for third party cookies.
 Developers should access this via {@link android.webkit.CookieManager#setShouldAcceptThirdPartyCookies}.
@hide Internal API.
*/
setAcceptThirdPartyCookies : function(  ) {},

/**Gets policy for third party cookies.
 Developers should access this via {@link android.webkit.CookieManager#getShouldAcceptThirdPartyCookies}.
@hide Internal API
*/
getAcceptThirdPartyCookies : function(  ) {},

/**Sets the text size of the page. The default is {@link android.webkit.WebSettings.TextSize#NORMAL}.
@param {Object {WebSettings.TextSize}} t the text size as a {@link TextSize} value
@deprecated Use {@link #setTextZoom} instead.
*/
setTextSize : function(  ) {},

/**Gets the text size of the page. If the text size was previously specified
 in percent using {@link #setTextZoom}, this will return the closest
 matching {@link android.webkit.WebSettings.TextSize}.
@return {Object {android.webkit.WebSettings.TextSize}} the text size as a {@link TextSize} value
@see #setTextSize
@deprecated Use {@link #getTextZoom} instead.
*/
getTextSize : function(  ) {},

/**Sets the default zoom density of the page. This must be called from the UI
 thread. The default is {@link android.webkit.WebSettings.ZoomDensity#MEDIUM}.

 This setting is not recommended for use in new applications.  If the WebView
 is utilized to display mobile-oriented pages, the desired effect can be achieved by
 adjusting 'width' and 'initial-scale' attributes of page's 'meta viewport'
 tag. For pages lacking the tag, {@link android.webkit.WebView#setInitialScale}
 and {@link #setUseWideViewPort} can be used.
@param {Object {WebSettings.ZoomDensity}} zoom the zoom density
@deprecated This method is no longer supported, see the function documentation for
             recommended alternatives.
*/
setDefaultZoom : function(  ) {},

/**Gets the default zoom density of the page. This should be called from
 the UI thread.

 This setting is not recommended for use in new applications.
@return {Object {android.webkit.WebSettings.ZoomDensity}} the zoom density
@see #setDefaultZoom
@deprecated Will only return the default value.
*/
getDefaultZoom : function(  ) {},

/**Enables using light touches to make a selection and activate mouseovers.
@deprecated From {@link android.os.Build.VERSION_CODES#JELLY_BEAN} this
             setting is obsolete and has no effect.
*/
setLightTouchEnabled : function(  ) {},

/**Gets whether light touches are enabled.
@see #setLightTouchEnabled
@deprecated This setting is obsolete.
*/
getLightTouchEnabled : function(  ) {},

/**Controlled a rendering optimization that is no longer present. Setting
 it now has no effect.
@deprecated This setting now has no effect.
@hide Since API level {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1}
*/
setUseDoubleTree : function(  ) {},

/**Controlled a rendering optimization that is no longer present. Setting
 it now has no effect.
@deprecated This setting now has no effect.
@hide Since API level {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1}
*/
getUseDoubleTree : function(  ) {},

/**Sets the user-agent string using an integer code.
 <ul>
   <li>0 means the WebView should use an Android user-agent string</li>
   <li>1 means the WebView should use a desktop user-agent string</li>
 </ul>
 Other values are ignored. The default is an Android user-agent string,
 i.e. code value 0.
@param {Number} ua the integer code for the user-agent string
@deprecated Please use {@link #setUserAgentString} instead.
@hide Since API level {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1}
*/
setUserAgent : function(  ) {},

/**Gets the user-agent as an integer code.
 <ul>
   <li>-1 means the WebView is using a custom user-agent string set with
   {@link #setUserAgentString}</li>
   <li>0 means the WebView should use an Android user-agent string</li>
   <li>1 means the WebView should use a desktop user-agent string</li>
 </ul>
@return {Number} the integer code for the user-agent string
@see #setUserAgent
@deprecated Please use {@link #getUserAgentString} instead.
@hide Since API level {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1}
*/
getUserAgent : function(  ) {},

/**Sets whether the WebView should enable support for the &quot;viewport&quot;
 HTML meta tag or should use a wide viewport.
 When the value of the setting is false, the layout width is always set to the
 width of the WebView control in device-independent (CSS) pixels.
 When the value is true and the page contains the viewport meta tag, the value
 of the width specified in the tag is used. If the page does not contain the tag or
 does not provide a width, then a wide viewport will be used.
@param {Boolean} use whether to enable support for the viewport meta tag
*/
setUseWideViewPort : function(  ) {},

/**Gets whether the WebView supports the &quot;viewport&quot;
 HTML meta tag or will use a wide viewport.
@return {Boolean} true if the WebView supports the viewport meta tag
@see #setUseWideViewPort
*/
getUseWideViewPort : function(  ) {},

/**Sets whether the WebView whether supports multiple windows. If set to
 true, {@link android.webkit.WebChromeClient#onCreateWindow} must be implemented by the
 host application. The default is false.
@param {Boolean} support whether to suport multiple windows
*/
setSupportMultipleWindows : function(  ) {},

/**Gets whether the WebView supports multiple windows.
@return {Boolean} true if the WebView supports multiple windows
@see #setSupportMultipleWindows
*/
supportMultipleWindows : function(  ) {},

/**Sets the underlying layout algorithm. This will cause a relayout of the
 WebView. The default is {@link android.webkit.WebSettings.LayoutAlgorithm#NARROW_COLUMNS}.
@param {Object {WebSettings.LayoutAlgorithm}} l the layout algorithm to use, as a {@link LayoutAlgorithm} value
*/
setLayoutAlgorithm : function(  ) {},

/**Gets the current layout algorithm.
@return {Object {android.webkit.WebSettings.LayoutAlgorithm}} the layout algorithm in use, as a {@link LayoutAlgorithm} value
@see #setLayoutAlgorithm
*/
getLayoutAlgorithm : function(  ) {},

/**Sets the standard font family name. The default is "sans-serif".
@param {String} font a font family name
*/
setStandardFontFamily : function(  ) {},

/**Gets the standard font family name.
@return {String} the standard font family name as a string
@see #setStandardFontFamily
*/
getStandardFontFamily : function(  ) {},

/**Sets the fixed font family name. The default is "monospace".
@param {String} font a font family name
*/
setFixedFontFamily : function(  ) {},

/**Gets the fixed font family name.
@return {String} the fixed font family name as a string
@see #setFixedFontFamily
*/
getFixedFontFamily : function(  ) {},

/**Sets the sans-serif font family name. The default is "sans-serif".
@param {String} font a font family name
*/
setSansSerifFontFamily : function(  ) {},

/**Gets the sans-serif font family name.
@return {String} the sans-serif font family name as a string
@see #setSansSerifFontFamily
*/
getSansSerifFontFamily : function(  ) {},

/**Sets the serif font family name. The default is "sans-serif".
@param {String} font a font family name
*/
setSerifFontFamily : function(  ) {},

/**Gets the serif font family name. The default is "serif".
@return {String} the serif font family name as a string
@see #setSerifFontFamily
*/
getSerifFontFamily : function(  ) {},

/**Sets the cursive font family name. The default is "cursive".
@param {String} font a font family name
*/
setCursiveFontFamily : function(  ) {},

/**Gets the cursive font family name.
@return {String} the cursive font family name as a string
@see #setCursiveFontFamily
*/
getCursiveFontFamily : function(  ) {},

/**Sets the fantasy font family name. The default is "fantasy".
@param {String} font a font family name
*/
setFantasyFontFamily : function(  ) {},

/**Gets the fantasy font family name.
@return {String} the fantasy font family name as a string
@see #setFantasyFontFamily
*/
getFantasyFontFamily : function(  ) {},

/**Sets the minimum font size. The default is 8.
@param {Number} size a non-negative integer between 1 and 72. Any number outside
             the specified range will be pinned.
*/
setMinimumFontSize : function(  ) {},

/**Gets the minimum font size.
@return {Number} a non-negative integer between 1 and 72
@see #setMinimumFontSize
*/
getMinimumFontSize : function(  ) {},

/**Sets the minimum logical font size. The default is 8.
@param {Number} size a non-negative integer between 1 and 72. Any number outside
             the specified range will be pinned.
*/
setMinimumLogicalFontSize : function(  ) {},

/**Gets the minimum logical font size.
@return {Number} a non-negative integer between 1 and 72
@see #setMinimumLogicalFontSize
*/
getMinimumLogicalFontSize : function(  ) {},

/**Sets the default font size. The default is 16.
@param {Number} size a non-negative integer between 1 and 72. Any number outside
             the specified range will be pinned.
*/
setDefaultFontSize : function(  ) {},

/**Gets the default font size.
@return {Number} a non-negative integer between 1 and 72
@see #setDefaultFontSize
*/
getDefaultFontSize : function(  ) {},

/**Sets the default fixed font size. The default is 16.
@param {Number} size a non-negative integer between 1 and 72. Any number outside
             the specified range will be pinned.
*/
setDefaultFixedFontSize : function(  ) {},

/**Gets the default fixed font size.
@return {Number} a non-negative integer between 1 and 72
@see #setDefaultFixedFontSize
*/
getDefaultFixedFontSize : function(  ) {},

/**Sets whether the WebView should load image resources. Note that this method
 controls loading of all images, including those embedded using the data
 URI scheme. Use {@link #setBlockNetworkImage} to control loading only
 of images specified using network URI schemes. Note that if the value of this
 setting is changed from false to true, all images resources referenced
 by content currently displayed by the WebView are loaded automatically.
 The default is true.
@param {Boolean} flag whether the WebView should load image resources
*/
setLoadsImagesAutomatically : function(  ) {},

/**Gets whether the WebView loads image resources. This includes
 images embedded using the data URI scheme.
@return {Boolean} true if the WebView loads image resources
@see #setLoadsImagesAutomatically
*/
getLoadsImagesAutomatically : function(  ) {},

/**Sets whether the WebView should not load image resources from the
 network (resources accessed via http and https URI schemes).  Note
 that this method has no effect unless
 {@link #getLoadsImagesAutomatically} returns true. Also note that
 disabling all network loads using {@link #setBlockNetworkLoads}
 will also prevent network images from loading, even if this flag is set
 to false. When the value of this setting is changed from true to false,
 network images resources referenced by content currently displayed by
 the WebView are fetched automatically. The default is false.
@param {Boolean} flag whether the WebView should not load image resources from the
             network
@see #setBlockNetworkLoads
*/
setBlockNetworkImage : function(  ) {},

/**Gets whether the WebView does not load image resources from the network.
@return {Boolean} true if the WebView does not load image resources from the network
@see #setBlockNetworkImage
*/
getBlockNetworkImage : function(  ) {},

/**Sets whether the WebView should not load resources from the network.
 Use {@link #setBlockNetworkImage} to only avoid loading
 image resources. Note that if the value of this setting is
 changed from true to false, network resources referenced by content
 currently displayed by the WebView are not fetched until
 {@link android.webkit.WebView#reload} is called.
 If the application does not have the
 {@link android.Manifest.permission#INTERNET} permission, attempts to set
 a value of false will cause a {@link java.lang.SecurityException}
 to be thrown. The default value is false if the application has the
 {@link android.Manifest.permission#INTERNET} permission, otherwise it is
 true.
@param {Boolean} flag whether the WebView should not load any resources from the
             network
@see android.webkit.WebView#reload
*/
setBlockNetworkLoads : function(  ) {},

/**Gets whether the WebView does not load any resources from the network.
@return {Boolean} true if the WebView does not load any resources from the network
@see #setBlockNetworkLoads
*/
getBlockNetworkLoads : function(  ) {},

/**Tells the WebView to enable JavaScript execution.
 <b>The default is false.</b>
@param {Boolean} flag true if the WebView should execute JavaScript
*/
setJavaScriptEnabled : function(  ) {},

/**Sets whether JavaScript running in the context of a file scheme URL
 should be allowed to access content from any origin. This includes
 access to content from other file scheme URLs. See
 {@link #setAllowFileAccessFromFileURLs}. To enable the most restrictive,
 and therefore secure policy, this setting should be disabled.
 Note that this setting affects only JavaScript access to file scheme
 resources. Other access to such resources, for example, from image HTML
 elements, is unaffected. To prevent possible violation of same domain policy
 on {@link android.os.Build.VERSION_CODES#ICE_CREAM_SANDWICH} and earlier
 devices, you should explicitly set this value to {@code false}.
 <p>
 The default value is true for API level
 {@link android.os.Build.VERSION_CODES#ICE_CREAM_SANDWICH_MR1} and below,
 and false for API level {@link android.os.Build.VERSION_CODES#JELLY_BEAN}
 and above.
@param {Boolean} flag whether JavaScript running in the context of a file scheme
             URL should be allowed to access content from any origin
*/
setAllowUniversalAccessFromFileURLs : function(  ) {},

/**Sets whether JavaScript running in the context of a file scheme URL
 should be allowed to access content from other file scheme URLs. To
 enable the most restrictive, and therefore secure policy, this setting
 should be disabled. Note that the value of this setting is ignored if
 the value of {@link #getAllowUniversalAccessFromFileURLs} is true.
 Note too, that this setting affects only JavaScript access to file scheme
 resources. Other access to such resources, for example, from image HTML
 elements, is unaffected. To prevent possible violation of same domain policy
 on {@link android.os.Build.VERSION_CODES#ICE_CREAM_SANDWICH} and earlier
 devices, you should explicitly set this value to {@code false}.
 <p>
 The default value is true for API level
 {@link android.os.Build.VERSION_CODES#ICE_CREAM_SANDWICH_MR1} and below,
 and false for API level {@link android.os.Build.VERSION_CODES#JELLY_BEAN}
 and above.
@param {Boolean} flag whether JavaScript running in the context of a file scheme
             URL should be allowed to access content from other file
             scheme URLs
*/
setAllowFileAccessFromFileURLs : function(  ) {},

/**Sets whether the WebView should enable plugins. The default is false.
@param {Boolean} flag true if plugins should be enabled
@deprecated This method has been deprecated in favor of
             {@link #setPluginState}
@hide Since API level {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}
*/
setPluginsEnabled : function(  ) {},

/**Tells 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. The default is
 {@link android.webkit.PluginState#OFF}.
@param {Object {WebSettings.PluginState}} state a PluginState value
@deprecated Plugins will not be supported in future, and should not be used.
*/
setPluginState : function(  ) {},

/**Sets a custom path to plugins used by the WebView. This method is
 obsolete since each plugin is now loaded from its own package.
@param {String} pluginsPath a 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.
@hide Since API level {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}
*/
setPluginsPath : function(  ) {},

/**Sets the path to where database storage API databases should be saved.
 In order for the database storage API to function correctly, this method
 must be called with a path to which the application can write. This
 method should only be called once: repeated calls are ignored.
@param {String} databasePath a path to the directory where databases should be
                     saved.
@deprecated Database paths are managed by the implementation and calling this method
             will have no effect.
*/
setDatabasePath : function(  ) {},

/**Sets the path where the Geolocation databases should be saved. In order
 for Geolocation permissions and cached positions to be persisted, this
 method must be called with a path to which the application can write.
@param {String} databasePath a path to the directory where databases should be
                     saved.
*/
setGeolocationDatabasePath : function(  ) {},

/**Sets whether the Application Caches API should be enabled. The default
 is false. Note that in order for the Application Caches API to be
 enabled, a valid database path must also be supplied to
 {@link #setAppCachePath}.
@param {Boolean} flag true if the WebView should enable Application Caches
*/
setAppCacheEnabled : function(  ) {},

/**Sets the path to the Application Caches files. In order for the
 Application Caches API to be enabled, this method must be called with a
 path to which the application can write. This method should only be
 called once: repeated calls are ignored.
@param {String} appCachePath a String path to the directory containing
                     Application Caches files.
@see #setAppCacheEnabled
*/
setAppCachePath : function(  ) {},

/**Sets the maximum size for the Application Cache content. The passed size
 will be rounded to the nearest value that the database can support, so
 this should be viewed as a guide, not a hard limit. Setting the
 size to a value less than current database size does not cause the
 database to be trimmed. The default size is {@link Long#MAX_VALUE}.
 It is recommended to leave the maximum size set to the default value.
@param {Number} appCacheMaxSize the maximum size in bytes
@deprecated In future quota will be managed automatically.
*/
setAppCacheMaxSize : function(  ) {},

/**Sets whether the database storage API is enabled. The default value is
 false. See also {@link #setDatabasePath} for how to correctly set up the
 database storage API.

 This setting is global in effect, across all WebView instances in a process.
 Note you should only modify this setting prior to making <b>any</b> WebView
 page load within a given process, as the WebView implementation may ignore
 changes to this setting after that point.
@param {Boolean} flag true if the WebView should use the database storage API
*/
setDatabaseEnabled : function(  ) {},

/**Sets whether the DOM storage API is enabled. The default value is false.
@param {Boolean} flag true if the WebView should use the DOM storage API
*/
setDomStorageEnabled : function(  ) {},

/**Gets whether the DOM Storage APIs are enabled.
@return {Boolean} true if the DOM Storage APIs are enabled
@see #setDomStorageEnabled
*/
getDomStorageEnabled : function(  ) {},

/**Gets the path to where database storage API databases are saved.
@return {String} the String path to the database storage API databases
@see #setDatabasePath
@deprecated Database paths are managed by the implementation this method is obsolete.
*/
getDatabasePath : function(  ) {},

/**Gets whether the database storage API is enabled.
@return {Boolean} true if the database storage API is enabled
@see #setDatabaseEnabled
*/
getDatabaseEnabled : function(  ) {},

/**Sets whether Geolocation is enabled. The default is true.
 <p>
 Please note that in order for the Geolocation API to be usable
 by a page in the WebView, the following requirements must be met:
 <ul>
   <li>an application must have permission to access the device location,
   see {@link android.Manifest.permission#ACCESS_COARSE_LOCATION},
   {@link android.Manifest.permission#ACCESS_FINE_LOCATION};
   <li>an application must provide an implementation of the
   {@link android.webkit.WebChromeClient#onGeolocationPermissionsShowPrompt} callback
   to receive notifications that a page is requesting access to location
   via the JavaScript Geolocation API.
 </ul>
 <p>
 As an option, it is possible to store previous locations and web origin
 permissions in a database. See {@link #setGeolocationDatabasePath}.
@param {Boolean} flag whether Geolocation should be enabled
*/
setGeolocationEnabled : function(  ) {},

/**Gets whether JavaScript is enabled.
@return {Boolean} true if JavaScript is enabled
@see #setJavaScriptEnabled
*/
getJavaScriptEnabled : function(  ) {},

/**Gets whether JavaScript running in the context of a file scheme URL can
 access content from any origin. This includes access to content from
 other file scheme URLs.
@return {Boolean} whether JavaScript running in the context of a file scheme URL
         can access content from any origin
@see #setAllowUniversalAccessFromFileURLs
*/
getAllowUniversalAccessFromFileURLs : function(  ) {},

/**Gets whether JavaScript running in the context of a file scheme URL can
 access content from other file scheme URLs.
@return {Boolean} whether JavaScript running in the context of a file scheme URL
         can access content from other file scheme URLs
@see #setAllowFileAccessFromFileURLs
*/
getAllowFileAccessFromFileURLs : function(  ) {},

/**Gets whether plugins are enabled.
@return {Boolean} true if plugins are enabled
@see #setPluginsEnabled
@deprecated This method has been replaced by {@link #getPluginState}
@hide Since API level {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}
*/
getPluginsEnabled : function(  ) {},

/**Gets the current state regarding whether plugins are enabled.
@return {Object {android.webkit.WebSettings.PluginState}} the plugin state as a {@link PluginState} value
@see #setPluginState
@deprecated Plugins will not be supported in future, and should not be used.
*/
getPluginState : function(  ) {},

/**Gets the directory that contains the plugin libraries. This method is
 obsolete since each plugin is now loaded from its own package.
@return {String} an empty string
@deprecated This method is no longer used as plugins are loaded from
 their own APK via the system's package manager.
@hide Since API level {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}
*/
getPluginsPath : function(  ) {},

/**Tells JavaScript to open windows automatically. This applies to the
 JavaScript function window.open(). The default is false.
@param {Boolean} flag true if JavaScript can open windows automatically
*/
setJavaScriptCanOpenWindowsAutomatically : function(  ) {},

/**Gets whether JavaScript can open windows automatically.
@return {Boolean} true if JavaScript can open windows automatically during
         window.open()
@see #setJavaScriptCanOpenWindowsAutomatically
*/
getJavaScriptCanOpenWindowsAutomatically : function(  ) {},

/**Sets the default text encoding name to use when decoding html pages.
 The default is "UTF-8".
@param {String} encoding the text encoding name
*/
setDefaultTextEncodingName : function(  ) {},

/**Gets the default text encoding name.
@return {String} the default text encoding name as a string
@see #setDefaultTextEncodingName
*/
getDefaultTextEncodingName : function(  ) {},

/**Sets the WebView's user-agent string. If the string is null or empty,
 the system default value will be used.

 Note that starting from {@link android.os.Build.VERSION_CODES#KITKAT} Android
 version, changing the user-agent while loading a web page causes WebView
 to initiate loading once again.
@param {String} ua new user-agent string
*/
setUserAgentString : function(  ) {},

/**Gets the WebView's user-agent string.
@return {String} the WebView's user-agent string
@see #setUserAgentString
*/
getUserAgentString : function(  ) {},

/**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 android.webkit.WebSettings#setUserAgentString(String)}.
@param {Object {Context}} context a Context object used to access application assets
*/
getDefaultUserAgent : function(  ) {},

/**Tells the WebView whether it needs to set a node to have focus when
 {@link android.webkit.WebView#requestFocus(int, android.graphics.Rect)} is called. The
 default value is true.
@param {Boolean} flag whether the WebView needs to set a node
*/
setNeedInitialFocus : function(  ) {},

/**Sets the priority of the Render thread. Unlike the other settings, this
 one only needs to be called once per process. The default value is
 {@link android.webkit.WebSettings.RenderPriority#NORMAL}.
@param {Object {WebSettings.RenderPriority}} priority the priority
@deprecated It is not recommended to adjust thread priorities, and this will
             not be supported in future versions.
*/
setRenderPriority : function(  ) {},

/**Overrides the way the cache is used. The way the cache is used is based
 on the navigation type. 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 retrieved from the cache.
 This method allows the client to override this behavior by specifying
 one of {@link #LOAD_DEFAULT},
 {@link #LOAD_CACHE_ELSE_NETWORK}, {@link #LOAD_NO_CACHE} or
 {@link #LOAD_CACHE_ONLY}. The default value is {@link #LOAD_DEFAULT}.
@param {Number} mode the mode to use
*/
setCacheMode : function(  ) {},

/**Gets the current setting for overriding the cache mode.
@return {Number} the current setting for overriding the cache mode
@see #setCacheMode
*/
getCacheMode : function(  ) {},

/**Configures the WebView's behavior when a secure origin attempts to load a resource from an
 insecure origin.

 By default, apps that target {@link android.os.Build.VERSION_CODES#KITKAT} or below default
 to {@link #MIXED_CONTENT_ALWAYS_ALLOW}. Apps targeting
 {@link android.os.Build.VERSION_CODES#LOLLIPOP} default to {@link #MIXED_CONTENT_NEVER_ALLOW}.

 The preferred and most secure mode of operation for the WebView is
 {@link #MIXED_CONTENT_NEVER_ALLOW} and use of {@link #MIXED_CONTENT_ALWAYS_ALLOW} is
 strongly discouraged.
@param {Number} mode The mixed content mode to use. One of {@link #MIXED_CONTENT_NEVER_ALLOW},
     {@link #MIXED_CONTENT_ALWAYS_ALLOW} or {@link #MIXED_CONTENT_COMPATIBILITY_MODE}.
*/
setMixedContentMode : function(  ) {},

/**Gets the current behavior of the WebView with regard to loading insecure content from a
 secure origin.
@return {Number} The current setting, one of {@link #MIXED_CONTENT_NEVER_ALLOW},
     {@link #MIXED_CONTENT_ALWAYS_ALLOW} or {@link #MIXED_CONTENT_COMPATIBILITY_MODE}.
*/
getMixedContentMode : function(  ) {},

/**Sets whether to use a video overlay for embedded encrypted video.
 In API levels prior to {@link android.os.Build.VERSION_CODES#LOLLIPOP}, encrypted video can
 only be rendered directly on a secure video surface, so it had been a hard problem to play
 encrypted video in HTML.  When this flag is on, WebView can play encrypted video (MSE/EME)
 by using a video overlay (aka hole-punching) for videos embedded using HTML &lt;video&gt;
 tag.<br>
 Caution: This setting is intended for use only in a narrow set of circumstances and apps
 should only enable it if they require playback of encrypted video content. It will impose
 the following limitations on the WebView:
 <ul>
 <li> Only one video overlay can be played at a time.
 <li> Changes made to position or dimensions of a video element may be propagated to the
 corresponding video overlay with a noticeable delay.
 <li> The video overlay is not visible to web APIs and as such may not interact with
 script or styling. For example, CSS styles applied to the &lt;video&gt; tag may be ignored.
 </ul>
 This is not an exhaustive set of constraints and it may vary with new versions of the
 WebView.
@hide 
*/
setVideoOverlayForEmbeddedEncryptedVideoEnabled : function(  ) {},

/**Gets whether a video overlay will be used for embedded encrypted video.
@return {Boolean} true if WebView uses a video overlay for embedded encrypted video.
@see #setVideoOverlayForEmbeddedEncryptedVideoEnabled
@hide 
*/
getVideoOverlayForEmbeddedEncryptedVideoEnabled : function(  ) {},

/**Sets whether this WebView should raster tiles when it is
 offscreen but attached to a window. Turning this on can avoid
 rendering artifacts when animating an offscreen WebView on-screen.
 Offscreen WebViews in this mode use more memory. The default value is
 false.<br>
 Please follow these guidelines to limit memory usage:
 <ul>
 <li> WebView size should be not be larger than the device screen size.
 <li> Limit use of this mode to a small number of WebViews. Use it for
   visible WebViews and WebViews about to be animated to visible.
 </ul>
*/
setOffscreenPreRaster : function(  ) {},

/**Gets whether this WebView should raster tiles when it is
 offscreen but attached to a window.
@return {Boolean} true if this WebView will raster tiles when it is
 offscreen but attached to a window.
*/
getOffscreenPreRaster : function(  ) {},


};