Diese Seite wurde von der Cloud Translation API übersetzt.

Authentifizierung auf Wearables

Wear OS-Apps können eigenständig ohne Begleit-App ausgeführt werden. Das bedeutet, dass eine Wear OS-App die Authentifizierung beim Zugriff auf Daten aus dem Internet selbst verwalten muss. Durch die kleine Displaygröße und die eingeschränkten Eingabemöglichkeiten der Smartwatch sind jedoch die Authentifizierungsoptionen eingeschränkt, die eine Wear OS-App verwenden kann.

In diesem Leitfaden werden die empfohlenen Authentifizierungsmethoden für Wear OS-Apps sowie Alternativen beschrieben, wenn diese Methoden für den Anwendungsfall einer App nicht geeignet sind.

Weitere Informationen zum Gestalten einer guten Anmeldung findest du im UX-Leitfaden für die Anmeldung.

Gastmodus

Verlangen Sie keine Authentifizierung für alle Funktionen. Stelle dem Nutzer stattdessen so viele Funktionen wie möglich zur Verfügung, ohne dass er sich anmelden muss.

Es kann sein, dass Nutzer deine Wear-App finden und installieren, ohne sie zuvor verwendet zu haben. In diesem Fall haben sie möglicherweise kein Konto und wissen nicht, welche Funktionen sie bietet. Achten Sie darauf, dass der Gastmodus die Funktionen Ihrer App korrekt zur Geltung kommt.

Empfohlene Authentifizierungsmethoden

Mit den folgenden Authentifizierungsmethoden kannst du eigenständige Wear OS-Apps ermöglichen, Anmeldedaten zur Nutzerauthentifizierung abzurufen.

Tokens über die Datenschicht übergeben

Die Companion-App des Smartphones kann mithilfe der Wearable-Datenschicht Authentifizierungsdaten sicher an die Wear OS-App übertragen. Anmeldedaten als Nachrichten oder Datenelemente übertragen

Diese Art der Authentifizierung erfordert normalerweise keine Aktion des Nutzers. Vermeiden Sie es jedoch, eine Authentifizierung durchzuführen, ohne den Nutzer darüber zu informieren, dass er angemeldet ist. Du kannst den Nutzer über einen einfachen, schließbaren Bildschirm informieren, auf dem angezeigt wird, dass sein Konto vom Mobilgerät übertragen wird.

Wichtig:Deine Wear-App muss mindestens eine weitere Authentifizierungsmethode bieten, da diese Option nur auf mit Android gekoppelten Smartwatches funktioniert, wenn die entsprechende mobile App installiert ist. Biete 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 Tokens mithilfe der Datenschicht aus der mobilen App, wie im folgenden Beispiel gezeigt:

val token = "..." // Auth token to transmit to the wearable device.
val dataClient: DataClient = Wearable.getDataClient(context)
val putDataReq: PutDataRequest = PutDataMapRequest.create("/auth").run {
    dataMap.putString("token", token)
    asPutDataRequest()
}
val putDataTask: Task<DataItem> = dataClient.putDataItem(putDataReq)

Du kannst in der Smartwatch-App auf Datenänderungsereignisse warten, wie im folgenden Beispiel gezeigt:

val dataClient: DataClient = Wearable.getDataClient(context)
dataClient.addListener{ dataEvents ->
    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 interstitial screen to notify the user they are being signed in.
                // Then, store the token and use it in network requests.
            }
        }
    }
}

Weitere Informationen zur Verwendung der Wearable-Datenschicht finden Sie unter Daten unter 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-Gewährung mit Proof Key for Code Exchange (PKCE), gemäß RFC 7636
Gewährung der Geräteautorisierung gemäß Definition in RFC 8628

Hinweis: Damit deine App nicht heruntergefahren wird, wenn die Smartwatch in den Inaktivmodus wechselt, aktiviere in der Aktivität zur Authentifizierung die Option „Always-On“ mit AmbientModeSupport.attach. Weitere Informationen zu Best Practices im Inaktivmodus findest du unter App unter Wear sichtbar halten.

Proof Key for Code Exchange (PKCE)

Verwenden Sie RemoteAuthClient, um PKCE effektiv zu nutzen.

Um eine Authentifizierungsanfrage von deiner Wear OS-App an einen OAuth-Anbieter durchzuführen, erstelle ein OAuthRequest-Objekt. Dieses Objekt besteht aus einer URL zu deinem OAuth-Endpunkt, um ein Token abzurufen, und einem CodeChallenge-Objekt. Der folgende Code zeigt ein Beispiel für das Erstellen einer Authentifizierungsanfrage:

val request = OAuthRequest.Builder(this.applicationContext)
    .setAuthProviderUrl(Uri.parse("https://...."))
    .setClientId(clientId)
    .setCodeChallenge(codeChallenge)
    .build()

Nachdem du die Authentifizierungsanfrage erstellt hast, sende sie mit der Methode sendAuthorizationRequest() an die Companion-App:

