Digitale Anmeldedaten in WebView anfordern

In diesem Leitfaden wird beschrieben, wie Sie in einer Android-App, die WebView verwendet, mit dem Credential Manager digitale Ausweise anfordern. Verwenden Sie eine JavaScript-Bridge, um die Kommunikation zwischen der Webseite und der App zu ermöglichen.

Übersicht

In den folgenden Schritten wird der Lebenszyklus einer Anfrage für einen digitalen Berechtigungsnachweis aus einer WebView beschrieben:

  1. Anfragegenerierung: Die Webseite in der WebView sendet eine Anfrage an den App-Server, der eine OpenID4VP-Anfrage im JSON-Format generiert und zurücksendet.
  2. Anfrageinitiierung: Die Webseite verwendet navigator.credentials.get({ digital: ... }), um digitale Ausweise mithilfe der Anfrage-JSON anzufordern.
  3. Abfangen: Die eingefügte bridge.js fängt diesen Aufruf ab, extrahiert die spezifische OpenID4VP-Anfrage-JSON und übergibt sie an die Android-App.
  4. Android-Verarbeitung: Die Android-App empfängt die Nachricht und ruft die CredentialManager.getCredential API auf.
  5. Nutzerauswahl: Der Credential Manager zeigt eine Benutzeroberfläche an, auf der der Nutzer aufgefordert wird, seine Anmeldedaten zu teilen. Der Berechtigungsnachweis wird an die Android-App zurückgegeben.
  6. Bridge-Antwort: Die Android-App sendet die Antwort über die Bridge an die Webseite zurück.
  7. Abschluss: Die Webseite empfängt und verarbeitet die Antwort.

Vorbereitung

Bevor Sie die JavaScript-Bridge für digitale Ausweise in WebView implementieren, müssen Sie prüfen, ob Ihr Projekt die folgenden Anforderungen erfüllt:

  • Kompatibilität mit Android-Versionen: Ihre App muss auf Android 6.0 (API-Level 23) oder höher ausgerichtet sein.
  • Kontrolle über die Host-App: Sie müssen die Kontrolle über die Android-App haben, die die WebView hostet, damit Sie vor dem Laden der Webseite eine WebMessageListener anhängen können.
  • HTTPS und Top-Level-Frame: Die Webseite, die die Anmeldedaten anfordert, muss über https:// bereitgestellt werden und im Hauptframe ausgeführt werden (isMainFrame muss true sein). Untergeordnete Frames und eingebettete <iframe>-Elemente werden nicht unterstützt.
  • Experimentelle API aktivieren: Da die Digital Credentials API experimentell ist, müssen Sie Klassen oder Methoden, die GetDigitalCredentialOption verwenden, mit @OptIn(ExperimentalDigitalCredentialApi::class) annotieren.

Abhängigkeiten hinzufügen

Fügen Sie der Datei build.gradle.kts Ihres App-Moduls die Abhängigkeiten für den Credential Manager und AndroidX WebKit hinzu:

dependencies {
    // Credential Manager dependencies
    implementation("androidx.credentials:credentials:1.7.0-alpha03")
    implementation("androidx.credentials:credentials-play-services-auth:1.7.0-alpha03")

    // AndroidX WebKit (required for WebMessageListener bridge)
    implementation("androidx.webkit:webkit:1.14.0")
}

Digitale Anmeldedaten in der WebView implementieren

Sie müssen Ihrer WebView JavaScript hinzufügen, um die Anfrage für Anmeldedaten zu stellen und sie mit bridge.js abzufangen.

JavaScript-Anfrage erstellen

Wenn Sie zwischen JavaScript, das in einer WebView ausgeführt wird, und Android-Code kommunizieren möchten, fügen Sie JavaScript-Code in Ihre WebView ein:

// Example digital credential request to request verified email
const request = {
  "providers": [
      {
        "protocol": "openid4vp",
        "request": JSON.stringify({
          "requests": [
            {
              "protocol": "openid4vp-v1-unsigned",
              "data": {
                "response_type": "vp_token",
                "response_mode": "dc_api",
                "nonce": "n-0S6_W_2F", // Generate dynamically
                "dcql_query": {
                  "credentials": [
                    {
                      "id": "user_info_query",
                      "format": "dc+sd-jwt",
                      "meta": {
                        "vct_values": ["UserInfoCredential"]
                      },
                      "claims": [
                        {"path": ["email"]},
                        {"path": ["email_verified"]},
                        {"path": ["name"]}
                      ]
                    }
                  ]
                }
              }
            }
          ]
      })
    }
  ]
};

try {
  const credential = await navigator.credentials.get({
    digital: request
  });

  // Process response
} catch (err) {
  // Handle error
}

JavaScript-Bridge erstellen

