Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Authentifizierung auf Wearables: Anmeldedaten-Manager

Wear OS-Apps können eigenständig ausgeführt werden, ohne dass eine Companion-App erforderlich ist. Das bedeutet, dass eine Wear OS-App die Authentifizierung selbst verwalten muss, wenn sie auf Daten aus dem Internet zugreift. Die geringe Displaygröße und die eingeschränkten Eingabemöglichkeiten der Smartwatch begrenzen jedoch die Authentifizierungsoptionen, die eine Wear OS-App verwenden kann.

In dieser Anleitung wird die empfohlene Authentifizierungsmethode für Wear OS-Apps beschrieben: Credential Manager.

Weitere Informationen zum Design eines guten Anmeldevorgangs finden Sie im Leitfaden zur UX für die Anmeldung.

Vorläufige Überlegungen

Bevor Sie mit der Implementierung beginnen, sollten Sie die folgenden Punkte berücksichtigen.

Gastmodus

Fordern Sie nicht für alle Funktionen eine Authentifizierung an. Stellen Sie dem Nutzer stattdessen so viele Funktionen wie möglich zur Verfügung, ohne dass er sich anmelden muss.

Nutzer können Ihre Wear-App entdecken und installieren, ohne die mobile App verwendet zu haben. Sie haben möglicherweise kein Konto und wissen nicht, welche Funktionen die App bietet. Achten Sie darauf, dass die Funktionen des Gastmodus die Funktionen Ihrer App genau widerspiegeln.

Einige Geräte bleiben möglicherweise länger entsperrt

Auf unterstützten Geräten mit Wear OS 5 oder höher erkennt das System, ob der Nutzer das Gerät am Handgelenk trägt. Wenn der Nutzer die Erkennung des Handgelenks deaktiviert und das Gerät dann vom Handgelenk abnimmt, bleibt das Gerät länger entsperrt als sonst.

Wenn Ihre App ein höheres Sicherheitsniveau erfordert, z. B. wenn potenziell sensible oder private Daten angezeigt werden, prüfen Sie zuerst, ob die Erkennung des Handgelenks aktiviert ist:

fun isWristDetectionAutoLockingEnabled(context: Context): Boolean {
    // Use the keyguard manager to check for the presence of a lock mechanism
    val keyguardManager = context.getSystemService<KeyguardManager>()
    val isSecured = keyguardManager?.isDeviceSecure == true

    // Use OEM-specific system settings to verify that on-body autolock is enabled.
    val isWristDetectionOn = android.provider.Settings.Global.getInt(
        context.contentResolver, PIXEL_WRIST_AUTOLOCK_SETTING_STATE,
        0
    ) == 1

    return isSecured && isWristDetectionOn
}WristDetectionUtility.kt

Wenn der Rückgabewert dieser Methode false ist, fordern Sie den Nutzer auf, sich in einem Konto in Ihrer App anzumelden, bevor Sie nutzerspezifische Inhalte anzeigen.

Credential Manager

Credential Manager ist die empfohlene API für die Authentifizierung unter Wear OS. Sie bietet eine sicherere Umgebung für Nutzer, um sich in einer eigenständigen Umgebung bei Wear OS-Anwendungen anzumelden, ohne dass ein verbundenes gekoppeltes Smartphone erforderlich ist und ohne dass sie sich ihr Passwort merken müssen.

In diesem Dokument werden die Informationen beschrieben, die Entwickler benötigen, um eine Credential Manager-Lösung mit den darin enthaltenen Standardauthentifizierungsmechanismen zu implementieren. Dazu gehören:

Passkeys
Passwörter
Föderierte Identitäten (z. B. „Über Google anmelden“)

In dieser Anleitung wird auch beschrieben, wie Sie die anderen akzeptablen Wear OS-Authentifizierungsmethoden (Data Layer Token Sharing und OAuth) als Back-ups für Credential Manager migrieren. Außerdem finden Sie spezielle Anleitungen für die Umstellung vom jetzt eingestellten eigenständigen Google-Anmeldebutton auf die eingebettete Credential Manager-Version.