val client = RemoteAuthClient.create(this)
client.sendAuthorizationRequest(request,
    { command -> command?.run() },
    object : RemoteAuthClient.Callback() {
        override fun onAuthorizationResponse(
            request: OAuthRequest,
            response: OAuthResponse
        ) {
            // Extract the token from the response, store it and use it in network requests.
        }

        override fun onAuthorizationError(errorCode: Int) {
            // Handle error
        }
    }
)

Diese Anfrage löst einen Aufruf an die 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 seine Einwilligung für die angeforderten Berechtigungen ein. Die Antwort wird an die automatisch generierte Weiterleitungs-URL gesendet.

Nach einer erfolgreichen oder fehlgeschlagenen Autorisierung wird der OAuth 2.0-Server an die in der Anfrage angegebene URL weitergeleitet. 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 erfolgt in Form eines Abfragestrings und sieht wie eines der folgenden Beispiele 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 mithilfe der onAuthorizationResponse API an die Drittanbieter-Smartwatch-App weiter.

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

Hinweis:Sobald die OAuthRequest erstellt wurde, finden Sie die Weiterleitungs-URL unter redirectUrl.

Gewährung Geräteautorisierung

Bei Verwendung 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.

Du kannst diesen Vorgang vereinfachen, indem du ein RemoteActivityHelper verwendest, 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.
val verificationUri = "..." // Extracted from the Device Authorization Response.
RemoteActivityHelper.startRemoteActivity(
    this,
    Intent(Intent.ACTION_VIEW)
        .addCategory(Intent.CATEGORY_BROWSABLE)
        .setData(Uri.parse(verificationUri)),
    null
)
// Poll the authorization server to find out if the user completed the user authorization
// step on their mobile device.

Wenn Sie eine iOS-App haben, verwenden Sie universelle Links, um diesen Intent in der App abzufangen, anstatt das Token über den Browser autorisieren zu müssen.

Andere Authentifizierungsmethoden

Wear OS unterstützt zusätzliche Anmeldemethoden, die in den folgenden Abschnitten beschrieben werden.

Über Google Log-in kann sich der Nutzer mit seinem bestehenden Google-Konto anmelden. Er bietet die beste Nutzererfahrung und ist einfach zu unterstützen, insbesondere wenn Sie ihn bereits in Ihren Handheld-Apps implementiert haben.

Nach den zuvor beschriebenen empfohlenen Authentifizierungsmethoden ist Google Log-in die nächstbeste Lösung, da es auch unter iOS funktioniert. Im folgenden Abschnitt wird beschrieben, wie du eine grundlegende Google Log-in-Integration vornimmst.

Voraussetzungen

Bevor du Google Log-in in deine Wear OS-App integrieren kannst, musst du ein Google API Console-Projekt konfigurieren und dein Android Studio-Projekt einrichten. Weitere Informationen findest du unter Google Log-in in deine Android-App einbinden.

Wenn du Google Log-in für eine App oder Website verwendest, die mit einem Backend-Server kommuniziert, gelten zwei zusätzliche Voraussetzungen:

Erstellen Sie eine Client-ID für die OAuth 2.0-Webanwendung für Ihren Back-End-Server. Diese Client-ID unterscheidet sich von der Client-ID Ihrer App. Weitere Informationen finden Sie unter Serverseitigen Zugriff aktivieren.
Identifizieren Sie den aktuell angemeldeten Nutzer sicher auf dem Server, indem Sie das ID-Token des Nutzers über HTTPS senden. Informationen zum Authentifizieren des Nutzers auf dem Backend-Server findest du unter Bei einem Backend-Server authentifizieren.

Überprüfe und implementiere die folgenden Schritte, die in den folgenden Abschnitten beschrieben werden, um Google Log-in in deine Wear OS-App einzubinden:

Google Log-in konfigurieren
Schaltfläche „Google Log-in“ hinzufügen
Anmeldevorgang starten, wenn auf die Anmeldeschaltfläche getippt wird

Konfiguriere Google Log-in in der onCreate()-Methode deiner Anmeldeaktivität so, dass die für deine App erforderlichen Nutzerdaten angefordert werden. Erstelle dann ein GoogleApiClient-Objekt mit Zugriff auf die Google Log-in API und die von dir angegebenen Optionen. Diese Schritte werden im folgenden Beispiel gezeigt:

  public class MyNewActivity extends AppCompatActivity {

    private static final int RC_SIGN_IN = 9001;

    private GoogleSignInClient mSignInClient;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        GoogleSignInOptions options =
               new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
                        .build();

        mSignInClient = GoogleSignIn.getClient(this, options);
    }
  }

Ihrer App eine Google Log-in-Schaltfläche hinzufügen

So fügen Sie eine Schaltfläche für Google Log-in hinzu:

Füge dem Layout deiner App SignInButton hinzu:

 <com.google.android.gms.common.SignInButton
 android:id="@+id/sign_in_button"
 android:layout_width="wrap_content"
 android:layout_height="wrap_content" />

Registriere in der onCreate()-Methode deiner App das OnClickListener deiner Schaltfläche, um den Nutzer beim Antippen anzumelden:

Kotlin

findViewById<View>(R.id.sign_in_button).setOnClickListener(this)

