Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * Copyright (C) 2006 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.os.Bundle;
  import android.os.Looper;
  import android.util.Log;
  import android.view.View;
  
  import java.io.File;
  import java.util.Map;

A View that displays web pages. This class is the basis upon which you can roll your own web browser or simply display some online content within your Activity. It uses the WebKit rendering engine to display web pages and includes methods to navigate forward and backward through a history, zoom in and out, perform text searches and more.

To enable the built-in zoom, set WebSettings.WebSettings.setBuiltInZoomControls(boolean) (introduced in API level android.os.Build.VERSION_CODES.CUPCAKE).

Note that, in order for your Activity to access the Internet and load web pages in a WebView, you must add the INTERNET permissions to your Android Manifest file:

<uses-permission android:name="android.permission.INTERNET" />

This must be a child of the <manifest> element.

For more information, read Building Web Apps in WebView.

Basic usage

By default, a WebView provides no browser-like widgets, does not enable JavaScript and web page errors are ignored. If your goal is only to display some HTML as a part of your UI, this is probably fine; the user won't need to interact with the web page beyond reading it, and the web page won't need to interact with the user. If you actually want a full-blown web browser, then you probably want to invoke the Browser application with a URL Intent rather than show it with a WebView. For example:

 Uri uri = Uri.parse("http://www.example.com");
 Intent intent = new Intent(Intent.ACTION_VIEW, uri);
 startActivity(intent);
 

See android.content.Intent for more information.

To provide a WebView in your own Activity, include a <WebView> in your layout, or set the entire Activity window as a WebView during android.app.Activity.onCreate(android.os.Bundle):

 WebView webview = new WebView(this);
 setContentView(webview);
 

Then load the desired web page:

 // Simplest usage: note that an exception will NOT be thrown
 // if there is an error loading this page (see below).
 webview.loadUrl("http://slashdot.org/");

 // OR, you can also load from an HTML string:
 String summary = "<html><body>You scored <b>192</b> points.</body></html>";
 webview.loadData(summary, "text/html", null);
 // ... although note that there are restrictions on what this HTML can do.
 // See the JavaDocs for loadData() and loadDataWithBaseURL(java.lang.String,java.lang.String,java.lang.String,java.lang.String,java.lang.String) for more info.
 

A WebView has several customization points where you can add your own behavior. These are:

Here's a more complicated example, showing error handling, settings, and progress notification:

 // Let's display the progress in the activity title bar, like the
 // browser app does.
 getWindow().requestFeature(Window.FEATURE_PROGRESS);

 webview.getSettings().setJavaScriptEnabled(true);

 final Activity activity = this;
 webview.setWebChromeClient(new WebChromeClient() {
   public void onProgressChanged(WebView view, int progress) {
     // Activities and WebViews measure progress with different scales.
     // The progress meter will automatically disappear when we reach 100%
     activity.setProgress(progress * 1000);
   }
 });
 webview.setWebViewClient(new WebViewClient() {
   public void onReceivedError(WebView view, int errorCode, String description, String failingUrl) {
     Toast.makeText(activity, "Oh no! " + description, Toast.LENGTH_SHORT).show();
   }
 });

 webview.loadUrl("http://slashdot.org/");
 

Cookie and window management

For obvious security reasons, your application has its own cache, cookie store etc.β€”it does not share the Browser application's data.

By default, requests by the HTML to open new windows are ignored. This is true whether they be opened by JavaScript or by the target attribute on a link. You can customize your WebChromeClient to provide your own behaviour for opening multiple windows, and render them in whatever manner you want.

The standard behavior for an Activity is to be destroyed and recreated when the device orientation or any other configuration changes. This will cause the WebView to reload the current page. If you don't want that, you can set your Activity to handle the orientation and keyboardHidden changes, and then just leave the WebView alone. It'll automatically re-orient itself as appropriate. Read Handling Runtime Changes for more information about how to handle configuration changes during runtime.

Building web pages to support different screen densities

The screen density of a device is based on the screen resolution. A screen with low density has fewer available pixels per inch, where a screen with high density has more β€” sometimes significantly more β€” pixels per inch. The density of a screen is important because, other things being equal, a UI element (such as a button) whose height and width are defined in terms of screen pixels will appear larger on the lower density screen and smaller on the higher density screen. For simplicity, Android collapses all actual screen densities into three generalized densities: high, medium, and low.

By default, WebView scales a web page so that it is drawn at a size that matches the default appearance on a medium density screen. So, it applies 1.5x scaling on a high density screen (because its pixels are smaller) and 0.75x scaling on a low density screen (because its pixels are bigger). Starting with API level android.os.Build.VERSION_CODES.ECLAIR, WebView supports DOM, CSS, and meta tag features to help you (as a web developer) target screens with different screen densities.

Here's a summary of the features you can use to handle different screen densities:

  • The window.devicePixelRatio DOM property. The value of this property specifies the default scaling factor used for the current device. For example, if the value of window.devicePixelRatio is "1.0", then the device is considered a medium density (mdpi) device and default scaling is not applied to the web page; if the value is "1.5", then the device is considered a high density device (hdpi) and the page content is scaled 1.5x; if the value is "0.75", then the device is considered a low density device (ldpi) and the content is scaled 0.75x. However, if you specify the "target-densitydpi" meta property (discussed below), then you can stop this default scaling behavior.
  • The -webkit-device-pixel-ratio CSS media query. Use this to specify the screen densities for which this style sheet is to be used. The corresponding value should be either "0.75", "1", or "1.5", to indicate that the styles are for devices with low density, medium density, or high density screens, respectively. For example:
     <link rel="stylesheet" media="screen and (-webkit-device-pixel-ratio:1.5)" href="hdpi.css" />

    The hdpi.css stylesheet is only used for devices with a screen pixel ration of 1.5, which is the high density pixel ratio.

  • The target-densitydpi property for the viewport meta tag. You can use this to specify the target density for which the web page is designed, using the following values:
    • device-dpi - Use the device's native dpi as the target dpi. Default scaling never occurs.
    • high-dpi - Use hdpi as the target dpi. Medium and low density screens scale down as appropriate.
    • medium-dpi - Use mdpi as the target dpi. High density screens scale up and low density screens scale down. This is also the default behavior.
    • low-dpi - Use ldpi as the target dpi. Medium and high density screens scale up as appropriate.
    • <value> - Specify a dpi value to use as the target dpi (accepted values are 70-400).

    Here's an example meta tag to specify the target density:

    <meta name="viewport" content="target-densitydpi=device-dpi" />

If you want to modify your web page for different densities, by using the -webkit-device-pixel-ratio CSS media query and/or the window.devicePixelRatio DOM property, then you should set the target-densitydpi meta property to device-dpi. This stops Android from performing scaling in your web page and allows you to make the necessary adjustments for each density via CSS and JavaScript.

