Simplifier l'implémentation WebView avec Jetpack Webkit

Ce guide décrit les avantages de la bibliothèque Jetpack Webkit, explique son fonctionnement et comment l'implémenter dans vos projets.

Présentation

Les composants WebView sont essentiels au développement Android, mais ils peuvent parfois être difficiles à gérer en raison des incohérences dans les fonctionnalités entre les différentes versions de l'OS Android. Chaque version de l'OS Android fournit un ensemble fixe d'API WebView. Étant donné qu'Android est déployé à un rythme plus lent que WebView, il est possible que les API Android ne couvrent pas toutes les fonctionnalités WebView disponibles. Cela ralentit le déploiement des fonctionnalités et augmente les coûts de test.

Jetpack Webkit résout ces problèmes en agissant comme une couche de compatibilité et en tirant parti de l'APK WebView à jour sur l'appareil de l'utilisateur. Elle contient également des API nouvelles et modernes qui ne sont disponibles que dans cette bibliothèque.

Pourquoi utiliser Jetpack Webkit ?

En plus d'offrir une compatibilité entre les versions, Jetpack Webkit propose également des API nouvelles et modernes qui peuvent simplifier le développement et améliorer les fonctionnalités de votre application :

  • Authentification moderne : WebView peut gérer de manière fluide les normes d'authentification Web modernes telles que WebAuthn, ce qui permet de se connecter à l'aide de clés d'accès. La bibliothèque androidx.webkit vous permet de contrôler entièrement cette intégration à l'aide de la méthode WebSettingsCompat.setWebAuthenticationSupport(), que vous pouvez utiliser pour configurer le niveau d'assistance requis par votre application.

  • Amélioration des performances : optimisez les performances de WebView pour les cas d'utilisation de votre application à l'aide d'API telles que prefetchUrlAsync, prerenderUrlAsync et setBackForwardCacheEnabled.

  • Stabilité accrue : récupérez les processus de rendu bloqués ou qui ne répondent pas sans provoquer de plantage. Pour en savoir plus, consultez WebViewRenderProcess#terminate().

  • Offre un contrôle précis sur les données de navigation : pour supprimer les données de navigation stockées par WebView pour des origines spécifiques, utilisez la classe WebStorageCompat.

Comprendre les composants

Pour utiliser efficacement Jetpack Webkit, vous devez comprendre la relation entre les composants suivants :

  • Android System WebView : il s'agit du moteur de rendu basé sur Chromium que Google met à jour régulièrement sur le Google Play Store, à la même fréquence que Chrome. Il contient les fonctionnalités les plus récentes et fournit le code d'implémentation sous-jacent pour toutes les API WebView.

  • API du framework (android.webkit) : il s'agit des API qui sont fixes à une version spécifique de l'OS Android. Par exemple, une application sur Android 10 ne peut accéder qu'aux API disponibles lors de la sortie de cette version. Il ne peut donc pas utiliser les nouvelles fonctionnalités ajoutées à l'APK WebView dans les mises à jour plus récentes. Par exemple, pour obtenir un handle sur un moteur de rendu qui ne répond pas avec WebView#getWebViewRenderProcess(), vous ne pouvez appeler cette méthode que sur Android 10 ou version ultérieure.

  • Bibliothèque Jetpack Webkit (androidx.webkit) : il s'agit d'une petite bibliothèque incluse dans votre application. Cette bibliothèque sert de pont qui appelle l'APK WebView, plutôt que les API définies dans la plate-forme Android, qui possède une version d'OS fixe. Ainsi, même si une application est installée sur un appareil exécutant une ancienne version de l'OS, comme Android 10, elle peut utiliser les dernières fonctionnalités WebView. Par exemple, WebViewCompat.getWebViewRenderProcess() fonctionne de la même manière que l'API Framework, sauf qu'elle peut également être appelée sur toutes les versions d'OS antérieures à Android 10.

