Authentifizierung auf Wearables

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

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

Weitere Informationen zur Gestaltung einer nutzerfreundlichen Anmeldung finden Sie im UX-Leitfaden für die Anmeldung.

Gastmodus

Für alle Funktionen ist keine Authentifizierung erforderlich. Bieten Sie Nutzern stattdessen so viele Funktionen wie möglich, ohne dass sie sich anmelden müssen.

Nutzer können Ihre Wear OS-App finden und installieren, ohne die mobile App verwendet zu haben. Daher haben sie möglicherweise kein Konto und wissen nicht, welche Funktionen die App bietet. Achten Sie darauf, dass die Funktionen des Gastmodus die Funktionen Ihrer App korrekt präsentieren.

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 nimmt, hält das System das Gerät länger entsperrt als es sonst der Fall wäre.

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

val wristDetectionEnabled =
        isWristDetectionAutoLockingEnabled(applicationContext)

Wenn der Rückgabewert dieser Methode false ist, bitte den Nutzer, sich in einem Konto in Ihrer App anzumelden, bevor du ihm nutzerspezifische Inhalte zeigst.

Empfohlene Authentifizierungsmethoden

Mit den folgenden Authentifizierungsmethoden können eigenständige Wear OS-Apps Anmeldedaten für die Nutzerauthentifizierung abrufen.

Tokens über die Datenschicht übergeben

Die Smartphone-Begleiter-App kann Authentifizierungsdaten über die Wearable Data Layer 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. Führen Sie die Authentifizierung jedoch nicht durch, ohne den Nutzer darüber zu informieren, dass er angemeldet wird. Sie können den Nutzer über einen einfachen, wegklickbaren Bildschirm darüber informieren, dass sein Konto von einem 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.

Über die Datenebene der mobilen App übergebene Karten-/Ticket-Tokens, 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)

Sie können 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 Data Layer finden Sie unter Daten in 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-Genehmigung mit Proof Key for Code Exchange (PKCE) gemäß RFC 7636
• Device Authorization Grant (Geräteautorisierungsberechtigung), wie in RFC 8628 definiert

Hinweis:Damit Ihre App nicht heruntergefahren wird, wenn die Smartwatch in den Ruhemodus wechselt, aktivieren Sie die Daueranzeige mit AmbientModeSupport.attach in der Aktivität, bei der die Authentifizierung durchgeführt wird. Weitere Informationen zu Best Practices für den Inaktivmodus finden Sie unter Sicherstellen der Sichtbarkeit der App auf Wear.

Proof Key for Code Exchange (PKCE)

Verwenden Sie RemoteAuthClient, um PKCE effektiv zu nutzen.

Wenn Sie eine Authentifizierungsanfrage von Ihrer Wear OS-App an einen OAuth-Anbieter senden möchten, erstellen Sie ein OAuthRequest-Objekt. Dieses Objekt besteht aus einer URL zu Ihrem OAuth-Endpunkt zum Abrufen eines Tokens und einem CodeChallenge-Objekt. Im folgenden Code wird ein Beispiel für die Erstellung einer Authentifizierungsanfrage gezeigt:

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 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 den Zugriff 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 Suchstrings 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, über die der Nutzer zur Companion App weitergeleitet wird. Die Companion App überprüft die Antwort-URL und leitet die Antwort über die onAuthorizationResponse API an die Smartwatch-App des Drittanbieters weiter.

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

Hinweis:Nachdem die OAuthRequest erstellt wurde, finden Sie die URL der Weiterleitung unter redirectUrl.

Geräteautorisierung gewähren

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

Um diesen Vorgang zu vereinfachen, kannst du mit einem RemoteActivityHelper eine Webseite auf dem gekoppelten Mobilgerät des Nutzers ö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 diese Intents in Ihrer App abzufangen, anstatt sich auf den Browser zur Autorisierung des Tokens zu verlassen.

Andere Authentifizierungsmethoden

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

Google-Anmeldung