HTML5 Video support

In order to support inline HTML5 video in your application, you need to have hardware acceleration turned on, and set a WebChromeClient. For full screen support, implementations of WebChromeClient.onShowCustomView(android.view.View,android.webkit.WebChromeClient.CustomViewCallback) and WebChromeClient.onHideCustomView() are required, WebChromeClient.getVideoLoadingProgressView() is optional.

 
 // Implementation notes.
 // The WebView is a thin API class that delegates its public API to a backend WebViewProvider
 // class instance. WebView extends {@link AbsoluteLayout} for backward compatibility reasons.
 // Methods are delegated to the provider implementation: all public API methods introduced in this
 // file are fully delegated, whereas public and protected methods from the View base classes are
 // only delegated where a specific need exists for them to do so.
 public class WebView extends AbsoluteLayout
         implements ViewTreeObserver.OnGlobalFocusChangeListener,
 
     private static final String LOGTAG = "webview_proxy";

    
Transportation object for returning WebView across thread boundaries.
 
     public class WebViewTransport {
         private WebView mWebview;

        
Sets the WebView to the transportation object.

Parameters:
webview the WebView to transport
 
         public synchronized void setWebView(WebView webview) {
              = webview;
         }

        
Gets the WebView object.

Returns:
the transported WebView object
 
         public synchronized WebView getWebView() {
             return ;
         }
     }

    
URI scheme for telephone number.
 
     public static final String SCHEME_TEL = "tel:";
    
URI scheme for email address.
 
     public static final String SCHEME_MAILTO = "mailto:";
    
URI scheme for map address.
 
     public static final String SCHEME_GEO = "geo:0,0?q=";

    
Interface to listen for find results.
 
     public interface FindListener {
        
Notifies the listener about progress made by a find operation.

Parameters:
activeMatchOrdinal the zero-based ordinal of the currently selected match
numberOfMatches how many matches have been found
isDoneCounting whether the find operation has actually completed. The listener may be notified multiple times while the operation is underway, and the numberOfMatches value should not be considered final unless isDoneCounting is true.
 
         public void onFindResultReceived(int activeMatchOrdinalint numberOfMatches,
             boolean isDoneCounting);
     }

    
Interface to listen for new pictures as they change.

Deprecated:
This interface is now obsolete.
 
     @Deprecated
     public interface PictureListener {
        
Used to provide notification that the WebView's picture has changed. See WebView.capturePicture() for details of the picture.

Deprecated:
Deprecated due to internal changes.
Parameters:
view the WebView that owns the picture
picture the new picture
 
         @Deprecated
         public void onNewPicture(WebView viewPicture picture);
     }
 
     public static class HitTestResult {
        
Default HitTestResult, where the target is unknown.
 
         public static final int UNKNOWN_TYPE = 0;
        

Deprecated:
This type is no longer used.
 
         @Deprecated
         public static final int ANCHOR_TYPE = 1;
        
HitTestResult for hitting a phone number.
 
         public static final int PHONE_TYPE = 2;
        
HitTestResult for hitting a map address.
 
         public static final int GEO_TYPE = 3;
        
HitTestResult for hitting an email address.
 
         public static final int EMAIL_TYPE = 4;
        
HitTestResult for hitting an HTML::img tag.
 
         public static final int IMAGE_TYPE = 5;
        

Deprecated:
This type is no longer used.
 
         @Deprecated
         public static final int IMAGE_ANCHOR_TYPE = 6;
        
HitTestResult for hitting a HTML::a tag with src=http.
 
         public static final int SRC_ANCHOR_TYPE = 7;
        
HitTestResult for hitting a HTML::a tag with src=http + HTML::img.
 
         public static final int SRC_IMAGE_ANCHOR_TYPE = 8;
        
HitTestResult for hitting an edit text area.
 
         public static final int EDIT_TEXT_TYPE = 9;
 
         private int mType;
         private String mExtra;

        

Hide:
Only for use by WebViewProvider implementations
 
         public HitTestResult() {
              = ;
         }

        

Hide:
Only for use by WebViewProvider implementations
 
         public void setType(int type) {
              = type;
         }

        

Hide:
Only for use by WebViewProvider implementations
 
         public void setExtra(String extra) {
              = extra;
         }

        
Gets the type of the hit test result. See the XXX_TYPE constants defined in this class.

Returns:
the type of the hit test result
 
         public int getType() {
             return ;
         }

        
Gets additional type-dependant information about the result. See WebView.getHitTestResult() for details. May either be null or contain extra information about this result.

Returns:
additional type-dependant information about the result
 
         public String getExtra() {
             return ;
         }
     }

    
Constructs a new WebView with a Context object.

Parameters:
context a Context object used to access application assets
 
     public WebView(Context context) {
         this(contextnull);
     }

    
Constructs a new WebView with layout parameters.

Parameters:
context a Context object used to access application assets
attrs an AttributeSet passed to our parent
 
     public WebView(Context contextAttributeSet attrs) {
         this(contextattrs.....);
     }

    
Constructs a new WebView with layout parameters and a default style.

Parameters:
context a Context object used to access application assets
attrs an AttributeSet passed to our parent
defStyle the default style resource ID
 
     public WebView(Context contextAttributeSet attrsint defStyle) {
         this(contextattrsdefStylefalse);
     }

    
Constructs a new WebView with layout parameters and a default style.

Deprecated:
Private browsing is no longer supported directly via WebView and will be removed in a future release. Prefer using WebSettings, WebViewDatabase, CookieManager and WebStorage for fine-grained control of privacy data.
Parameters:
context a Context object used to access application assets
attrs an AttributeSet passed to our parent
defStyle the default style resource ID
privateBrowsing whether this WebView will be initialized in private mode
 
     @Deprecated
     public WebView(Context contextAttributeSet attrsint defStyle,
             boolean privateBrowsing) {
         this(contextattrsdefStylenullprivateBrowsing);
     }

    
Constructs a new WebView with layout parameters, a default style and a set of custom Javscript interfaces to be added to this WebView at initialization time. This guarantees that these interfaces will be available when the JS context is initialized.

Parameters:
context a Context object used to access application assets
attrs an AttributeSet passed to our parent
defStyle the default style resource ID
javaScriptInterfaces a Map of interface names, as keys, and object implementing those interfaces, as values
privateBrowsing whether this WebView will be initialized in private mode
Hide:
This is used internally by dumprendertree, as it requires the javaScript interfaces to be added synchronously, before a subsequent loadUrl call takes effect.
 
     @SuppressWarnings("deprecation")  // for super() call into deprecated base class constructor.
     protected WebView(Context contextAttributeSet attrsint defStyle,
             Map<StringObjectjavaScriptInterfacesboolean privateBrowsing) {
         super(contextattrsdefStyle);
         if (context == null) {
             throw new IllegalArgumentException("Invalid context argument");
         }
         checkThread();
 
         ensureProviderCreated();
         .init(javaScriptInterfacesprivateBrowsing);
     }

    
