Uwierzytelnianie na urządzeniach do noszenia

Aplikacje na Wear OS mogą działać samodzielnie, bez aplikacji towarzyszącej. Oznacza to, że aplikacja na Wear OS musi samodzielnie zarządzać uwierzytelnianiem podczas uzyskiwania dostępu do danych z Internetu. Jednak mały rozmiar ekranu zegarka i ograniczone możliwości wprowadzania danych ograniczają opcje uwierzytelniania, których może używać aplikacja na Wear OS.

W tym przewodniku omawiamy zalecane metody uwierzytelniania w przypadku aplikacji na Wear OS, a także alternatywy, gdy te metody nie pasują do konkretnego zastosowania.

Aby dowiedzieć się więcej o tym, jak zaprojektować dobre logowanie, zapoznaj się z przewodnikiem po logowaniu.

Tryb gościa

Nie wymagaj uwierzytelniania w przypadku wszystkich funkcji. Zamiast tego udostępnij jak najwięcej funkcji bez konieczności logowania się.

Użytkownicy mogą wykryć i zainstalować Twoją aplikację na Wear nawet wtedy, gdy nie korzystali z urządzenia mobilnego. w aplikacji, więc użytkownik może nie mieć konta i nie wiedzieć, jakie funkcje są dostępne oferty. Upewnij się, że tryb gościa dokładnie prezentuje funkcje aplikacji.

Niektóre urządzenia mogą dłużej pozostawać odblokowane

Na obsługiwanych urządzeniach z Wear OS 5 lub nowszym system wykrywa, użytkownik nosi urządzenie na nadgarstku. Jeśli użytkownik wyłączy nadgarstek a następnie ściąga je z nadgarstka, system zachowuje urządzenie odblokowane przez dłuższy czas niż miałoby to miejsce.

Jeśli aplikacja wymaga wyższego poziomu zabezpieczeń – np. przy wyświetlaniu dane potencjalnie wrażliwe lub prywatne – najpierw sprawdź, czy wykrywanie nadgarstka jest włączono:

val wristDetectionEnabled =
        isWristDetectionAutoLockingEnabled(applicationContext)

Jeśli zwracana wartość tej metody to false, przed wyświetleniem treści dotyczących konkretnego użytkownika poproś użytkownika o zalogowanie się na konto w aplikacji.

Zalecane metody uwierzytelniania

Użyj tych metod uwierzytelniania, aby umożliwić samodzielnym aplikacjom na Wear OS uzyskać dane uwierzytelniające użytkownika.

Przekazywanie tokenów za pomocą warstwy danych

Aplikacja towarzysząca do telefonu może bezpiecznie przesyłać dane uwierzytelniające do aplikacji na Wear OS za pomocą warstwy danych do noszenia. Przenoszenie danych logowania w postaci wiadomości lub elementów danych.

Ten typ uwierzytelniania zwykle nie wymaga od użytkownika żadnych działań. Unikaj jednak przeprowadzanie uwierzytelniania bez informowania użytkownika, że jest zalogowany. Możesz poinformować użytkownika za pomocą prostego, zamykanego ekranu, który pokazuje, że jego konto jest przenoszone z urządzenia mobilnego.

Ważne: Aplikacja na Wear musi oferować co najmniej jedną inną metodę uwierzytelniania, ponieważ ta opcja działa tylko na zegarki sparowane z Androidem, gdy jest zainstalowana odpowiednia aplikacja mobilna. Podaj wersję alternatywną Metoda uwierzytelniania w przypadku użytkowników, którzy nie mają odpowiedniej aplikacji mobilnej lub mają Wear OS urządzenie jest sparowane z urządzeniem z iOS.

Przekaż tokeny za pomocą warstwy danych z aplikacji mobilnej, jak w przykładzie poniżej:

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)

Nasłuchuj zdarzeń zmiany danych w aplikacji na zegarek, jak w tym przykładzie:

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