Si une API est disponible à la fois dans le framework et dans Jetpack Webkit, nous vous recommandons de choisir la version Jetpack Webkit. Cela permet de garantir un comportement et une compatibilité cohérents sur la plus large gamme d'appareils.

Interaction entre Jetpack Webkit et les APK

Les API de Jetpack Webkit sont implémentées en deux parties :

  • Static Jetpack Webkit : la bibliothèque Static Jetpack Webkit contient une minorité du code responsable de l'implémentation de l'API.

  • APK WebView : l'APK WebView contient la majeure partie du code.

Votre application appelle l'API Jetpack Webkit, qui appelle ensuite l'APK WebView.

Bien que vous contrôliez la version Jetpack Webkit dans votre application, vous ne pouvez pas contrôler les mises à jour de l'APK WebView sur les appareils des utilisateurs. En général, la plupart des utilisateurs disposent de versions à jour de l'APK WebView, mais votre application doit tout de même faire attention à ne pas appeler d'API que cette version particulière de l'APK WebView ne prend pas en charge.

Jetpack Webkit permet également d'éviter de vérifier manuellement les versions de WebView. Pour déterminer si une fonctionnalité est disponible, recherchez sa constante de fonctionnalité. Par exemple, WebViewFeature.WEB_AUTHENTICATION.

Fonctionnement combiné

Jetpack Webkit comble le fossé entre l'API Framework statique et l'APK WebView fréquemment mis à jour. Lorsque vous utilisez l'API Jetpack Webkit avec le modèle de détection de fonctionnalités, la bibliothèque vérifie si la fonctionnalité est compatible avec l'APK WebView installé sur l'appareil de l'utilisateur. Cela permet de ne pas avoir à vérifier la version de l'OS Android (framework).

Si l'APK WebView est suffisamment récent, la bibliothèque appelle la fonctionnalité. Sinon, il indique que la fonctionnalité n'est pas disponible, ce qui empêche votre application de planter et vous permet de gérer la situation de manière fluide.

Comparer les API Jetpack Webkit et Framework

Cette section compare les méthodes d'implémentation avec et sans la bibliothèque Jetpack Webkit :

Activer l'authentification moderne (WebAuthn)

Sans Jetpack Webkit

Impossible avec les API du framework.

Avec Jetpack Webkit

Utilise WebViewFeature.WEB_AUTHENTICATION pour les vérifications de compatibilité.

if (WebViewFeature.isFeatureSupported(WebViewFeature.WEB_AUTHENTICATION)) {
  WebSettingsCompat.setWebAuthenticationSupport(
      webView.settings,
      WebSettingsCompat.WEB_AUTHENTICATION_SUPPORT_FOR_APP
  )
}

Supprimer les données d'une origine (stockage spécifique à un site)

Sans Jetpack WebKit

Il n'existe aucune API directe permettant d'effacer des données d'origine spécifiques. Cela nécessite souvent d'effacer toutes les données.

Avec Jetpack WebKit

Utilise des API de compatibilité pour supprimer précisément les données. Vous pouvez utiliser l'une des options suivantes :

WebStorageCompat.getInstance().deleteBrowsingData()

Ou

WebStorageCompat.getInstance().deleteBrowsingDataForSite()

Obtenir la version de WebView

Sans Jetpack WebKit

Utilise la classe de framework standard.

val webViewPackage = WebView.getCurrentWebViewPackage()

Avec Jetpack WebKit

Utilise la couche de compatibilité pour une récupération plus sûre.

val webViewPackage = WebViewCompat.getCurrentWebViewPackage()

Gérer un moteur de rendu qui ne répond pas (client du moteur de rendu)

Sans Jetpack WebKit

Utilise la méthode de framework standard.

webView.setWebViewRenderProcessClient(myClient)

Avec Jetpack WebKit

Utilise WebViewCompat et une vérification des fonctionnalités pour définir le client.