Specifies whether the horizontal scrollbar has overlay style.

Parameters:
overlay true if horizontal scrollbar should have overlay style
 
     public void setHorizontalScrollbarOverlay(boolean overlay) {
         checkThread();
         .setHorizontalScrollbarOverlay(overlay);
     }

    
Specifies whether the vertical scrollbar has overlay style.

Parameters:
overlay true if vertical scrollbar should have overlay style
 
     public void setVerticalScrollbarOverlay(boolean overlay) {
         checkThread();
         .setVerticalScrollbarOverlay(overlay);
     }

    
Gets whether horizontal scrollbar has overlay style.

Returns:
true if horizontal scrollbar has overlay style
 
     public boolean overlayHorizontalScrollbar() {
         checkThread();
         return .overlayHorizontalScrollbar();
     }

    
Gets whether vertical scrollbar has overlay style.

Returns:
true if vertical scrollbar has overlay style
 
     public boolean overlayVerticalScrollbar() {
         checkThread();
         return .overlayVerticalScrollbar();
     }

    
Gets the visible height (in pixels) of the embedded title bar (if any).

Deprecated:
This method is now obsolete.
Hide:
Since API level android.os.Build.VERSION_CODES.JELLY_BEAN_MR1
 
     public int getVisibleTitleHeight() {
         checkThread();
         return .getVisibleTitleHeight();
     }

    
Gets the SSL certificate for the main top-level page or null if there is no certificate (the site is not secure).

Returns:
the SSL certificate for the main top-level page
 
     public SslCertificate getCertificate() {
         checkThread();
         return .getCertificate();
     }

    
Sets the SSL certificate for the main top-level page.

Deprecated:
Calling this function has no useful effect, and will be ignored in future releases.
 
     @Deprecated
     public void setCertificate(SslCertificate certificate) {
         checkThread();
         .setCertificate(certificate);
     }
 
     //-------------------------------------------------------------------------
     // Methods called by activity
     //-------------------------------------------------------------------------
 
    
Sets a username and password pair for the specified host. This data is used by the Webview to autocomplete username and password fields in web forms. Note that this is unrelated to the credentials used for HTTP authentication.

Parameters:
host the host that required the credentials
username the username for the given host
password the password for the given host
See also:
WebViewDatabase.clearUsernamePassword()
WebViewDatabase.hasUsernamePassword()
 
     public void savePassword(String hostString usernameString password) {
         checkThread();
         .savePassword(hostusernamepassword);
     }

    
Stores HTTP authentication credentials for a given host and realm. This method is intended to be used with WebViewClient.onReceivedHttpAuthRequest(android.webkit.WebView,android.webkit.HttpAuthHandler,java.lang.String,java.lang.String).

Parameters:
host the host to which the credentials apply
realm the realm to which the credentials apply
username the username
password the password
See also:
getHttpAuthUsernamePassword
WebViewDatabase.hasHttpAuthUsernamePassword()
WebViewDatabase.clearHttpAuthUsernamePassword()
 
     public void setHttpAuthUsernamePassword(String hostString realm,
             String usernameString password) {
         checkThread();
         .setHttpAuthUsernamePassword(hostrealmusernamepassword);
     }

    
Retrieves HTTP authentication credentials for a given host and realm. This method is intended to be used with WebViewClient.onReceivedHttpAuthRequest(android.webkit.WebView,android.webkit.HttpAuthHandler,java.lang.String,java.lang.String).

Parameters:
host the host to which the credentials apply
realm the realm to which the credentials apply
Returns:
the credentials as a String array, if found. The first element is the username and the second element is the password. Null if no credentials are found.
See also:
setHttpAuthUsernamePassword
WebViewDatabase.hasHttpAuthUsernamePassword()
WebViewDatabase.clearHttpAuthUsernamePassword()
 
     public String[] getHttpAuthUsernamePassword(String hostString realm) {
         checkThread();
         return .getHttpAuthUsernamePassword(hostrealm);
     }

    
Destroys the internal state of this WebView. This method should be called after this WebView has been removed from the view system. No other methods may be called on this WebView after destroy.
 
     public void destroy() {
         checkThread();
         .destroy();
     }

    
Enables platform notifications of data state and proxy changes. Notifications are enabled by default.

Deprecated:
This method is now obsolete.
Hide:
Since API level android.os.Build.VERSION_CODES.JELLY_BEAN_MR1
 
     @Deprecated
     public static void enablePlatformNotifications() {
         checkThread();
     }

    
Disables platform notifications of data state and proxy changes. Notifications are enabled by default.

Deprecated:
This method is now obsolete.
Hide:
Since API level android.os.Build.VERSION_CODES.JELLY_BEAN_MR1
 
     @Deprecated
     public static void disablePlatformNotifications() {
         checkThread();
     }

    
Informs WebView of the network state. This is used to set the JavaScript property window.navigator.isOnline and generates the online/offline event as specified in HTML5, sec. 5.7.7

Parameters:
networkUp a boolean indicating if network is available
 
     public void setNetworkAvailable(boolean networkUp) {
         checkThread();
         .setNetworkAvailable(networkUp);
     }

    
Saves the state of this WebView used in android.app.Activity.onSaveInstanceState(android.os.Bundle). Please note that this method no longer stores the display data for this WebView. The previous behavior could potentially leak files if restoreState(android.os.Bundle) was never called.

Parameters:
outState the Bundle to store this WebView's state
Returns:
the same copy of the back/forward list used to save the state. If saveState fails, the returned list will be null.
 
     public WebBackForwardList saveState(Bundle outState) {
         checkThread();
         return .saveState(outState);
     }

    
Saves the current display data to the Bundle given. Used in conjunction with saveState(android.os.Bundle).

Deprecated:
This method is now obsolete.
Parameters:
b a Bundle to store the display data
dest the file to store the serialized picture data. Will be overwritten with this WebView's picture data.
Returns:
true if the picture was successfully saved
Hide:
Since API level android.os.Build.VERSION_CODES.JELLY_BEAN_MR1
 
     @Deprecated
     public boolean savePicture(Bundle bfinal File dest) {
         checkThread();
         return .savePicture(bdest);
     }

    
Restores the display data that was saved in savePicture(android.os.Bundle,java.io.File). Used in conjunction with restoreState(android.os.Bundle). Note that this will not work if this WebView is hardware accelerated.

Deprecated:
This method is now obsolete.
Parameters:
b a Bundle containing the saved display data
src the file where the picture data was stored
Returns:
true if the picture was successfully restored
Hide:
Since API level android.os.Build.VERSION_CODES.JELLY_BEAN_MR1
 
     @Deprecated
     public boolean restorePicture(Bundle bFile src) {
         checkThread();
         return .restorePicture(bsrc);
     }

    
