Wear OS-Apps können eigenständig ohne Companion-App ausgeführt werden. Das bedeutet, dass eine Wear OS-App die Authentifizierung selbst verwalten muss, wenn sie auf Daten aus dem Internet zugreift. Die kleine Bildschirmgröße und die eingeschränkten Eingabemöglichkeiten der Smartwatch schränken jedoch die Authentifizierungsoptionen ein, die eine Wear OS-App verwenden kann.
In diesem Leitfaden finden Sie eine Anleitung für die empfohlene Authentifizierungsmethode für Wear OS-Apps, den Credential Manager.
Weitere Informationen zum Entwerfen einer guten Anmeldung finden Sie im Leitfaden zur UX-Anmeldung.
Vorüberlegungen
Beachten Sie vor der Implementierung die folgenden Punkte.
Gastmodus
Verlangen Sie nicht für alle Funktionen eine Authentifizierung. Biete Nutzern stattdessen so viele Funktionen wie möglich, ohne dass sie sich anmelden müssen.
Nutzer können deine Wear-App entdecken und installieren, ohne die mobile App verwendet zu haben. Sie haben also möglicherweise kein Konto und wissen nicht, welche Funktionen sie bietet. Achte darauf, dass die Funktionen deiner App im Gastmodus genau dargestellt werden.
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 Trägererkennung deaktiviert und das Gerät dann vom Handgelenk abnimmt, bleibt das Gerät länger entsperrt als sonst.
Wenn deine App ein höheres Sicherheitsniveau erfordert, z. B. wenn potenziell sensible oder private Daten angezeigt werden, prüfe zuerst, ob die Trageerkennung 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 }
Wenn der Rückgabewert dieser Methode false ist, fordere den Nutzer auf, sich in deiner App in einem Konto anzumelden, bevor du nutzerspezifische Inhalte anzeigst.
Credential Manager
Credential Manager ist die empfohlene API für die Authentifizierung unter Wear OS. Sie bietet Nutzern eine sicherere Umgebung, um sich in einer eigenständigen Umgebung in Wear OS-Anwendungen anzumelden, ohne dass ein verbundenes 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 standardmäßigen Authentifizierungsmechanismen zu implementieren, die sie hostet:
- Passkeys
- Passwörter
- Föderierte Identitäten (z. B. „Über Google anmelden“)
In diesem Leitfaden finden Sie auch Anleitungen zur Migration der anderen zulässigen Wear OS-Authentifizierungsmethoden (Datenebenen-Token-Freigabe und OAuth) als Back-ups für den Credential Manager sowie spezielle Anleitungen für den Übergang von der jetzt verworfenen eigenständigen Schaltfläche „Über Google anmelden“ zur eingebetteten Credential Manager-Version.
Einschränkungen und Unterschiede bei Wear OS
Entwickler sollten die folgenden Einschränkungen und Unterschiede bei Wear OS beachten:
- Der Credential Manager ist auf Wear OS 3 und höher verfügbar.
- Anmeldedaten können nicht unter Wear OS erstellt werden
- Weder Anmeldedaten wiederherstellen noch hybride Anmeldeabläufe werden unterstützt.
- Nur Anbieter von Anmeldedaten mit Wear OS-Integrationen können von Mobilgeräten wiederverwendet werden.
Passkeys auf Wear OS
Entwicklern wird dringend empfohlen, Passkeys in ihren Implementierungen des Credential Managers für Wear OS zu implementieren. Passkeys sind der neue Branchenstandard für die Endnutzerauthentifizierung und bieten Nutzern mehrere wichtige 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 neu 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 weitaus weniger lohnenswert ist, Server zu hacken, und dass im Falle einer Sicherheitsverletzung weitaus weniger Bereinigungsarbeiten erforderlich sind.
- Passkeys bieten Schutz vor Phishing. Passkeys funktionieren nur auf registrierten Websites und in 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.
- Durch Passkeys müssen weniger SMS gesendet werden, was die Authentifizierung kostengünstiger macht.
Passkeys implementieren
Enthält Informationen zur Einrichtung und Anleitung für alle Implementierungstypen.
Einrichtung
Legen Sie das Ziel-API-Level in der Datei „build.gradle“ Ihres Anwendungsmoduls auf 35 fest:
android { defaultConfig { targetSdk(35) } }Fügen Sie der Datei „build.gradle“ für Ihre App oder Ihr Modul die folgenden Zeilen hinzu. Verwenden Sie dabei die neueste stabile Version aus der Referenz zu den
androidx.credentials-Releases.androidx.credentials:credentials:1.6.0 androidx.credentials:credentials-play-services-auth:1.6.0
Integrierte Authentifizierungsmethoden
Da der Credential Manager eine einheitliche API ist, sind die Implementierungsschritte für Wear OS dieselben wie für alle anderen Gerätetypen.
Verwenden Sie die Anleitung für Mobilgeräte, um loszulegen und die Unterstützung von Passkeys und Passwörtern zu implementieren.
Die Schritte zum Hinzufügen der Unterstützung für „Über Google anmelden“ zum Credential Manager sind auf die mobile Entwicklung ausgerichtet, aber die Schritte sind unter Wear OS identisch.
Da Anmeldedaten unter Wear OS nicht erstellt werden können, müssen Sie die in der Anleitung für Mobilgeräte erwähnten Methoden zur Erstellung von Anmeldedaten nicht implementieren.
Sekundäre Authentifizierungsmethoden
Es gibt zwei weitere zulässige Authentifizierungsmethoden für Wear OS-Apps: OAuth 2.0 (beide Varianten) und die Freigabe von mobilen Authentifizierungstokens über die Datenebene. Diese Methoden haben zwar keine Integrationspunkte in der Credential Manager API, können aber als Fallbacks in den UX-Ablauf des Credential Managers aufgenommen werden, falls Nutzer den Credential Manager-Bildschirm schließen.
Wenn der Nutzer den Credential Manager-Bildschirm schließt, fangen Sie im Rahmen Ihrer GetCredential-Logik eine GetCredentialCancellationException ab und rufen Sie Ihre eigene benutzerdefinierte Authentifizierungs-UI auf.
try { val getCredentialResponse: GetCredentialResponse = credentialManager.getCredential(activity, createGetCredentialRequest()) return authenticate(getCredentialResponse.credential) } catch (_: GetCredentialCancellationException) { navigateToSecondaryAuthentication() }
Ihre benutzerdefinierte Authentifizierungs-UI kann dann jede der anderen zulässigen Authentifizierungsmethoden bereitstellen, die im Leitfaden zur UX für die Anmeldung beschrieben sind.
Datenebenen-Token teilen
Die Companion-App auf dem Smartphone kann Authentifizierungsdaten mithilfe der Wearable Data Layer API sicher an die Wear OS-App übertragen. Anmeldedaten als Nachrichten oder Datenelemente übertragen
Bei dieser Art der Authentifizierung ist in der Regel keine Aktion des Nutzers erforderlich. Vermeide jedoch die Authentifizierung, ohne den Nutzer darüber zu informieren, dass er angemeldet wird. Du kannst den Nutzer über einen schließbaren Bildschirm darüber informieren, dass sein Konto vom Mobilgerät übertragen wird.
Wichtig: Deine Wear OS-App muss mindestens eine weitere Authentifizierungsmethode bieten, da diese Option nur auf mit Android gekoppelten Smartwatches funktioniert, wenn die entsprechende mobile App installiert ist. Stelle eine alternative Authentifizierungsmethode für Nutzer bereit, die die entsprechende mobile App nicht haben oder deren Wear OS-Gerät mit einem iOS-Gerät gekoppelt ist.
Übergeben Sie Tokens über die Datenschicht 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)
Überwachen Sie die Wear OS-App auf Datenänderungsereignisse, 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?) {} }
Weitere Informationen zur Verwendung der Wearable-Datenebene findest du unter Daten auf Wear OS senden und synchronisieren.
OAuth 2.0 verwenden
Wear OS unterstützt zwei OAuth 2.0-basierte Abläufe, die in den folgenden Abschnitten beschrieben werden:
- Autorisierungscode-Gewährung mit Proof Key for Code Exchange (PKCE), wie in RFC 7636 definiert
- Device Authorization Grant (DAG), wie in RFC 8628 definiert
Proof Key for Code Exchange (PKCE)
Verwenden Sie RemoteAuthClient, um PKCE effektiv zu nutzen.
Erstelle dann ein OAuthRequest-Objekt, um eine Authentifizierungsanfrage von deiner 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()
Nachdem du die Authentifizierungsanfrage erstellt hast, sende sie mit der Methode sendAuthorizationRequest() 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"))) } } )
Diese Anfrage löst einen Aufruf der Companion-App aus, die dann eine Autorisierungs-UI in einem Webbrowser auf dem Smartphone des Nutzers anzeigt. 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 zur 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 in etwa 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 über die onAuthorizationResponse API an deine Wear OS-App weiter.
Die Smartwatch-App kann den Autorisierungscode dann gegen ein Zugriffstoken eintauschen.
Device Authorization Grant
Bei Verwendung der Geräteautorisierung öffnet der Nutzer den Bestätigungs-URI auf einem anderen Gerät. Anschließend werden sie vom Autorisierungsserver aufgefordert, die Anfrage zu genehmigen oder abzulehnen.
Um diesen Vorgang zu vereinfachen, kannst du eine RemoteActivityHelper verwenden, 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 ) }
Wenn Sie eine iOS-App haben, verwenden Sie universelle Links, um diesen Intent in Ihrer App abzufangen, anstatt sich darauf zu verlassen, dass der Browser das Token autorisiert.