Mit Google Sign-in können sich Nutzer mit ihrem bestehenden Google-Konto anmelden. Sie bietet die beste Nutzerfreundlichkeit und ist einfach zu unterstützen, insbesondere wenn Sie sie bereits in Ihren Apps für Mobilgeräte implementiert haben.

Nach den oben beschriebenen empfohlenen Authentifizierungsmethoden ist die Anmeldung über Google die nächste bevorzugte Lösung, da sie auch auf iOS-Geräten gut funktioniert. Im folgenden Abschnitt wird beschrieben, wie Sie eine grundlegende Google Sign-In-Integration vornehmen.

Voraussetzungen

Bevor Sie Google Sign-In in Ihre Wear OS-App einbinden können, müssen Sie ein Google API Console-Projekt konfigurieren und Ihr Android Studio-Projekt einrichten. Weitere Informationen finden Sie unter Google Log-in in Ihre Android-App einbinden.

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

• Erstellen Sie eine OAuth 2.0-Webanwendungs-Client-ID für Ihren Backend-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 auf dem Server sicher, indem Sie das ID-Token des Nutzers über HTTPS senden. Informationen dazu, wie du Nutzer auf dem Backend-Server authentifizierst, findest du unter Mit einem Backend-Server authentifizieren.

Google Sign-in in Ihre App einbinden

Führen Sie die folgenden Schritte aus, die in den folgenden Abschnitten beschrieben werden, um Google Sign-in in Ihre Wear OS-App einzubinden:

1. Google Log-in konfigurieren
2. Fügen Sie eine Schaltfläche für Google Log-in hinzu.
3. Starten Sie den Anmeldevorgang, wenn die Anmeldeschaltfläche angetippt wird.

Google Sign-In konfigurieren und das GoogleApiClient-Objekt erstellen

Konfigurieren Sie in der onCreate()-Methode Ihrer Anmeldeaktivität Google Sign-In so, dass die von Ihrer App benötigten Nutzerdaten angefordert werden. Erstellen Sie dann ein GoogleApiClient-Objekt mit Zugriff auf die Google Sign-In API und die von Ihnen angegebenen Optionen. Diese Schritte sind im folgenden Beispiel dargestellt:

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 Schaltfläche für Google Log-in hinzufügen

So fügen Sie eine Schaltfläche für die Anmeldung über Google hinzu:

1. Fügen Sie dem Layout Ihrer App den SignInButton hinzu:

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

2. Registrieren Sie in der onCreate()-Methode Ihrer App die OnClickListener Ihrer Schaltfläche, um den Nutzer anzumelden, wenn er darauf tippt:

Kotlin

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

Java

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

Anmeldeabsicht erstellen und Anmeldevorgang starten

Wenn Sie in Ihrer onCLick()-Methode die Tippen auf die Anmeldeschaltfläche verarbeiten möchten, erstellen Sie einen Anmelde-Intent mit der Methode getSignInIntent(). Starten Sie dann den Intent mit der Methode startActivityForResult().

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

Der Nutzer wird aufgefordert, ein Google-Konto auszuwählen, mit dem er sich anmelden möchte. Wenn Sie Zugriffsbereiche angefordert haben, die über „Profil“, „E-Mail“ und „OpenID“ hinausgehen, wird der Nutzer auch aufgefordert, Zugriff auf diese Ressourcen zu gewähren.

Rufen Sie abschließend in der Methode onActivityResult der Aktivität das Anmeldeergebnis mit getSignInResultFromIntent ab. Nachdem du das Anmeldeergebnis abgerufen hast, kannst du mit der Methode isSuccess prüfen, ob die Anmeldung erfolgreich war. Wenn die Anmeldung erfolgreich war, kannst du die Methode getSignInAccount aufrufen, um ein GoogleSignInAccount-Objekt mit Informationen zum angemeldeten Nutzer zu erhalten, z. B. seinen Namen. Diese Schritte sind im folgenden Beispiel dargestellt:

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
            }
        }
    }
}

@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();
        }
    }
}