Więcej informacji o korzystaniu z warstwy danych do noszenia znajdziesz tutaj: Wysyłanie i synchronizowanie danych na Wear OS

Korzystanie z protokołu OAuth 2.0

Wear OS obsługuje 2 przepływy OAuth 2.0, które są opisane w następnych sekcjach:

• Przyznawanie kodu autoryzacji z Proof Key for Code Exchange (PKCE) zgodnie z definicją w RFC 7636
• Uwierzytelnienie autoryzacji urządzenia, zgodnie z definicją w sekcji RFC 8628

Uwaga: aby mieć pewność, że aplikacja nie wyłączy się po przejściu w tryb nieaktywny włącz tryb Ekran zawsze wł., AmbientModeSupport.attach w danej aktywności, która przeprowadza uwierzytelnianie. Więcej informacji o sprawdzonych metodach dotyczących Trybu nieaktywnego znajdziesz w artykule Jak zadbać o to, aby aplikacja była widoczna na zegarku.

Proof Key for Code Exchange (PKCE)

Aby skutecznie korzystać z PKCE, użyj RemoteAuthClient

Aby wysłać żądanie uwierzytelnienia z aplikacji na Wear OS do dostawcy OAuth, utwórz OAuthRequest obiektu. Ten obiekt składa się z adresu URL punktu końcowego OAuth, który pozwala uzyskać token, oraz CodeChallenge obiektu. Poniższy kod pokazuje przykład tworzenia żądania uwierzytelniania:

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

Po utworzeniu żądania uwierzytelnienia wyślij je do aplikacji towarzyszącej za pomocą Metoda sendAuthorizationRequest():

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

To żądanie powoduje wywołanie aplikacji towarzyszącej, która wyświetla interfejs autoryzacji w przeglądarce na telefonie użytkownika. Dostawca OAuth 2.0 uwierzytelnia użytkownika i uzyskiwanie zgody na żądane uprawnienia. Odpowiedź jest wysyłana do automatycznie wygenerowanego .

Po udanej lub nieudanej autoryzacji serwer OAuth 2.0 przekierowuje na podany URL do danego wniosku. Jeśli użytkownik zatwierdzi prośbę o dostęp, odpowiedź będzie zawierać kodu autoryzacji. Jeśli użytkownik nie zatwierdzi prośby, odpowiedź będzie zawierać komunikat o błędzie.

Odpowiedź ma postać ciągu zapytania i wygląda jak jeden z tych przykładów:

  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

Spowoduje to wczytanie strony, która przekieruje użytkownika do aplikacji towarzyszącej. Aplikacja towarzysząca weryfikuje i przekazuje odpowiedź do aplikacji na zegarek innej firmy za pomocą Interfejs API onAuthorizationResponse.

Aplikacja na zegarku może następnie wymienić kod autoryzacji na token dostępu.

Uwaga: po utworzeniu tagu OAuthRequest przekierowanie znajdziesz w redirectUrl.

Przyznanie uprawnień do urządzenia

Gdy używasz upoważnienia do autoryzacji urządzenia, użytkownik otwiera identyfikator URI weryfikacji na innym urządzeniu. Następnie serwer autoryzacji prosi o zaakceptowanie lub odrzucenie prośby.

Aby ułatwić ten proces, użyj RemoteActivityHelper aby otworzyć stronę internetową na sparowanym urządzeniu mobilnym, jak w poniższym przykładzie:

// 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.

Jeśli masz aplikację na iOS, użyj linków uniwersalnych, aby przechwycić ten zamiar w aplikacji, zamiast polegać na przeglądarce do autoryzacji tokena.

Inne metody uwierzytelniania

Wear OS obsługuje dodatkowe metody logowania opisane w sekcjach poniżej.

Logowanie przez Google