Java

findViewById(R.id.sign_in_button).setOnClickListener(this);

Zum Verarbeiten von Anmeldeschaltflächen in der Methode onCLick() wird mit der Methode getSignInIntent() ein Anmelde-Intent erstellt. Starten Sie dann den Intent mit der Methode startActivityForResult().

  Intent intent = mSignInClient.getSignInIntent();
  startActivityForResult(intent, RC_SIGN_IN);

The user is prompted to select a Google account to sign in with. If you requested scopes beyond profile, email, and open ID, the user is also prompted to grant access to those resources.

Finally, in the activity's onActivityResult method, retrieve the sign-in result with getSignInResultFromIntent. After you retrieve the sign-in result, you can check whether the sign-in succeeded using the isSuccess method. If sign-in succeeds, you can call the getSignInAccount method to get a GoogleSignInAccount object that contains information about the signed-in user, such as the user's name. These steps are shown in the following example:

Kotlin

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    super.onActivityResult(requestCode, resultCode, data)

    // Result returned from launching the Intent from GoogleSignInApi.getSignInIntent(...).
    if (requestCode == RC_SIGN_IN) {
        Auth.GoogleSignInApi.getSignInResultFromIntent(data)?.apply {
            if (isSuccess) {
                // Get account information.
                fullName = signInAccount?.displayName
                mGivenName = signInAccount?.givenName
                mFamilyName = signInAccount?.familyName
                mEmail = signInAccount?.email
            }
        }
    }
}

Java

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    // Result returned from launching the Intent from GoogleSignInApi.getSignInIntent(...).
    if (requestCode == RC_SIGN_IN) {
        GoogleSignInResult signInResult = Auth.GoogleSignInApi.getSignInResultFromIntent(data);
        if (signInResult.isSuccess()) {
            GoogleSignInAccount acct = signInResult.getSignInAccount();

            // Get account information.
            fullName = acct.getDisplayName();
            givenName = acct.getGivenName();
            familyName = acct.getFamilyName();
            email = acct.getEmail();
        }
    }
}

Im Horologist Google Log-in-Beispiel auf GitHub findest du eine Beispiel-App, in der Google Log-in implementiert ist.

Authentifizierung mit benutzerdefiniertem Code

Als Alternative zu den zuvor beschriebenen Authentifizierungsmethoden kannst du festlegen, dass sich der Nutzer über ein anderes Gerät authentifizieren muss, z. B. ein Smartphone oder Tablet, und einen kurzlebigen numerischen Code abrufen. Der Nutzer gibt dann den Code auf seinem Wear OS-Gerät ein, um seine Identität zu bestätigen, und erhält ein Authentifizierungstoken.

Bei diesem Authentifizierungsvorgang wird entweder das Anmeldemodul Ihrer App verwendet oder manuell die Anmeldemethode eines Drittanbieters in den Code Ihrer App integriert. Diese Authentifizierungsmethode erfordert manuelle Arbeit und zusätzlichen Aufwand, um sie sicherer zu machen. Du kannst sie jedoch verwenden, wenn du eine frühere Authentifizierung in deinen eigenständigen Wear OS-Apps benötigst.

Der Autorisierungsablauf für diese Einrichtung funktioniert so:

Der Nutzer führt eine Aktion mit der Wear OS-App aus, die eine Autorisierung erfordert.
Die Wear OS-App zeigt dem Nutzer einen Authentifizierungsbildschirm an und weist ihn an, einen Code von einer angegebenen URL einzugeben.
Der Nutzer wechselt zu einem Mobilgerät, Tablet oder PC, startet dann einen Browser, ruft die in der Wear OS-App angegebene URL auf und meldet sich an.
Der Nutzer erhält einen kurzlebigen numerischen Code, den er auf dem Authentifizierungsbildschirm der Wear OS-App über die integrierte Tastatur in Wear OS eingibt:
Ab diesem Zeitpunkt kannst du den eingegebenen Code als Nachweis dafür verwenden, dass dies der richtige Nutzer ist, und den Code gegen ein Authentifizierungstoken austauschen, das auf dem Wear OS-Gerät gespeichert und gesichert ist, um authentifizierte Aufrufe zu erhalten.

Hinweis:Der vom Nutzer generierte Code muss nur numerisch sein und darf keine alphabetischen Zeichen enthalten.

Dieser Autorisierungsablauf wird im folgenden Diagramm dargestellt:

Authentifizierung auf Wearables

Gastmodus

Empfohlene Authentifizierungsmethoden

Tokens über die Datenschicht übergeben

OAuth 2.0 verwenden

Proof Key for Code Exchange (PKCE)

Gewährung Geräteautorisierung

Andere Authentifizierungsmethoden

Google-Anmeldung

Voraussetzungen

Google Log-in in deine App einbinden

Google Log-in konfigurieren und das GoogleApiClient-Objekt erstellen

Ihrer App eine Google Log-in-Schaltfläche hinzufügen

Kotlin

Java

Anmelde-Intent erstellen und Anmeldevorgang starten

Kotlin

Java

Authentifizierung mit benutzerdefiniertem Code