Restores the state of this WebView from the given Bundle. This method is intended for use in android.app.Activity.onRestoreInstanceState(android.os.Bundle) and should be called to restore the state of this WebView. If it is called after this WebView has had a chance to build state (load pages, create a back/forward list, etc.) there may be undesirable side-effects. Please note that this method no longer restores the display data for this WebView.

Parameters:
inState the incoming Bundle of state
Returns:
the restored back/forward list or null if restoreState failed
 
     public WebBackForwardList restoreState(Bundle inState) {
         checkThread();
         return .restoreState(inState);
     }

    
Loads the given URL with the specified additional HTTP headers.

Parameters:
url the URL of the resource to load
additionalHttpHeaders the additional headers to be used in the HTTP request for this URL, specified as a map from name to value. Note that if this map contains any of the headers that are set by default by this WebView, such as those controlling caching, accept types or the User-Agent, their values may be overriden by this WebView's defaults.
 
     public void loadUrl(String urlMap<StringStringadditionalHttpHeaders) {
         checkThread();
         .loadUrl(urladditionalHttpHeaders);
     }

    
Loads the given URL.

Parameters:
url the URL of the resource to load
 
     public void loadUrl(String url) {
         checkThread();
         .loadUrl(url);
     }

    
Loads the URL with postData using "POST" method into this WebView. If url is not a network URL, it will be loaded with {link loadUrl(java.lang.String) instead.

Parameters:
url the URL of the resource to load
postData the data will be passed to "POST" request
 
     public void postUrl(String urlbyte[] postData) {
         checkThread();
         .postUrl(urlpostData);
     }

    
Loads the given data into this WebView using a 'data' scheme URL.

Note that JavaScript's same origin policy means that script running in a page loaded using this method will be unable to access content loaded using any scheme other than 'data', including 'http(s)'. To avoid this restriction, use loadDataWithBaseURL(java.lang.String,java.lang.String,java.lang.String,java.lang.String,java.lang.String) with an appropriate base URL.

The encoding parameter specifies whether the data is base64 or URL encoded. If the data is base64 encoded, the value of the encoding parameter must be 'base64'. For all other values of the parameter, including null, it is assumed that the data uses ASCII encoding for octets inside the range of safe URL characters and use the standard %xx hex encoding of URLs for octets outside that range. For example, '#', '%', '\', '?' should be replaced by %23, %25, %27, %3f respectively.

The 'data' scheme URL formed by this method uses the default US-ASCII charset. If you need need to set a different charset, you should form a 'data' scheme URL which explicitly specifies a charset parameter in the mediatype portion of the URL and call loadUrl(java.lang.String) instead. Note that the charset obtained from the mediatype portion of a data URL always overrides that specified in the HTML or XML document itself.

Parameters:
data a String of data in the given encoding
mimeType the MIME type of the data, e.g. 'text/html'
encoding the encoding of the data
 
     public void loadData(String dataString mimeTypeString encoding) {
         checkThread();
         .loadData(datamimeTypeencoding);
     }

    
Loads the given data into this WebView, using baseUrl as the base URL for the content. The base URL is used both to resolve relative URLs and when applying JavaScript's same origin policy. The historyUrl is used for the history entry.

Note that content specified in this way can access local device files (via 'file' scheme URLs) only if baseUrl specifies a scheme other than 'http', 'https', 'ftp', 'ftps', 'about' or 'javascript'.

If the base URL uses the data scheme, this method is equivalent to calling loadData() and the historyUrl is ignored.

Parameters:
baseUrl the URL to use as the page's base URL. If null defaults to 'about:blank'.
data a String of data in the given encoding
mimeType the MIMEType of the data, e.g. 'text/html'. If null, defaults to 'text/html'.
encoding the encoding of the data
historyUrl the URL to use as the history entry. If null defaults to 'about:blank'.
 
     public void loadDataWithBaseURL(String baseUrlString data,
             String mimeTypeString encodingString historyUrl) {
         checkThread();
         .loadDataWithBaseURL(baseUrldatamimeTypeencodinghistoryUrl);
     }

    
Saves the current view as a web archive.

Parameters:
filename the filename where the archive should be placed
 
     public void saveWebArchive(String filename) {
         checkThread();
         .saveWebArchive(filename);
     }

    
Saves the current view as a web archive.

Parameters:
basename the filename where the archive should be placed
autoname if false, takes basename to be a file. If true, basename is assumed to be a directory in which a filename will be chosen according to the URL of the current page.
callback called after the web archive has been saved. The parameter for onReceiveValue will either be the filename under which the file was saved, or null if saving the file failed.
 
     public void saveWebArchive(String basenameboolean autonameValueCallback<Stringcallback) {
         checkThread();
         .saveWebArchive(basenameautonamecallback);
     }

    
Stops the current load.
 
     public void stopLoading() {
         checkThread();
         .stopLoading();
     }

    
Reloads the current URL.
 
     public void reload() {
         checkThread();
         .reload();
     }

    
Gets whether this WebView has a back history item.

Returns:
true iff this WebView has a back history item
 
     public boolean canGoBack() {
         checkThread();
         return .canGoBack();
     }

    
Goes back in the history of this WebView.
 
     public void goBack() {
         checkThread();
         .goBack();
     }

    
Gets whether this WebView has a forward history item.

Returns:
true iff this Webview has a forward history item
 
     public boolean canGoForward() {
         checkThread();
         return .canGoForward();
     }

    
Goes forward in the history of this WebView.
 
     public void goForward() {
         checkThread();
         .goForward();
     }

    
Gets whether the page can go back or forward the given number of steps.

Parameters:
steps the negative or positive number of steps to move the history
 
     public boolean canGoBackOrForward(int steps) {
         checkThread();
         return .canGoBackOrForward(steps);
     }

    
Goes to the history item that is the number of steps away from the current item. Steps is negative if backward and positive if forward.

Parameters:
steps the number of steps to take back or forward in the back forward list
 
     public void goBackOrForward(int steps) {
         checkThread();
         .goBackOrForward(steps);
     }

    
Gets whether private browsing is enabled in this WebView.
 
     public boolean isPrivateBrowsingEnabled() {
         checkThread();
         return .isPrivateBrowsingEnabled();
     }

    
Scrolls the contents of this WebView up by half the view size.

Parameters:
top true to jump to the top of the page
Returns:
true if the page was scrolled
 
     public boolean pageUp(boolean top) {
         checkThread();
         return .pageUp(top);
     }

    
Scrolls the contents of this WebView down by half the page size.

Parameters:
bottom true to jump to bottom of page
Returns:
true if the page was scrolled
 
     public boolean pageDown(boolean bottom) {
         checkThread();
         return .pageDown(bottom);
     }

    
Clears this WebView so that onDraw() will draw nothing but white background, and onMeasure() will return 0 if MeasureSpec is not MeasureSpec.EXACTLY.
    public void clearView() {
        checkThread();
        .clearView();
    }

    
Gets a new picture that captures the current contents of this WebView. The picture is of the entire document being displayed, and is not limited to the area currently displayed by this WebView. Also, the picture is a static copy and is unaffected by later changes to the content being displayed.

Note that due to internal changes, for API levels between android.os.Build.VERSION_CODES.HONEYCOMB and android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH inclusive, the picture does not include fixed position elements or scrollable divs.

Returns:
a picture that captures the current contents of this WebView
    public Picture capturePicture() {
        checkThread();
        return .capturePicture();
    }

    
Gets the current scale of this WebView.

Deprecated:
This method is prone to inaccuracy due to race conditions between the web rendering and UI threads; prefer WebViewClient.onScaleChanged(android.webkit.WebView,float,float).
Returns:
the current scale
    @ViewDebug.ExportedProperty(category = "webview")
    public float getScale() {
        checkThread();
        return .getScale();
    }

    
Sets the initial scale for this WebView. 0 means default. If WebSettings.getUseWideViewPort() is true, it zooms out all the way. Otherwise it starts with 100%. If initial scale is greater than 0, WebView starts with this value as initial scale. Please note that unlike the scale properties in the viewport meta tag, this method doesn't take the screen density into account.

Parameters:
scaleInPercent the initial scale in percent
    public void setInitialScale(int scaleInPercent) {
        checkThread();
        .setInitialScale(scaleInPercent);
    }

    
Invokes the graphical zoom picker widget for this WebView. This will result in the zoom widget appearing on the screen to control the zoom level of this WebView.
    public void invokeZoomPicker() {
        checkThread();
        .invokeZoomPicker();
    }

    
Gets a HitTestResult based on the current cursor node. If a HTML::a tag is found and the anchor has a non-JavaScript URL, the HitTestResult type is set to SRC_ANCHOR_TYPE and the URL is set in the "extra" field. If the anchor does not have a URL or if it is a JavaScript URL, the type will be UNKNOWN_TYPE and the URL has to be retrieved through requestFocusNodeHref(android.os.Message) asynchronously. If a HTML::img tag is found, the HitTestResult type is set to IMAGE_TYPE and the URL is set in the "extra" field. A type of SRC_IMAGE_ANCHOR_TYPE indicates an anchor with a URL that has an image as a child node. If a phone number is found, the HitTestResult type is set to PHONE_TYPE and the phone number is set in the "extra" field of HitTestResult. If a map address is found, the HitTestResult type is set to GEO_TYPE and the address is set in the "extra" field of HitTestResult. If an email address is found, the HitTestResult type is set to EMAIL_TYPE and the email is set in the "extra" field of HitTestResult. Otherwise, HitTestResult type is set to UNKNOWN_TYPE.
    public HitTestResult getHitTestResult() {
        checkThread();
        return .getHitTestResult();
    }

    
Requests the anchor or image element URL at the last tapped point. If hrefMsg is null, this method returns immediately and does not dispatch hrefMsg to its target. If the tapped point hits an image, an anchor, or an image in an anchor, the message associates strings in named keys in its data. The value paired with the key may be an empty string.

Parameters:
hrefMsg the message to be dispatched with the result of the request. The message data contains three keys. "url" returns the anchor's href attribute. "title" returns the anchor's text. "src" returns the image's src attribute.
    public void requestFocusNodeHref(Message hrefMsg) {
        checkThread();
        .requestFocusNodeHref(hrefMsg);
    }

    
Requests the URL of the image last touched by the user. msg will be sent to its target with a String representing the URL as its object.

Parameters:
msg the message to be dispatched with the result of the request as the data member with "url" as key. The result can be null.
    public void requestImageRef(Message msg) {
        checkThread();
        .requestImageRef(msg);
    }

    
Gets the URL for the current page. This is not always the same as the URL passed to WebViewClient.onPageStarted because although the load for that URL has begun, the current page may not have changed.

Returns:
the URL for the current page
    @ViewDebug.ExportedProperty(category = "webview")
    public String getUrl() {
        checkThread();
        return .getUrl();
    }

    
Gets the original URL for the current page. This is not always the same as the URL passed to WebViewClient.onPageStarted because although the load for that URL has begun, the current page may not have changed. Also, there may have been redirects resulting in a different URL to that originally requested.

Returns:
the URL that was originally requested for the current page
    @ViewDebug.ExportedProperty(category = "webview")
    public String getOriginalUrl() {
        checkThread();
        return .getOriginalUrl();
    }

    
Gets the title for the current page. This is the title of the current page until WebViewClient.onReceivedTitle is called.

Returns:
the title for the current page
    @ViewDebug.ExportedProperty(category = "webview")
    public String getTitle() {
        checkThread();
        return .getTitle();
    }

    
Gets the favicon for the current page. This is the favicon of the current page until WebViewClient.onReceivedIcon is called.

Returns:
the favicon for the current page
    public Bitmap getFavicon() {
        checkThread();
        return .getFavicon();
    }

    
Gets the touch icon URL for the apple-touch-icon <link> element, or a URL on this site's server pointing to the standard location of a touch icon.

Hide:
    public String getTouchIconUrl() {
        return .getTouchIconUrl();
    }

    
Gets the progress for the current page.

Returns:
the progress for the current page between 0 and 100
    public int getProgress() {
        checkThread();
        return .getProgress();
    }

    
Gets the height of the HTML content.

Returns:
the height of the HTML content
    @ViewDebug.ExportedProperty(category = "webview")
    public int getContentHeight() {
        checkThread();
        return .getContentHeight();
    }

    
Gets the width of the HTML content.

Returns:
the width of the HTML content
Hide:
    @ViewDebug.ExportedProperty(category = "webview")
    public int getContentWidth() {
        return .getContentWidth();
    }

    
Pauses all layout, parsing, and JavaScript timers for all WebViews. This is a global requests, not restricted to just this WebView. This can be useful if the application has been paused.
    public void pauseTimers() {
        checkThread();
        .pauseTimers();
    }

    
Resumes all layout, parsing, and JavaScript timers for all WebViews. This will resume dispatching all timers.
    public void resumeTimers() {
        checkThread();
        .resumeTimers();
    }

    
Pauses any extra processing associated with this WebView and its associated DOM, plugins, JavaScript etc. For example, if this WebView is taken offscreen, this could be called to reduce unnecessary CPU or network traffic. When this WebView is again "active", call onResume(). Note that this differs from pauseTimers(), which affects all WebViews.
    public void onPause() {
        checkThread();
        .onPause();
    }

    
Resumes a WebView after a previous call to onPause().
    public void onResume() {
        checkThread();
        .onResume();
    }

    
Gets whether this WebView is paused, meaning onPause() was called. Calling onResume() sets the paused state back to false.

Hide:
    public boolean isPaused() {
        return .isPaused();
    }

    
Informs this WebView that memory is low so that it can free any available memory.
    public void freeMemory() {
        checkThread();
        .freeMemory();
    }

    
Clears the resource cache. Note that the cache is per-application, so this will clear the cache for all WebViews used.

Parameters:
includeDiskFiles if false, only the RAM cache is cleared
    public void clearCache(boolean includeDiskFiles) {
        checkThread();
        .clearCache(includeDiskFiles);
    }

    
Removes the autocomplete popup from the currently focused form field, if present. Note this only affects the display of the autocomplete popup, it does not remove any saved form data from this WebView's store. To do that, use WebViewDatabase.clearFormData().
    public void clearFormData() {
        checkThread();
        .clearFormData();
    }

    
Tells this WebView to clear its internal back/forward list.
    public void clearHistory() {
        checkThread();
        .clearHistory();
    }

    
Clears the SSL preferences table stored in response to proceeding with SSL certificate errors.
    public void clearSslPreferences() {
        checkThread();
    }

    
Gets the WebBackForwardList for this WebView. This contains the back/forward list for use in querying each item in the history stack. This is a copy of the private WebBackForwardList so it contains only a snapshot of the current state. Multiple calls to this method may return different objects. The object returned from this method will not be updated to reflect any new state.
        checkThread();
        return .copyBackForwardList();
    }

    