if (WebViewFeature.isFeatureSupported(WebViewFeature.WEB_VIEW_RENDERER_CLIENT_BASIC_USAGE)) {
  WebViewCompat.setWebViewRenderProcessClient(webView, myClient)
}

Pour en savoir plus, consultez la documentation de référence de androidx.webkit.

Intégrer Jetpack Webkit à votre code

L'utilisation de Jetpack Webkit augmente les capacités de la classe WebView standard, mais ne remplace pas entièrement la classe WebView d'origine.

Vous pouvez continuer à utiliser la classe android.webkit.WebView. Vous pouvez l'ajouter à vos mises en page XML et obtenir une référence à l'instance dans votre code. Pour accéder aux fonctionnalités standards du framework, vous pouvez toujours appeler des méthodes directement sur l'instance WebView ou son objet de paramètres.

Pour accéder aux fonctionnalités modernes, vous utilisez les méthodes d'assistance statiques fournies par Jetpack Webkit, telles que WebViewCompat et WebSettingsCompat. Vous transmettez votre instance WebView existante à ces méthodes.

Kotlin

import android.webkit.WebView
import androidx.webkit.WebSettingsCompat
import androidx.webkit.WebViewFeature

// You still get your WebView instance the standard way.
val webView: WebView = findViewById(R.id.my_webview)

// To enable a modern feature, you pass that instance to a Jetpack Webkit helper.
if (WebViewFeature.isFeatureSupported(WebViewFeature.FORCE_DARK)) {
    WebSettingsCompat.setForceDark(webView.settings, WebSettingsCompat.FORCE_DARK_ON)
}

Java

import android.webkit.WebView;
import androidx.webkit.WebSettingsCompat;
import androidx.webkit.WebViewFeature;

// You still get your WebView instance the standard way.
WebView webView = findViewById(R.id.my_webview);

// To enable a modern feature, you pass that instance to a Jetpack Webkit helper.
if (WebViewFeature.isFeatureSupported(WebViewFeature.FORCE_DARK)) {
    WebSettingsCompat.setForceDark(webView.settings, WebSettingsCompat.FORCE_DARK_ON);
}

Implémenter Jetpack Webkit

Pour implémenter Jetpack Webkit, procédez comme suit.

Étape 1 : Ajoutez la dépendance

Dans le fichier build.gradle.kts ou build.gradle de votre module, incluez la dépendance suivante pour ajouter Jetpack Webkit :

Groovy

dependencies {
    implementation "androidx.webkit:webkit:1.14.0"
}

Kotlin

dependencies {
    implementation("androidx.webkit:webkit:1.14.0")
}

Jetpack Webkit contient des wrappers fins, ce qui minimise l'impact sur la taille de votre application.

Étape 2 : Adoptez le modèle de détection de fonctionnalités

Pour éviter les plantages lors de l'appel d'API non disponibles, utilisez des vérifications de fonctionnalités. Nous vous recommandons d'entourer chaque appel d'API d'une vérification de fonctionnalité et d'envisager une logique de secours lorsque l'API n'est pas disponible.

Nous vous recommandons d'utiliser le modèle suivant pour utiliser une API WebView moderne :

import android.webkit.WebView
import androidx.webkit.WebSettingsCompat
import androidx.webkit.WebViewFeature

// In your Kotlin code where you configure your WebView
val webView: WebView = findViewById(R.id.my_webview)

// Before you use a modern API, first check if it is supported.
if (WebViewFeature.isFeatureSupported(WebViewFeature.FORCE_DARK)) {
    // If the check passes, it is safe to call the API.
    WebSettingsCompat.setForceDark(webView.settings, WebSettingsCompat.FORCE_DARK_ON)
} else {
    // Optionally, provide a fallback for older WebView versions.
}

Ce modèle permet de s'assurer que l'application est robuste. Comme la vérification des fonctionnalités s'exécute en premier, l'application ne plante pas si la fonctionnalité n'est pas disponible. La surcharge de performances de la vérification WebViewFeature#isFeatureSupported() est négligeable.