Erstellen Sie eine Datei mit dem Namen bridge.js oder fügen Sie diesen Code mit evaluateJavascript ein. Dieses Script überschreibt navigator.credentials.get, um die Anfrage abzufangen und den inneren OpenID4VP-JSON-String an die Android-App zu senden.

(function() {
  if (!navigator.credentials) {
    navigator.credentials = {};
  }

  const originalGet = navigator.credentials.get;

  // Overrides navigator.credentials.get() to intercept W3C Digital Credential requests.
  navigator.credentials.get = async function(options) {

    if (options && options.digital) {
      if (window.DigitalCredentialBridge) {
        return new Promise((resolve, reject) => {
          const digital = options.digital;

          if (digital.providers && digital.providers.length > 0) {
            const provider = digital.providers[0];

            if (provider.protocol === "openid4vp") {
              const requestJson = provider.request;

              const message = {
                type: "get",
                request: requestJson
              };

              console.log("Sending message to native bridge:", JSON.stringify(message));
              // Send the request string to native Android code
              window.DigitalCredentialBridge.postMessage(JSON.stringify(message));

              // Receive the response sent from native code using replyProxy.postMessage()
              window.DigitalCredentialBridge.onmessage = function(event) {
                console.log("Received response from native bridge:", event.data);
                try {
                  const response = JSON.parse(event.data);
                  if (response.error) {
                    reject(new Error(response.error));
                  } else {
                    resolve(response);
                  }
                } catch (e) {
                  // If it's not JSON, just resolve with the raw data
                  resolve(event.data);
                }
              };
            } else {
              reject(new Error("Unsupported protocol: " + provider.protocol));
            }
          } else {
            reject(new Error("No providers specified in digital credential request"));
          }
        });
      } else {
        console.warn("DigitalCredentialBridge not found, falling back to original");
      }
    }

    if (originalGet) {
      return originalGet.call(navigator.credentials, options);
    } else {
      throw new Error("navigator.credentials.get is not supported and no bridge available");
    }
  };
})();

Digitale Ausweise in Android implementieren

Konfigurieren Sie Ihre Android-App so, dass sie von bridge.js gesendete Anfragen nach Anmeldedaten verarbeitet.

Android-Listener erstellen

Richten Sie eine DigitalCredentialWebListener-Klasse ein, die WebViewCompat.WebMessageListener implementiert. Diese Klasse verarbeitet bidirektionale Nachrichten zwischen JavaScript und nativem Android-Code, erzwingt Sicherheitsprüfungen für isMainFrame und sourceOrigin und verhindert sich überschneidende Anfragen.

Credential Manager-Handler implementieren

Rufen Sie getCredential auf, um digitale Ausweise vom Gerät anzufordern.

@OptIn(ExperimentalDigitalCredentialApi::class)
class CredentialManagerHandler(private val context: Context) {
  private val credentialManager = CredentialManager.create(context)

  suspend fun getDigitalCredential(requestJson: String): String {
    val digitalCredentialOption = GetDigitalCredentialOption(requestJson)
    val getCredRequest = GetCredentialRequest(listOf(digitalCredentialOption))

    return try {
      val result = credentialManager.getCredential(context, getCredRequest)
      val credential = result.credential
      if (credential is DigitalCredential) {
        credential.credentialJson
      } else {
        "{\"error\": \"Unexpected credential type\"}"
      }
    } catch (e: GetCredentialException) {
      "{\"error\": \"${e.message}\"}"
    } catch (e: Exception) {
      "{\"error\": \"Unknown exception\"}"
    }
  }

  companion object {
    private const val TAG = "CredManHandler"
  }
}

Framework auf Ihre Aktivität anwenden

Registrieren Sie in Ihrer Activity oder View die WebMessageListener und die zugehörigen Funktionen.

// Inside your Activity or View setup
AndroidView(
  factory = { context ->
    val handler = CredentialManagerHandler(context)
    WebView(context).apply {
      settings.javaScriptEnabled = true

      // Register the bridge before loading URL
      if (WebViewFeature.isFeatureSupported(WebViewFeature.WEB_MESSAGE_LISTENER)) {
                val listener = DigitalCredentialWebListener(coroutineScope, credentialManagerHandler)
                WebViewCompat.addWebMessageListener(
                    webView,
                    INTERFACE_NAME,
                    setOf("*"),
                    listener
                )


      loadUrl("https://your-secure-domain.com/login")
    }
  },
)

Flow wird getestet

Testen Sie den Ablauf, um die Kommunikation zwischen der WebView und der Android-App zu bestätigen. Die Auswahl der Anmeldedaten wird während des Vorgangs in der WebView angezeigt und die ausgewählten Anmeldedaten werden nach Abschluss an die WebView zurückgegeben.