Registers the listener to be notified as find-on-page operations progress. This will replace the current listener.

Parameters:
listener an implementation of WebView.FindListener
    public void setFindListener(FindListener listener) {
        checkThread();
        .setFindListener(listener);
    }

    
Highlights and scrolls to the next match found by findAllAsync(java.lang.String), wrapping around page boundaries as necessary. Notifies any registered WebView.FindListener. If findAllAsync(java.lang.String) has not been called yet, or if clearMatches() has been called since the last find operation, this function does nothing.

Parameters:
forward the direction to search
See also:
setFindListener(android.webkit.WebView.FindListener)
    public void findNext(boolean forward) {
        checkThread();
        .findNext(forward);
    }

    
Finds all instances of find on the page and highlights them. Notifies any registered WebView.FindListener.

Deprecated:
findAllAsync(java.lang.String) is preferred.
Parameters:
find the string to find
Returns:
the number of occurances of the String "find" that were found
See also:
setFindListener(android.webkit.WebView.FindListener)
    public int findAll(String find) {
        checkThread();
        StrictMode.noteSlowCall("findAll blocks UI: prefer findAllAsync");
        return .findAll(find);
    }

    
Finds all instances of find on the page and highlights them, asynchronously. Notifies any registered WebView.FindListener. Successive calls to this will cancel any pending searches.