Logowanie przez Google umożliwia użytkownikowi zalogowanie się na swoje istniejące konto Google. Zapewnia ona użytkownikom najlepsze wrażenia i jest łatwa w obsługiwaniu, zwłaszcza jeśli jest już wdrażana w Twoich aplikacjach na urządzenia przenośne.

Po zastosowaniu opisanych powyżej zalecanych metod uwierzytelniania Kolejnym preferowanym rozwiązaniem jest logowanie się, ponieważ działa też dobrze w iOS. W tej sekcji opisaliśmy, jak przeprowadzić podstawową integrację z Zalogowaniem w Google.

Wymagania wstępne

Zanim zaczniesz integrować logowanie w Google w aplikacji na Wear OS, musisz skonfigurować projekt w Konsoli interfejsów API Google i utworzyć projekt w Android Studio. Aby dowiedzieć się więcej, patrz Zacznij integrować logowanie przez Google z aplikacją na Androida.

Jeśli używasz Logowania przez Google w aplikacji lub na stronie, która komunikuje się z serwerem backendu, istnieją 2 dodatkowe wymagania wstępne:

• Utwórz identyfikator klienta aplikacji internetowej OAuth 2.0 dla i serwera backendu. Ten identyfikator klienta różni się od identyfikatora klienta Twojej aplikacji. Więcej informacji znajdziesz w artykule Włączanie dostępu po stronie serwera.
• Aby bezpiecznie zidentyfikować na serwerze aktualnie zalogowanego użytkownika, wyślij jego token identyfikacyjny za pomocą protokołu HTTPS. Informacje o uwierzytelnianiu użytkownika na serwerze backendu znajdziesz w artykule Uwierzytelnianie na serwerze backendu.

Integrowanie logowania Google z aplikacją

Zapoznaj się z poniższymi krokami, które zostały opisane w sekcjach, i wykonaj te czynności. aby zintegrować Logowanie przez Google z aplikacją na Wear OS:

1. Skonfiguruj logowanie przez Google.
2. Dodaj przycisk logowania przez Google
3. Rozpoczęcie procesu logowania po naciśnięciu przycisku logowania.

Konfigurowanie logowania przez Google i tworzenie obiektu GoogleApiClient

W metodzie onCreate() aktywności logowania skonfiguruj logowanie Google, aby żądać danych użytkownika wymaganych przez Twoją aplikację. Następnie utwórz obiekt GoogleApiClient z dostępem do interfejsu Google Sign-In API i określonymi przez Ciebie opcjami. Aby to zrobić: w tym przykładzie:

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

Dodaj przycisk logowania przez Google do aplikacji

Aby dodać przycisk logowania w Google:

1. Dodaj SignInButton do układu aplikacji:

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

2. W metodzie onCreate() aplikacji zarejestruj kod przycisku OnClickListener, aby zalogować użytkownika po kliknięciu:

Kotlin

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

Java

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

Tworzenie zamiaru logowania i rozpoczynanie procesu logowania

Obsługuj kliknięcia przycisku logowania w metodzie onCLick(), tworząc zamiar logowania za pomocą metody getSignInIntent(). Następnie rozpocznij zamiar za pomocą metody startActivityForResult().

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

Użytkownik zostanie poproszony o wybranie konta Google, na które będzie się logować. Jeśli żądasz uprawnień wykraczających poza profil, adres e-mail i identyfikator OpenID, użytkownik zostanie poproszony o przyznanie dostępu do tych zasobów.

Na koniec w metodzie onActivityResult aktywności pobierz wynik logowania za pomocą getSignInResultFromIntent. Po pobraniu wyniku logowania możesz sprawdzić, czy logowanie się powiodło, korzystając z metody isSuccess. Jeśli uda Ci się zalogować, możesz wywołać metodę getSignInAccount, aby uzyskać GoogleSignInAccount obiekt, który zawiera informacje o zalogowanym użytkowniku. nazwę użytkownika, np. nazwę użytkownika. Czynności te zostały pokazane w tym przykładzie:

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