Authentifizierung auf Wearables

Wear OS-Apps können eigenständig ohne Companion-App ausgeführt werden. Das bedeutet, dass Eine Wear OS-App muss die Authentifizierung beim Zugriff auf Daten aus dem Internet. Aber das kleine Display der Uhr Eingabefunktionen schränken die Authentifizierungsoptionen ein, die eine Wear OS-App verwenden kann.

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

Weitere Informationen zur Gestaltung einer guten Anmeldung finden Sie in der UX der Anmeldung .

Gastmodus

Erzwingen Sie für alle Funktionen keine Authentifizierung. Bieten Sie stattdessen so viele Funktionen wie ohne sich anmelden zu müssen.

Nutzer könnten deine Wear-App finden und installieren, ohne das Smartphone zu verwenden Die Nutzer haben also kein Konto und wissen nicht, welche Funktionen sie Angebote. Achten Sie darauf, dass im Gastmodus die Funktionen Ihrer App korrekt präsentiert 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, Der Nutzer trägt das Gerät am Handgelenk. Wenn der Nutzer das Handgelenk abschaltet und das Gerät dann vom Handgelenk nehmen, sorgt das System dafür, Gerät länger als sonst entsperrt.

Wenn Ihre App ein höheres Sicherheitsniveau erfordert, z. B. bei der Anzeige potenziell sensible oder private Daten: Prüfe zuerst, ob die Handgelenkerkennung aktiviert:

val wristDetectionEnabled =
        isWristDetectionAutoLockingEnabled(applicationContext)

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

Empfohlene Authentifizierungsmethoden

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

Tokens mit der Datenschicht übergeben

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

Bei dieser Art der Authentifizierung ist in der Regel keine Aktion des Nutzers erforderlich. Vermeiden Sie es jedoch, eine Authentifizierung durchführen, ohne den Nutzer über seine Anmeldung zu informieren. Sie können die Nutzer über einen einfachen Bildschirm, der sie schließen kann, darüber informieren, übertragen werden.

Wichtig: Deine Wear-App muss mindestens eine andere Authentifizierungsmethode anbieten, weil funktioniert diese Option nur auf Uhren, die mit einem Android-Gerät gekoppelt sind, wenn die entsprechende mobile App installiert ist Alternative bereitstellen Authentifizierungsmethode für Nutzer, die nicht die entsprechende mobile App haben oder deren Wear OS-Geräte -Gerät mit einem iOS-Gerät gekoppelt ist.

Übergeben Sie Tokens mithilfe der Datenschicht in 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)

Warten Sie auf Datenänderungsereignisse in der Smartwatch-App, 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 OAuth 2.0-basierte Abläufe, die in den Abschnitten beschrieben werden. Folgende:

• Authorization Code Grant with Proof Key for Code Exchange (PKCE), wie in RFC 7636
• Erteilung der Geräteautorisierung, wie in den RFC 8628

Hinweis:So wird sichergestellt, dass Ihre App nicht heruntergefahren wird, wenn die Smartwatch in den Inaktivmodus wechselt. aktivieren Sie "Always-On" mit AmbientModeSupport.attach der Authentifizierung. Weitere Informationen zu Best Practices für den Inaktivmodus Siehe App unter Wear sichtbar halten.

Nachweisschlüssel für Code Exchange (PKCE)

Um PKCE effektiv zu nutzen, verwenden Sie RemoteAuthClient

Wenn du von deiner Wear OS-App eine Authentifizierungsanfrage an einen OAuth-Anbieter senden möchtest, erstelle ein OAuthRequest -Objekt enthält. Dieses Objekt besteht aus einer URL zu deinem OAuth-Endpunkt zum Abrufen eines Tokens und einem CodeChallenge -Objekt enthält. 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 Sie die Authentifizierungsanfrage erstellt haben, senden Sie sie mithilfe der Methode sendAuthorizationRequest()-Methode:

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 Web anzeigt. Browser auf dem Mobiltelefon des Nutzers. Der OAuth 2.0-Anbieter authentifiziert den Nutzer und erhält die Zustimmung des Nutzers für die angeforderten Berechtigungen. Die Antwort wird an die automatisch generierte Weiterleitungs-URL

Nach einer erfolgreichen oder fehlgeschlagenen Autorisierung führt der OAuth 2.0-Server eine Weiterleitung zur angegebenen URL durch. in der Anfrage. Wenn der Nutzer die Zugriffsanfrage genehmigt, enthält die Antwort einen Autorisierungscode. Wenn der Nutzer die Anfrage nicht genehmigt, enthält die Antwort einen Fehler angezeigt.