Parameters:
find the string to find.
See also:
setFindListener(android.webkit.WebView.FindListener)
    public void findAllAsync(String find) {
        checkThread();
        .findAllAsync(find);
    }

    
Starts an ActionMode for finding text in this WebView. Only works if this WebView is attached to the view system.

Parameters:
text if non-null, will be the initial text to search for. Otherwise, the last String searched for in this WebView will be used to start.
showIme if true, show the IME, assuming the user will begin typing. If false and text is non-null, perform a find all.
Returns:
true if the find dialog is shown, false otherwise
    public boolean showFindDialog(String textboolean showIme) {
        checkThread();
        return .showFindDialog(textshowIme);
    }

    
Gets the first substring consisting of the address of a physical location. Currently, only addresses in the United States are detected, and consist of:
  • a house number
  • a street name
  • a street type (Road, Circle, etc), either spelled out or abbreviated
  • a city name
  • a state or territory, either spelled out or two-letter abbr
  • an optional 5 digit or 9 digit zip code
All names must be correctly capitalized, and the zip code, if present, must be valid for the state. The street type must be a standard USPS spelling or abbreviation. The state or territory must also be spelled or abbreviated using USPS standards. The house number may not exceed five digits.

Parameters:
addr the string to search for addresses
Returns:
the address, or if no address is found, null
    public static String findAddress(String addr) {
        return getFactory().getStatics().findAddress(addr);
    }

    
Clears the highlighting surrounding text matches created by findAllAsync(java.lang.String).
    public void clearMatches() {
        checkThread();
        .clearMatches();
    }

    
Queries the document to see if it contains any image references. The message object will be dispatched with arg1 being set to 1 if images were found and 0 if the document does not reference any images.

Parameters:
response the message that will be dispatched with the result
    public void documentHasImages(Message response) {
        checkThread();
        .documentHasImages(response);
    }

    
Sets the WebViewClient that will receive various notifications and requests. This will replace the current handler.

Parameters:
client an implementation of WebViewClient
    public void setWebViewClient(WebViewClient client) {
        checkThread();
        .setWebViewClient(client);
    }

    
Registers the interface to be used when content can not be handled by the rendering engine, and should be downloaded instead. This will replace the current handler.

Parameters:
listener an implementation of DownloadListener
    public void setDownloadListener(DownloadListener listener) {
        checkThread();
        .setDownloadListener(listener);
    }

    
Sets the chrome handler. This is an implementation of WebChromeClient for use in handling JavaScript dialogs, favicons, titles, and the progress. This will replace the current handler.

Parameters:
client an implementation of WebChromeClient
    public void setWebChromeClient(WebChromeClient client) {
        checkThread();
        .setWebChromeClient(client);
    }

    
Sets the Picture listener. This is an interface used to receive notifications of a new Picture.

Deprecated:
This method is now obsolete.
Parameters:
listener an implementation of WebView.PictureListener
    public void setPictureListener(PictureListener listener) {
        checkThread();
        .setPictureListener(listener);
    }

    
Injects the supplied Java object into this WebView. The object is injected into the JavaScript context of the main frame, using the supplied name. This allows the Java object's methods to be accessed from JavaScript. For applications targeted to API level android.os.Build.VERSION_CODES.JELLY_BEAN_MR1 and above, only public methods that are annotated with JavascriptInterface can be accessed from JavaScript. For applications targeted to API level android.os.Build.VERSION_CODES.JELLY_BEAN or below, all public methods (including the inherited ones) can be accessed, see the important security note below for implications.

Note that injected objects will not appear in JavaScript until the page is next (re)loaded. For example:

 class JsObject {
    @JavascriptInterface
    public String toString() { return "injectedObject"; }
 }
 webView.addJavascriptInterface(new JsObject(), "injectedObject");
 webView.loadData("<title></title>", "text/html", null);
 webView.loadUrl("javascript:alert(injectedObject.toString())");

