# WebView quick start (legacy)
*** note
This is an old version of the quick start guide. We recommend following the [new
version instead](./quick-start.md).
***
[TOC]
## Overview
This is not a thorough guide for how to build WebView, but is the **fastest**
way to get a local build of WebView up and running.
### Building for preview Android releases
Googlers should see internal instructions. External contributors should switch
to a public (and finalized) Android release (there's no workaround).
## System requirements, tools, etc.
See general Android instructions for:
* [System
requirements](/docs/android_build_instructions.md#System-requirements)
* [Installing
`depot_tools`](/docs/android_build_instructions.md#Install-depot_tools)
* [Getting the code](/docs/android_build_instructions.md#Get-the-code) **or**
[converting a Linux
checkout](/docs/android_build_instructions.md#Converting-an-existing-Linux-checkout)
* [Installing build
dependencies](/docs/android_build_instructions.md#Install-additional-build-dependencies)
**and** [running hooks](/docs/android_build_instructions.md#Run-the-hooks)
## Install adb
If you don't already have `adb` installed, the fastest way is to add chromium's
Android SDK to your `$PATH`. If you use multiple terminal, you'll want to run
this command in each terminal:
```shell
$ source build/android/envsetup.sh
```
## Device setup
The recommend configuration is to use an **Android P emulator**. Android N or O
are also OK, however if you need to use any other OS version then you need to
switch to the full [build guide](./build-instructions.md) instead.
Set up an [Android emulator](/docs/android_emulator.md). You have 2 options for
this:
1. Preconfigured emulator image. Just run this command in your terminal, which
will launch an emulator window when the emulator is ready. If anything goes
wrong, see [the
documentation](https://chromium.googlesource.com/chromium/src/+/HEAD/docs/android_emulator.md#Using-Prebuilt-CIPD-packages)
or try the next option (see below).
```shell
$ tools/android/avd/avd.py start \
--avd-config tools/android/avd/proto/generic_android28.textpb --emulator-window
```
2. Android Studio Emulator image. [Install the Android Studio
IDE](https://developer.android.com/studio/install) and then follow [these
instructions](https://developer.android.com/studio/run/managing-avds)
to launch the Device Manager GUI. Create an emulator with these settings:
* Skin: any Pixel device skin is fine
* Release name: **Pie**
* ABI: **x86**
* Target: **Google APIs**
<!-- Keep this part in sync with /docs/android_emulator.md -->
* Select "Show Advanced Settings" > scroll down:
* Set internal storage to 4000MB
* Set SD card to 1000MB
* If in doubt, consult the
[chromium
documentation](https://chromium.googlesource.com/chromium/src/+/HEAD/docs/android_emulator.md#Using-Your-Own-Emulator-Image)
to configure your emulator
Once configured, click the **play** button to launch the emulator.
**Verify your emulator is ready:** after performing either of the steps above,
you should check your emulator by running:
```shell
# If everything worked correctly, this should say "device" in the right column.
$ adb devices
List of devices attached
emulator-5554 device
```
## Setting up the build
Configure GN args (run `gn args out/Default`) as follows:
```gn
target_os = "android"
target_cpu = "x86"
# This package name is allowed for debuggable (userdebug) devices, and lets
# devs install a WebView provider without the usual signature checks. This only
# works on N-P.
system_webview_package_name = "com.google.android.apps.chrome"
# Recommended: this lets you use System WebView Shell as a test app.
system_webview_shell_package_name = "org.chromium.my_webview_shell"
```
## Build, install, and switch WebView provider {#build}
```shell
# Build
$ autoninja -C out/Default system_webview_apk
# Install the APK
$ out/Default/bin/system_webview_apk install
# Tell Android platform to load a WebView implementation from this APK
$ out/Default/bin/system_webview_apk set-webview-provider
```
**That's it!** Your APK should be installed and should be providing the WebView
implementation for all apps on the system.
## Things to do next
### Start running an app
**Skip this section** if you already have an app you want to test.
You can start testing our your WebView APK with the System WebView Shell test
app. This also shows the WebView version at the top of the app, so you can
verify this is using the version you built locally. You can run this test app
like so:
```shell
# Build
$ autoninja -C out/Default system_webview_shell_apk
# Install
$ out/Default/bin/system_webview_shell_apk install
# Launch a URL
$ out/Default/bin/system_webview_shell_apk launch "https://www.google.com/"
```
For more info about WebView Shell, see [the docs](./webview-shell.md).
### Toggle features or commandline flags
**Skip this section** if you don't need to toggle a specific commandline flag.
If you exposed your flag in [ProductionSupportedFlagList.java], then you can
toggle the flag in WebView DevTools. For more info about WebView DevTools, see
[the docs](./developer-ui.md). You can launch WebView DevTools with:
```shell
$ adb shell am start -a "com.android.webview.SHOW_DEV_UI"
```
If the flag is not exposed, you can instead try following [these
steps](./commandline-flags.md).
### Debug with adb logcat
We recommend starting with "printf-style debugging" on Android:
1. Add some logs in your code:
* In C++ code: add `LOG(ERROR) << "SOMETAG: <your log message goes here>";`
* In Java code: add `org.chromium.base.Log.e("SOMETAG", "<your log message
goes here>");`
2. Recompile and reinstall `system_webview_apk` (see
[steps above](#build)). Re-launch your test app.
3. Read your log messages by running this command:
`adb logcat | grep 'SOMETAG'`
For more guidance, refer to [the logging
documentation](/docs/android_logging.md).
### Run automated tests
We recommend starting with [integration
tests](./test-instructions.md#instrumentation-tests).
### Shutdown your emulator when you're done
The recommended way to turn off your emulator is to just close the emulator
window. If that doesn't work or you can't find the emulator window, then you can
safely shutdown your emulator by running `adb emu kill` in the terminal.
## Troubleshooting
If the install command succeeded but something else is wrong, the best way to
troubleshoot the problem is to query the state of the on-device
WebViewUpdateService:
```shell
# Only available on O+
$ adb shell dumpsys webviewupdate
Current WebView Update Service state
Fallback logic enabled: true
Current WebView package (name, version): (com.google.android.apps.chrome, 75.0.3741.0)
Minimum WebView version code: 303012512
Number of relros started: 1
Number of relros finished: 1
WebView package dirty: false
Any WebView package installed: true
Preferred WebView package (name, version): (com.google.android.apps.chrome, 75.0.3741.0)
WebView packages:
Valid package com.android.chrome (versionName: 58.0.3029.125, versionCode: 303012512, targetSdkVersion: 26) is installed/enabled for all users
Valid package com.google.android.webview (versionName: 58.0.3029.125, versionCode: 303012500, targetSdkVersion: 26) is NOT installed/enabled for all users
Invalid package com.chrome.beta (versionName: 74.0.3729.23, versionCode: 372902311, targetSdkVersion: 28), reason: No WebView-library manifest flag
Invalid package com.chrome.dev (versionName: 54.0.2840.98, versionCode: 284009811, targetSdkVersion: 24), reason: SDK version too low
Invalid package com.chrome.canary (versionName: 75.0.3741.0, versionCode: 374100010, targetSdkVersion: 25), reason: SDK version too low
Valid package com.google.android.apps.chrome (versionName: 75.0.3741.0, versionCode: 2, targetSdkVersion: 28) is installed/enabled for all users
```
### Invalid package ... No WebView-library manifest flag
This APK does not contain a WebView implementation. Make sure you're building
`system_webview_apk`.
### Invalid package ... Version code too low
This shouldn't happen for userdebug builds. If it does, add this GN arg:
```gn
# Any number >= "Minimum WebView version code":
android_override_version_code = "987654321"
```
### Invalid package ... SDK version too low
The targetSdkVersion of your APK is too low (it must be >= the platform's API
level). This shouldn't happen for local builds using tip-of-tree chromium on
public OS versions (see [note](#Building-for-preview-Android-releases)).
*** note
**Note:** we only support local development using the latest revision of the
main branch. Checking out release branches introduces a lot of complexity, and
it might not even be possible to build WebView for your device.
***
### Invalid package ... Incorrect signature
This shouldn't happen for userdebug devices, and there's no workaround for user
devices. Make sure you have a userdebug device (you can check with `adb shell
getprop ro.build.type`).
### Valid package ... **is** installed/enabled for all users
This is the correct state. If this is not the "preferred WebView package" or the
"current WebView package", call `set-webview-implementation` again.
### Valid package ... **is NOT** installed/enabled for all users
This shouldn't happen for `com.google.android.apps.chrome` (the recommended
package name). If you need to use a different package name, you may be able to
workaround this by enabling "redundant packages" (`adb shell cmd webviewupdate
enable-redundant-packages`), reinstalling, and running `set-webview-provider`
again.
Otherwise, please [reach out to the team][1].
### My package isn't in the list
Either your package didn't install (see below) or you chose a package name which
is [not eligible as a WebView provider](webview-providers.md#Package-name) for
this device. Double-check the package name in your GN args. If you're on AOSP
(any OS level), choose `"com.android.webview"`. If you're on L-M, choose
`"com.google.android.webview"`. In either case, you'll likely need to [remove
the preinstalled WebView
APK](/android_webview/tools/remove_preinstalled_webview.py).
### WebView shell doesn't show the correct version
Check the "Current WebView package" in the dumpsys output. You're probably
hitting one of the cases above.
### INSTALL\_FAILED\_UPDATE\_INCOMPATIBLE: Package ... signatures do not match previously installed version
This is probably because you've already installed Chrome Debug (ex. with the
Google-only `monochrome_apk` target, or through a Google-only official build).
This guide borrows that app's package name, but the locally compiled APK may not
have the same signing key, causing the `adb install` error. You should remove
the conflicting package with `out/Default/bin/system_webview_apk uninstall`, and
then try installing WebView again.
### I couldn't install the APK/... is NOT installed.
This could fail for an even wider variety of reasons than already listed. Please
[reach out to the team][1].
### I couldn't **build** the APK
Try building Chromium. If that doesn't work, please reach out to [the chromium
team](https://groups.google.com/a/chromium.org/forum/#!forum/chromium-dev) for
general guidance. If `system_webview_apk` is the only troublesome target, please
reach out to the WebView team (see previous section).
## What if I didn't follow these instructions exactly?
**Proceed at your own risk.** Building and installing WebView is, for a variety
of reasons, complex. If you've deviated from **any** of these instructions (and
don't know what you're doing) there's a good chance of making mistakes (some of
which don't have any error messages).
If you can't follow the quick start guide for some reason, please consult our
[general build instructions](build-instructions.md).
[1]: https://groups.google.com/a/chromium.org/forum/#!forum/android-webview-dev
[ProductionSupportedFlagList.java]: https://source.chromium.org/chromium/chromium/src/+/main:android_webview/java/src/org/chromium/android_webview/common/ProductionSupportedFlagList.java
Codebase Browser
chromium