Einschränkungen und Unterschiede bei Wear OS

Entwickler sollten die folgenden Einschränkungen und Unterschiede bei Wear OS beachten:

Credential Manager ist auf Wear OS 3 und höher verfügbar.
Anmeldedaten können nicht unter Wear OS erstellt werden.
Weder das Wiederherstellen von Anmeldedaten noch hybride Anmeldevorgänge werden unterstützt.
Nur Credential-Anbieter mit Wear OS-Integrationen können von Mobilgeräten aus wiederverwendet werden.

Passkeys unter Wear OS

Entwickler sollten Passkeys in ihren Wear OS-Implementierungen von Credential Manager implementieren. Passkeys sind der neue Branchenstandard für die Endnutzerauthentifizierung und bieten Nutzern mehrere erhebliche Vorteile.

Passkeys sind einfacher

Nutzer können ein Konto auswählen, mit dem sie sich anmelden möchten. Sie müssen keinen Nutzernamen eingeben.
Nutzer können sich mit der Displaysperre des Geräts authentifizieren.
Nachdem ein Passkey erstellt und registriert wurde, kann der Nutzer nahtlos zu einem neuen Gerät wechseln und es sofort verwenden, ohne sich noch einmal registrieren zu müssen.

Passkeys sind sicherer

Entwickler speichern nur einen öffentlichen Schlüssel auf dem Server, anstatt ein Passwort zu speichern. Das bedeutet, dass es für böswillige Akteure viel weniger Wert hat, in Server einzudringen, und im Falle einer Sicherheitsverletzung viel weniger Aufwand für die Bereinigung erforderlich ist.
Passkeys bieten Schutz vor Phishing. Passkeys funktionieren nur auf den registrierten Websites und in den registrierten Apps. Nutzer können nicht dazu verleitet werden, sich auf einer betrügerischen Website zu authentifizieren, da die Bestätigung vom Browser oder Betriebssystem übernommen wird.
Passkeys machen den Versand von SMS überflüssig und machen die Authentifizierung kostengünstiger.

Passkeys implementieren

Enthält Einrichtung und Anleitung für alle Implementierungstypen.

Einrichtung

Legen Sie in der Datei „build.gradle“ des Anwendungsmoduls die Ziel-API-Ebene auf 35 fest:
```
android {
    defaultConfig {
        targetSdk(35)
    }
}
```
Fügen Sie die folgenden Zeilen in die Datei „build.gradle“ für Ihre App oder Ihr Modul ein, und verwenden Sie dabei die neueste stabile Version aus der androidx.credentials Releases Referenz.
```
androidx.credentials:credentials:1.6.0
androidx.credentials:credentials-play-services-auth:1.6.0
```

Integrierte Authentifizierungsmethoden

Da Credential Manager eine einheitliche API ist, sind die Implementierungsschritte für Wear OS dieselben wie für jeden anderen Gerätetyp.

Folgen Sie der Anleitung für Mobilgeräte , um loszulegen und die Unterstützung für Passkeys und Passwörter zu implementieren.

Die Schritte zum Hinzufügen der Unterstützung für „Über Google anmelden“ zu Credential Manager sind auf die mobile Entwicklung ausgerichtet, aber die Schritte sind unter Wear OS dieselben.

Beachten Sie, dass Anmeldedaten unter Wear OS nicht erstellt werden können. Daher müssen Sie die in der Anleitung für Mobilgeräte erwähnten Methoden zur Erstellung von Anmeldedaten nicht implementieren.

Backup-Authentifizierungsmethoden

Es gibt zwei weitere akzeptable Authentifizierungsmethoden für Wear OS-Apps: OAuth 2.0 (beide Varianten) und Mobile Auth Token Data Layer Sharing. Diese Methoden haben zwar keine Integrationspunkte in der Credential Manager API, können aber in Ihren UX-Ablauf von Credential Manager als Fallbacks aufgenommen werden, falls Nutzer den Credential Manager-Bildschirm schließen.