IMPORTANT:

  • This method can be used to allow JavaScript to control the host application. This is a powerful feature, but also presents a security risk for applications targeted to API level android.os.Build.VERSION_CODES.JELLY_BEAN or below, because JavaScript could use reflection to access an injected object's public fields. Use of this method in a WebView containing untrusted content could allow an attacker to manipulate the host application in unintended ways, executing Java code with the permissions of the host application. Use extreme care when using this method in a WebView which could contain untrusted content.
  • JavaScript interacts with Java object on a private, background thread of this WebView. Care is therefore required to maintain thread safety.
  • The Java object's fields are not accessible.

Parameters:
object the Java object to inject into this WebView's JavaScript context. Null values are ignored.
name the name used to expose the object in JavaScript
    public void addJavascriptInterface(Object objectString name) {
        checkThread();
        .addJavascriptInterface(objectname);
    }

    
Removes a previously injected Java object from this WebView. Note that the removal will not be reflected in JavaScript until the page is next (re)loaded. See addJavascriptInterface(java.lang.Object,java.lang.String).

Parameters:
name the name used to expose the object in JavaScript
    public void removeJavascriptInterface(String name) {
        checkThread();
    }

    
Gets the WebSettings object used to control the settings for this WebView.

Returns:
a WebSettings object that can be used to control this WebView's settings
    public WebSettings getSettings() {
        checkThread();
        return .getSettings();
    }

    
Gets the list of currently loaded plugins.

Deprecated:
This was used for Gears, which has been deprecated.
Returns:
the list of currently loaded plugins
Hide:
    public static synchronized PluginList getPluginList() {
        checkThread();
        return new PluginList();
    }

    

Deprecated:
This was used for Gears, which has been deprecated.
Hide:
    public void refreshPlugins(boolean reloadOpenPages) {
        checkThread();
    }

    
Puts this WebView into text selection mode. Do not rely on this functionality; it will be deprecated in the future.

Deprecated:
This method is now obsolete.
Hide:
Since API level android.os.Build.VERSION_CODES.JELLY_BEAN_MR1
    public void emulateShiftHeld() {
        checkThread();
    }

    

Deprecated:
WebView no longer needs to implement ViewGroup.OnHierarchyChangeListener. This method does nothing now.
    @Override
    // Cannot add @hide as this can always be accessed via the interface.
    public void onChildViewAdded(View parentView child) {}

    

Deprecated:
WebView no longer needs to implement ViewGroup.OnHierarchyChangeListener. This method does nothing now.
    @Override
    // Cannot add @hide as this can always be accessed via the interface.
    public void onChildViewRemoved(View pView child) {}

    

Deprecated:
WebView should not have implemented ViewTreeObserver.OnGlobalFocusChangeListener. This method does nothing now.
    @Override
    // Cannot add @hide as this can always be accessed via the interface.
    public void onGlobalFocusChanged(View oldFocusView newFocus) {
    }

    

Deprecated:
Only the default case, true, will be supported in a future version.
    public void setMapTrackballToArrowKeys(boolean setMap) {
        checkThread();
        .setMapTrackballToArrowKeys(setMap);
    }
    public void flingScroll(int vxint vy) {
        checkThread();
        .flingScroll(vxvy);
    }

    
Gets the zoom controls for this WebView, as a separate View. The caller is responsible for inserting this View into the layout hierarchy.

API level android.os.Build.VERSION_CODES.CUPCAKE introduced built-in zoom mechanisms for the WebView, as opposed to these separate zoom controls. The built-in mechanisms are preferred and can be enabled using WebSettings.setBuiltInZoomControls(boolean).

Deprecated:
the built-in zoom mechanisms are preferred
Hide:
Since API level android.os.Build.VERSION_CODES.JELLY_BEAN
    public View getZoomControls() {
        checkThread();
        return .getZoomControls();
    }

    
Gets whether this WebView can be zoomed in.

Deprecated:
This method is prone to inaccuracy due to race conditions between the web rendering and UI threads; prefer WebViewClient.onScaleChanged(android.webkit.WebView,float,float).
Returns:
true if this WebView can be zoomed in
    public boolean canZoomIn() {
        checkThread();
        return .canZoomIn();
    }

    
Gets whether this WebView can be zoomed out.

Deprecated:
This method is prone to inaccuracy due to race conditions between the web rendering and UI threads; prefer WebViewClient.onScaleChanged(android.webkit.WebView,float,float).
Returns:
true if this WebView can be zoomed out
    public boolean canZoomOut() {
        checkThread();
        return .canZoomOut();
    }

    
Performs zoom in in this WebView.

Returns:
true if zoom in succeeds, false if no zoom changes
    public boolean zoomIn() {
        checkThread();
        return .zoomIn();
    }

    
Performs zoom out in this WebView.

Returns:
true if zoom out succeeds, false if no zoom changes
    public boolean zoomOut() {
        checkThread();
        return .zoomOut();
    }

    

Deprecated:
This method is now obsolete.
Hide:
Since API level android.os.Build.VERSION_CODES.JELLY_BEAN_MR1
    public void debugDump() {
        checkThread();
    }

    
    @Override
    public void dumpViewHierarchyWithProperties(BufferedWriter outint level) {
        .dumpViewHierarchyWithProperties(outlevel);
    }

    
    @Override
    public View findHierarchyView(String classNameint hashCode) {
        return .findHierarchyView(classNamehashCode);
    }
    //-------------------------------------------------------------------------
    // Interface for WebView providers
    //-------------------------------------------------------------------------

    
Gets the WebViewProvider. Used by providers to obtain the underlying implementation, e.g. when the appliction responds to WebViewClient.onCreateWindow() request.

Hide:
WebViewProvider is not public API.
        return ;
    }

    
Callback interface, allows the provider implementation to access non-public methods and fields, and make super-class calls in this WebView instance.

