WebView
public class WebView
extends AbsoluteLayout
implements ViewTreeObserver.OnGlobalFocusChangeListener, ViewGroup.OnHierarchyChangeListener
java.lang.Object | ||||
↳ | android.view.View | |||
↳ | android.view.ViewGroup | |||
↳ | android.widget.AbsoluteLayout | |||
↳ | android.webkit.WebView |
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.
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("https://www.example.com"); Intent intent = new Intent(Intent.ACTION_VIEW, uri); startActivity(intent);
See 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 onCreate()
:
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("https://example.com/"); // 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 forloadData()
andloadDataWithBaseURL()
for more info.
A WebView has several customization points where you can add your own behavior. These are:
- Creating and setting a
WebChromeClient
subclass. This class is called when something that might impact a browser UI happens, for instance, progress updates and JavaScript alerts are sent here (see Debugging Tasks). - Creating and setting a
WebViewClient
subclass. It will be called when things happen that impact the rendering of the content, eg, errors or form submissions. You can also intercept URL loading here (viashouldOverrideUrlLoading()
). - Modifying the
WebSettings
, such as enabling JavaScript withsetJavaScriptEnabled()
. - Injecting Java objects into the WebView using the
addJavascriptInterface(Object, String)
method. This method allows you to inject Java objects into a page's JavaScript context, so that they can be accessed by JavaScript in the page.
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("https://developer.android.com/");
Zoom
To enable the built-in zoom, set WebSettings
.setBuiltInZoomControls(boolean)
(introduced in API level CUPCAKE
).
NOTE: Using zoom if either the height or width is set to WRAP_CONTENT
may lead to undefined behavior and should be avoided.
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 behavior 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 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 ofwindow.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. - 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.
HTML5 Video support
In order to support inline HTML5 video in your application you need to have hardware acceleration turned on.
Full screen support
In order to support full screen — for video or other HTML content — you need to set a WebChromeClient
and implement both onShowCustomView(View, WebChromeClient.CustomViewCallback)
and onHideCustomView()
. If the implementation of either of these two methods is missing then the web contents will not be allowed to enter full screen. Optionally you can implem