Ta strona została przetłumaczona przez Cloud Translation API.

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. Mały ekran zegarka i mniejsze możliwości wprowadzania danych ograniczają opcje uwierzytelniania, z których może korzystać aplikacja na Wear OS.

W tym przewodniku opisujemy zalecane metody uwierzytelniania w aplikacjach na Wear OS oraz alternatywne metody, które nie pasują do zastosowań aplikacji.

Więcej informacji o sposobie projektowania wygodnych funkcji logowania znajdziesz w przewodniku po UX logowania.

Tryb gościa

Uwierzytelnianie nie wymaga uwierzytelniania wszystkich funkcji. Zamiast tego udostępnij użytkownikom jak najwięcej funkcji bez konieczności logowania się.

Użytkownicy mogą znaleźć i zainstalować Twoją aplikację na Wear bez korzystania z aplikacji mobilnej. Mogą więc nie mieć konta i nie wiedzieć, jakie funkcje oferuje. Upewnij się, że tryb gościa dokładnie prezentuje funkcje aplikacji.

Zalecane metody uwierzytelniania

Aby włączyć zbieranie danych uwierzytelniających użytkowników przez samodzielne aplikacje na Wear OS, użyj tych metod uwierzytelniania.

Przekazywanie tokenów za pomocą warstwy danych

Aplikacja towarzysząca na telefonie może bezpiecznie przesyłać dane uwierzytelniania do aplikacji na Wear OS za pomocą warstwy danych do noszenia. Przenieś dane logowania jako wiadomości lub elementy danych.

Ten typ uwierzytelniania zwykle nie wymaga żadnych działań ze strony użytkownika. Unikaj jednak uwierzytelniania bez informowania użytkownika o tym, że jest zalogowany. Możesz poinformować użytkownika na łatwym do zamknięcia ekranie, 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 zegarkach sparowanych z Androidem, gdy zainstalowana jest odpowiednia aplikacja mobilna. Udostępnij alternatywną metodę uwierzytelniania użytkownikom, którzy nie mają odpowiedniej aplikacji mobilnej lub których urządzenie z Wear OS jest sparowane z urządzeniem z iOS.

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

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)

Wykrywaj zdarzenia zmiany danych w aplikacji na zegarek, tak 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 w artykule Wysyłanie i synchronizowanie danych w Wear OS.

Używaj protokołu OAuth 2.0

Wear OS obsługuje 2 procesy oparte na protokole OAuth 2.0, które zostały opisane w sekcjach poniżej:

Udzielanie kodu autoryzacji z kluczem zabezpieczającym dla wymiany kodu (PKCE), zgodnie z definicją w dokumencie RFC 7636
Zezwolenie na autoryzację urządzenia, zgodnie z definicją w dokumencie RFC 8628

Uwaga: aby mieć pewność, że aplikacja nie wyłącza się, gdy zegarek przechodzi w tryb nieaktywny, podczas uwierzytelniania aktywności włącz opcję Zawsze włączona, używając parametru AmbientModeSupport.attach. Więcej informacji o sprawdzonych metodach dotyczących Trybu nieaktywnego znajdziesz w artykule Dbanie o widoczność aplikacji na Wear.

Klucz weryfikacyjny dla wymiany kodu (PKCE)

Aby skutecznie korzystać z narzędzia PKCE, użyj właściwości RemoteAuthClient.

Aby wykonać żądanie uwierzytelniania z aplikacji na Wear OS do dostawcy OAuth, utwórz obiekt OAuthRequest. Obiekt składa się z adresu URL do punktu końcowego OAuth, który umożliwia uzyskanie tokena, oraz obiektu CodeChallenge. Poniższy kod zawiera przykład tworzenia żądania uwierzytelniania:

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

Po utworzeniu żądania uwierzytelniania wyślij je do aplikacji towarzyszącej za pomocą metody 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 następnie wyświetla interfejs autoryzacji w przeglądarce na telefonie komórkowym użytkownika. Dostawca OAuth 2.0 uwierzytelnia użytkownika i uzyskuje jego zgodę na wymagane uprawnienia. Odpowiedź jest wysyłana na automatycznie wygenerowany adres URL przekierowania.

Po udanej lub nieudanej autoryzacji serwer OAuth 2.0 przekierowuje pod adres URL podany w żądaniu. Jeśli użytkownik zatwierdzi prośbę o dostęp, odpowiedź będzie zawierała kod 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 na 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 adres URL odpowiedzi i przekazuje odpowiedź do aplikacji na zegarek innej firmy za pomocą interfejsu API onAuthorizationResponse.

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

Uwaga: po utworzeniu atrybutu OAuthRequest możesz uzyskać adres URL przekierowania za pomocą właściwości redirectUrl.

Przyznanie autoryzacji urządzenia

Podczas korzystania z autoryzacji urządzenia użytkownik otwiera weryfikacyjny identyfikator URI na innym urządzeniu. Następnie serwer autoryzacji poprosi o zatwierdzenie lub odrzucenie żądania.

Aby ułatwić ten proces, użyj RemoteActivityHelper do otwierania strony internetowej na sparowanym urządzeniu mobilnym użytkownika, jak pokazano w tym 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 uniwersalnych linków do przechwycenia tej intencji w aplikacji, zamiast czekać, aż przeglądarka autoryzuje token.

Inne metody uwierzytelniania

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

Logowanie przez Google umożliwia użytkownikowi logowanie się przy użyciu istniejącego konta Google. Zapewnia on największą wygodę użytkowników i jest łatwy w obsłudze, zwłaszcza jeśli wdrażasz go już w swoich aplikacjach mobilnych.