Die Antwort liegt in Form eines Abfragestrings vor 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 Antwort-URL und leitet die Antwort über die onAuthorizationResponse-API.

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

Hinweis: Nachdem die OAuthRequest erstellt wurde, finden Sie Ihre Weiterleitungs-URL unter redirectUrl ein.

Geräteautorisierung gewähren

Bei Verwendung der Geräteautorisierung öffnet der Nutzer den Bestätigungs-URI auf einem anderen Gerät. Dann werden vom Autorisierungsserver gebeten, 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.
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 Ihrer App abzufangen, anstatt sich auf die Autorisierung des Tokens durch den Browser zu verlassen.

Andere Authentifizierungsmethoden

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

Google-Anmeldung

Über Google Log-in kann sich der Nutzer mit seinem bestehenden Google-Konto anmelden. Es bietet die Nutzererfahrung und ist einfach zu unterstützen, insbesondere wenn Sie in deinen Handheld-Apps.

Nach den oben beschriebenen empfohlenen Authentifizierungsmethoden Die Anmeldung ist die nächste bevorzugte Lösung, da sie auch unter iOS funktioniert. Die folgenden wird beschrieben, wie Sie eine grundlegende Integration von Google Log-in durchführen.

Voraussetzungen

Bevor du Google Log-in in deine Wear OS-App integrieren kannst, musst du eine Google API Console-Projekt erstellen und Ihr Android Studio-Projekt einrichten. Weitere Informationen Siehe Google Log-in in deine Android-App einbinden

Wenn Sie Google Log-in mit einer App oder Website verwenden, mit einem Back-End-Server kommuniziert, gibt es zwei zusätzliche Voraussetzungen:

• OAuth 2.0-Webanwendungs-Client-ID erstellen für Back-End-Server. Diese Client-ID unterscheidet sich von der Client-ID Ihrer App. Weitere Informationen finden Sie unter Serverseitigen Zugriff aktivieren
• Den aktuell angemeldeten Nutzer durch Senden des ID-Tokens sicher auf dem Server identifizieren mit HTTPS. Informationen zum Authentifizieren Ihres Nutzers auf dem Backend-Server finden Sie unter Bei einem Backend-Server authentifizieren

Google Log-in in deine App einbinden

Lesen und implementieren Sie die folgenden Schritte, die in den Abschnitten beschrieben werden. So binden Sie Google Log-in in Ihre Wear OS-App ein:

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

Google Log-in konfigurieren und das GoogleApiClient-Objekt erstellen

Konfigurieren Sie in der onCreate()-Methode Ihrer Anmeldeaktivität Google Log-in, um die für Ihre App erforderlichen Nutzerdaten. Erstellen Sie dann ein GoogleApiClient-Objekt mit auf die Google Log-in API und die von dir angegebenen Optionen zugreifen können. Diese Schritte sind im folgenden Beispiel zu sehen:

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

Schaltfläche „Google Log-in“ zur App hinzufügen

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

1. hinzufügen SignInButton zum App-Layout:

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

2. Registriere in der onCreate()-Methode deiner App die OnClickListener, um den Nutzer anzumelden, wenn er angetippt wird:

Kotlin

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

Java

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

Anmelde-Intent erstellen und Anmeldevorgang starten

Umgang mit dem Tippen auf die Anmeldeschaltfläche in deinem onCLick() indem Sie einen Anmelde-Intent mit der Methode getSignInIntent()-Methode. Beginnen Sie dann den Intent mit dem startActivityForResult()-Methode.

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

Der Nutzer wird aufgefordert, ein Google-Konto für die Anmeldung auszuwählen. Wenn Sie Bereiche angefordert haben neben dem Profil, der E-Mail-Adresse und der OpenID-ID, wird der Nutzer auch aufgefordert, Ressourcen.

Schließlich können Sie in der onActivityResult, rufen Sie das Anmeldeergebnis mit getSignInResultFromIntent Nachdem Sie das Anmeldeergebnis abgerufen haben, können Sie Überprüfen Sie, ob die Anmeldung mit dem isSuccess-Methode. Wenn die Anmeldung erfolgreich ist, können Sie die getSignInAccount, um eine GoogleSignInAccount-Objekt, das Informationen zum angemeldeten Nutzer enthält z. B. den Namen des Nutzers. Diese Schritte werden im folgenden Beispiel gezeigt:

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