Wenn der Nutzer den Credential Manager-Bildschirm schließt, fangen Sie eine NoCredentialException im Rahmen Ihrer GetCredential Logik ab und wechseln Sie zu Ihrer eigenen benutzerdefinierten Authentifizierungs-UI.

try {
    val getCredentialResponse: GetCredentialResponse =
        credentialManager.getCredential(activity, createGetCredentialRequest())
    return authenticate(getCredentialResponse.credential)
} catch (_: GetCredentialCancellationException) {
    navigateToSecondaryAuthentication()
}CredentialManager.kt

Ihre benutzerdefinierte Authentifizierungs-UI kann dann eine der anderen akzeptablen Authentifizierung methoden anbieten, die im Leitfaden zur UX für die Anmeldung beschrieben sind.

Tokenfreigabe über die Datenebene

Die Companion-App für Smartphones kann Authentifizierungsdaten sicher über die Wearable Data Layer API an die Wear OS-App übertragen. Übertragen Sie Anmeldedaten als Nachrichten oder als Datenelemente.

Für diese Art der Authentifizierung ist in der Regel keine Aktion des Nutzers erforderlich. Vermeiden Sie jedoch die Authentifizierung, ohne den Nutzer darüber zu informieren, dass er angemeldet wird. Sie können den Nutzer über einen schließbaren Bildschirm informieren, auf dem angezeigt wird, dass sein Konto vom Mobilgerät übertragen wird.

Wichtig:Ihre Wear OS-App muss mindestens eine weitere Authentifizierungsmethode anbieten, da diese Option nur auf mit Android gekoppelten Smartwatches funktioniert, wenn die entsprechende mobile App installiert ist. Bieten Sie eine alternative Authentifizierungsmethode für Nutzer an, die die entsprechende mobile App nicht haben oder deren Wear OS-Gerät mit einem iOS-Gerät gekoppelt ist.

Übergeben Sie Token über die Datenebene aus der mobilen App, wie im folgenden Beispiel gezeigt:

val token = "..." // Auth token to transmit to the Wear OS device.
val putDataReq: PutDataRequest = PutDataMapRequest.create("/auth").run {
    dataMap.putString("token", token)
    asPutDataRequest()
}
val putDataTask: Task<DataItem> = Wearable.getDataClient(this).putDataItem(putDataReq)DataLayerActivity.kt

Achten Sie in der Wear OS-App auf Ereignisse zur Datenänderung, wie im folgenden Beispiel gezeigt:

class AuthDataListenerService : WearableListenerService() {
    override fun onDataChanged(dataEvents: DataEventBuffer) {
        dataEvents.forEach { event ->
            if (event.type == DataEvent.TYPE_CHANGED) {
                val dataItemPath = event.dataItem.uri.path ?: ""

                if (dataItemPath.startsWith("/auth")) {
                    val token = DataMapItem.fromDataItem(event.dataItem)
                        .dataMap
                        .getString("token")
                    // Display an interstitial screen to notify the user that they're being signed
                    // in. Then, store the token and use it in network requests.
                    handleSignInSequence(token)
                }
            }
        }
    }

    /** placeholder sign in handler. */
    fun handleSignInSequence(token: String?) {}
}DataLayerService.kt

Weitere Informationen zur Verwendung der Wearable Data Layer API finden Sie unter Daten auf Wear OS senden und synchronisieren.

OAuth 2.0 verwenden

Wear OS unterstützt zwei auf OAuth 2.0 basierende Abläufe, die in den folgenden Abschnitten beschrieben werden:

Autorisierungscode mit Proof Key for Code Exchange (PKCE) gemäß RFC 7636
Geräteautorisierung (Device Authorization Grant, DAG) gemäß RFC 8628

Proof Key for Code Exchange (PKCE)