Po zastosowaniu zalecanych metod uwierzytelniania, które opisaliśmy wcześniej, logowanie przez Google jest kolejnym preferowanym rozwiązaniem, ponieważ działa dobrze także na iOS. W tej sekcji dowiesz się, jak przeprowadzić podstawową integrację z logowaniem przez Google.

Wymagania wstępne

Zanim zaczniesz integrować Logowanie przez Google z aplikacją na Wear OS, musisz skonfigurować projekt Konsoli interfejsów API Google i projekt Android Studio. Więcej informacji znajdziesz w artykule Rozpoczynanie integracji logowania przez Google z aplikacją na Androida.

Jeśli używasz Logowania przez Google w aplikacji lub witrynie, która komunikuje się z serwerem backendu, musisz spełnić 2 dodatkowe wymagania wstępne:

Utwórz identyfikator klienta aplikacji internetowej OAuth 2.0 dla serwera backendu. Ten identyfikator klienta różni się od identyfikatora klienta Twojej aplikacji. Więcej informacji znajdziesz w artykule o włączaniu dostępu po stronie serwera.
Zidentyfikuj aktualnie zalogowanego użytkownika bezpiecznie na serwerze, wysyłając jego token identyfikatora za pomocą protokołu HTTPS. Aby dowiedzieć się, jak uwierzytelnić użytkownika na serwerze backendu, przeczytaj sekcję Uwierzytelnianie za pomocą serwera backendu.

Aby zintegrować Logowanie przez Google z aplikacją na Wear OS, zapoznaj się z poniższymi krokami i zaimplementuj je:

Skonfiguruj Logowanie przez Google.
Dodaj przycisk logowania przez Google.
Rozpocznij proces logowania po naciśnięciu przycisku logowania.

W metodzie onCreate() aktywności logowania skonfiguruj Logowanie przez Google tak, aby żądało danych użytkownika wymaganych przez aplikację. Następnie utwórz obiekt GoogleApiClient z dostępem do interfejsu Google Sign-In API i określonych przez Ciebie opcji. Oto przykład:

  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 do aplikacji przycisk Logowania przez Google

Aby dodać przycisk logowania przez Google:

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

W metodzie onCreate() w aplikacji zarejestruj OnClickListener przycisku, 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);

Obsługuj kliknięcia przycisków logowania w metodzie onCLick(), tworząc intencję logowania za pomocą metody getSignInIntent(). Następnie uruchom intencję za pomocą metody 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();
        }
    }
}

Aby zobaczyć przykładową aplikację, która implementuje logowanie przez Google, zapoznaj się z Przykładem logowania Google dla Horologa na GitHubie.

Uwierzytelnianie za pomocą niestandardowego kodu

Zamiast opisanych powyżej metod uwierzytelniania możesz wymagać od użytkownika uwierzytelnienia za pomocą innego urządzenia, takiego jak telefon komórkowy czy tablet, i uzyskania krótkotrwałego kodu liczbowego. Następnie użytkownik wpisuje go na urządzeniu z Wear OS, aby potwierdzić swoją tożsamość i otrzymać token autoryzacji.

Proces uwierzytelniania wykorzystuje moduł logowania aplikacji lub ręcznie integruje z kodem aplikacji metodę logowania zewnętrznego dostawcy uwierzytelniania. Chociaż ta metoda uwierzytelniania wymaga ręcznej pracy i dodatkowych działań, aby zwiększyć jej bezpieczeństwo, możesz z niej korzystać, jeśli w samodzielnych aplikacjach na Wear OS potrzebujesz wcześniejszego uwierzytelniania.

Proces uwierzytelniania w przypadku tej konfiguracji działa w ten sposób:

Użytkownik wykonuje działanie w aplikacji na Wear OS, co wymaga autoryzacji.
Aplikacja Wear OS wyświetla użytkownikowi ekran uwierzytelniania i prosi go o wpisanie kodu z określonego adresu URL.
Użytkownik przełącza się na urządzenie mobilne, tablet lub komputer, a następnie uruchamia przeglądarkę, przechodzi pod adres URL podany w aplikacji na Wear OS i się loguje.
Użytkownik otrzymuje przez krótki czas kod numeryczny, który wpisuje na ekranie uwierzytelniania w aplikacji Wear OS za pomocą klawiatury wbudowanej w Wear OS:
Od tego momentu możesz używać podanego kodu jako potwierdzenia, że jest to prawidłowy użytkownik, i wymieniać go na token autoryzacji przechowywany i zabezpieczony na urządzeniu z Wear OS na potrzeby uwierzytelniania połączeń.

Uwaga: wygenerowany przez użytkownika kod musi mieć postać liczbową i nie może zawierać żadnych liter.

Przepływ uwierzytelniania przedstawiono na tym wykresie:

Uwierzytelnianie na urządzeniach do noszenia

Tryb gościa

Zalecane metody uwierzytelniania

Przekazywanie tokenów za pomocą warstwy danych

Używaj protokołu OAuth 2.0

Klucz weryfikacyjny dla wymiany kodu (PKCE)

Przyznanie autoryzacji urządzenia

Inne metody uwierzytelniania

Logowanie przez Google

Wymagania wstępne

Zintegruj Logowanie przez Google ze swoją aplikacją

Skonfiguruj Logowanie przez Google i utwórz obiekt GoogleApiClient

Dodaj do aplikacji przycisk Logowania przez Google

Kotlin

Java

Utwórz intencję logowania i rozpocznij proces logowania

Kotlin

Java

Uwierzytelnianie za pomocą niestandardowego kodu