Hide:
Only for use by WebViewProvider implementations
    public class PrivateAccess {
        // ---- Access to super-class methods ----
        public int super_getScrollBarStyle() {
            return WebView.super.getScrollBarStyle();
        }
        public void super_scrollTo(int scrollXint scrollY) {
            WebView.super.scrollTo(scrollXscrollY);
        }
        public void super_computeScroll() {
            WebView.super.computeScroll();
        }
        public boolean super_onHoverEvent(MotionEvent event) {
            return WebView.super.onHoverEvent(event);
        }
        public boolean super_performAccessibilityAction(int actionBundle arguments) {
            return WebView.super.performAccessibilityAction(actionarguments);
        }
        public boolean super_performLongClick() {
            return WebView.super.performLongClick();
        }
        public boolean super_setFrame(int leftint topint rightint bottom) {
            return WebView.super.setFrame(lefttoprightbottom);
        }
        public boolean super_dispatchKeyEvent(KeyEvent event) {
            return WebView.super.dispatchKeyEvent(event);
        }
        public boolean super_onGenericMotionEvent(MotionEvent event) {
            return WebView.super.onGenericMotionEvent(event);
        }
        public boolean super_requestFocus(int directionRect previouslyFocusedRect) {
            return WebView.super.requestFocus(directionpreviouslyFocusedRect);
        }
        public void super_setLayoutParams(ViewGroup.LayoutParams params) {
            WebView.super.setLayoutParams(params);
        }
        // ---- Access to non-public methods ----
        public void overScrollBy(int deltaXint deltaY,
                int scrollXint scrollY,
                int scrollRangeXint scrollRangeY,
                int maxOverScrollXint maxOverScrollY,
                boolean isTouchEvent) {
            WebView.this.overScrollBy(deltaXdeltaYscrollXscrollYscrollRangeXscrollRangeY,
                    maxOverScrollXmaxOverScrollYisTouchEvent);
        }
        public void awakenScrollBars(int duration) {
            WebView.this.awakenScrollBars(duration);
        }
        public void awakenScrollBars(int durationboolean invalidate) {
            WebView.this.awakenScrollBars(durationinvalidate);
        }
        public float getVerticalScrollFactor() {
            return WebView.this.getVerticalScrollFactor();
        }
        public float getHorizontalScrollFactor() {
            return WebView.this.getHorizontalScrollFactor();
        }
        public void setMeasuredDimension(int measuredWidthint measuredHeight) {
            WebView.this.setMeasuredDimension(measuredWidthmeasuredHeight);
        }
        public void onScrollChanged(int lint tint oldlint oldt) {
            WebView.this.onScrollChanged(ltoldloldt);
        }
        public int getHorizontalScrollbarHeight() {
            return WebView.this.getHorizontalScrollbarHeight();
        }
        // ---- Access to (non-public) fields ----
        
Raw setter for the scroll X value, without invoking onScrollChanged handlers etc.
        public void setScrollXRaw(int scrollX) {
            WebView.this. = scrollX;
        }

        
Raw setter for the scroll Y value, without invoking onScrollChanged handlers etc.
        public void setScrollYRaw(int scrollY) {
            WebView.this. = scrollY;
        }
    }
    //-------------------------------------------------------------------------
    // Private internal stuff
    //-------------------------------------------------------------------------
    private WebViewProvider mProvider;
    private void ensureProviderCreated() {
        checkThread();
        if ( == null) {
            // As this can get called during the base class constructor chain, pass the minimum
            // number of dependencies here; the rest are deferred to init().
             = getFactory().createWebView(thisnew PrivateAccess());
        }
    }
    private static synchronized WebViewFactoryProvider getFactory() {
        // For now the main purpose of this function (and the factory abstration) is to keep
        // us honest and minimize usage of WebViewClassic internals when binding the proxy.
        checkThread();
        return WebViewFactory.getProvider();
    }
    private static void checkThread() {
        if (Looper.myLooper() != Looper.getMainLooper()) {
            Throwable throwable = new Throwable(
                    "Warning: A WebView method was called on thread '" +
                    Thread.currentThread().getName() + "'. " +
                    "All WebView methods must be called on the UI thread. " +
                    "Future versions of WebView may not support use on other threads.");
            Log.w(, Log.getStackTraceString(throwable));
            StrictMode.onWebViewMethodCalledOnWrongThread(throwable);
        }
    }
    //-------------------------------------------------------------------------
    // Override View methods
    //-------------------------------------------------------------------------
    // TODO: Add a test that enumerates all methods in ViewDelegte & ScrollDelegate, and ensures
    // there's a corresponding override (or better, caller) for each of them in here.
    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
    }
    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
    }
    @Override
    public void setLayoutParams(ViewGroup.LayoutParams params) {
        .getViewDelegate().setLayoutParams(params);
    }
    @Override
    public void setOverScrollMode(int mode) {
        super.setOverScrollMode(mode);
        // This method may called in the constructor chain, before the WebView provider is
        // created. (Fortunately, this is the only method we override that can get called by
        // any of the base class constructors).
        ensureProviderCreated();
    }
    @Override
    public void setScrollBarStyle(int style) {
        super.setScrollBarStyle(style);
    }
    @Override
    protected int computeHorizontalScrollRange() {
    }
    @Override
    protected int computeHorizontalScrollOffset() {
    }
    @Override
    protected int computeVerticalScrollRange() {
    }
    @Override
    protected int computeVerticalScrollOffset() {
    }
    @Override
    protected int computeVerticalScrollExtent() {
    }
    @Override
    public void computeScroll() {
    }
    @Override
    public boolean onHoverEvent(MotionEvent event) {
        return .getViewDelegate().onHoverEvent(event);
    }
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        return .getViewDelegate().onTouchEvent(event);
    }
    @Override
    public boolean onGenericMotionEvent(MotionEvent event) {
        return .getViewDelegate().onGenericMotionEvent(event);
    }
    @Override
    public boolean onTrackballEvent(MotionEvent event) {
        return .getViewDelegate().onTrackballEvent(event);
    }
    @Override
    public boolean onKeyDown(int keyCodeKeyEvent event) {
        return .getViewDelegate().onKeyDown(keyCodeevent);
    }
    @Override
    public boolean onKeyUp(int keyCodeKeyEvent event) {
        return .getViewDelegate().onKeyUp(keyCodeevent);
    }
    @Override
    public boolean onKeyMultiple(int keyCodeint repeatCountKeyEvent event) {
        return .getViewDelegate().onKeyMultiple(keyCoderepeatCountevent);
    }
    /*
    TODO: These are not currently implemented in WebViewClassic, but it seems inconsistent not
    to be delegating them too.
    @Override
    public boolean onKeyPreIme(int keyCode, KeyEvent event) {
        return mProvider.getViewDelegate().onKeyPreIme(keyCode, event);
    }
    @Override
    public boolean onKeyLongPress(int keyCode, KeyEvent event) {
        return mProvider.getViewDelegate().onKeyLongPress(keyCode, event);
    }
    @Override
    public boolean onKeyShortcut(int keyCode, KeyEvent event) {
        return mProvider.getViewDelegate().onKeyShortcut(keyCode, event);
    }
    */
    @Override
    public boolean shouldDelayChildPressedState() {
    }
    @Override
        super.onInitializeAccessibilityNodeInfo(info);
        info.setClassName(WebView.class.getName());
    }
    @Override
        super.onInitializeAccessibilityEvent(event);
        event.setClassName(WebView.class.getName());
    }
    @Override
    public boolean performAccessibilityAction(int actionBundle arguments) {
        return .getViewDelegate().performAccessibilityAction(actionarguments);
    }

    

Hide:
    @Override
    protected void onDrawVerticalScrollBar(Canvas canvas