Verwenden Sie RemoteAuthClient, um PKCE effektiv zu nutzen. Erstellen Sie dann ein OAuthRequest-Objekt, um eine Auth-Anfrage von Ihrer Wear OS-App an einen OAuth-Anbieter zu senden. Dieses Objekt besteht aus einer URL zu Ihrem OAuth-Endpunkt zum Abrufen eines Tokens und einem CodeChallenge-Objekt.

Der folgende Code zeigt ein Beispiel für das Erstellen einer Authentifizierungsanfrage:

val oauthRequest = OAuthRequest.Builder(context)
    .setAuthProviderUrl(uri)
    .setCodeChallenge(codeChallenge)
    .setClientId(CLIENT_ID)
    .build()OAuthPKCE.kt

Nachdem Sie die Authentifizierungsanfrage erstellt haben, senden Sie sie mit der sendAuthorizationRequest() Methode an die Companion-App:

RemoteAuthClient.create(context).sendAuthorizationRequest(
    request = oauthRequest,
    executor = { command -> command?.run() },
    clientCallback = object : RemoteAuthClient.Callback() {
        override fun onAuthorizationResponse(
            request: OAuthRequest,
            response: OAuthResponse
        ) {
            // Extract the token from the response, store it, and use it in requests.
            continuation.resume(parseCodeFromResponse(response))
        }
        override fun onAuthorizationError(request: OAuthRequest, errorCode: Int) {
            // Handle Errors
            continuation.resume(Result.failure(IOException("Authorization failed")))
        }
    }
)OAuthPKCE.kt

Diese Anfrage löst einen Aufruf an die Companion-App aus, die dann eine Autorisierungs-UI in einem Webbrowser auf dem Mobilgerät des Nutzers präsentiert. Der OAuth 2.0-Anbieter authentifiziert den Nutzer und holt die Einwilligung des Nutzers für die angeforderten Berechtigungen ein. Die Antwort wird an die automatisch generierte Weiterleitungs-URL gesendet.

Nach einer erfolgreichen oder fehlgeschlagenen Autorisierung leitet der OAuth 2.0-Server zu der in der Anfrage angegebenen URL weiter. Wenn der Nutzer die Zugriffsanfrage genehmigt, enthält die Antwort einen Autorisierungscode. Wenn der Nutzer die Anfrage nicht genehmigt, enthält die Antwort eine Fehlermeldung.

Die Antwort hat die Form eines Abfragestrings und sieht so aus:

  https://wear.googleapis.com/3p_auth/com.your.package.name?code=xyz
  https://wear.googleapis-cn.com/3p_auth/com.your.package.name?code=xyz

Dadurch wird eine Seite geladen, die den Nutzer zur Companion-App weiterleitet. Die Companion-App überprüft die Antwort-URL und leitet die Antwort mit der onAuthorizationResponse-API an Ihre Wear OS-App weiter.

Die Smartwatch-App kann dann den Autorisierungscode gegen ein Zugriffstoken austauschen.

Geräteautorisierung

Bei der Geräteautorisierung öffnet der Nutzer den Bestätigungs-URI auf einem anderen Gerät. Anschließend fordert der Autorisierungsserver ihn auf, die Anfrage zu genehmigen oder abzulehnen.

Um diesen Vorgang zu vereinfachen, verwenden Sie ein RemoteActivityHelper, um eine Webseite auf dem gekoppelten Mobilgerät des Nutzers zu öffnen, wie im folgenden Beispiel gezeigt:

// Request access from the authorization server and receive Device Authorization Response.
private fun verifyDeviceAuthGrant(verificationUri: String) {
    RemoteActivityHelper(context).startRemoteActivity(
        Intent(Intent.ACTION_VIEW).apply {
            addCategory(Intent.CATEGORY_BROWSABLE)
            data = Uri.parse(verificationUri)
        },
        null
    )
}OAuthDAG.kt

Wenn Sie eine iOS-App haben, verwenden Sie universelle Links, um diesen Intent in Ihrer App abzufangen, anstatt sich auf den Browser zu verlassen, um das Token zu autorisieren.