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 znajdziesz zalecane metody uwierzytelniania w przypadku aplikacji na Wear OS, a także ich alternatywne wersje, gdy te metody nie pasują do przypadku użycia aplikacji.

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

Tryb gościa

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

Użytkownicy mogą znaleźć i zainstalować Twoją aplikację na Wear bez korzystania z aplikacji mobilnej, więc mogą nie mieć konta i nie znać jej funkcji. Upewnij się, że funkcja trybu gościa dokładnie przedstawia funkcje aplikacji.

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

Na obsługiwanych urządzeniach z Wear OS 5 lub nowszym system wykrywa, czy użytkownik ma urządzenie na nadgarstku. Jeśli użytkownik wyłączy wykrywanie nadgarstka, a potem zdejmie urządzenie z nadgarstka, system będzie dłużej utrzymywać urządzenie w stanie odblokowanym.

Jeśli Twoja aplikacja wymaga wyższego poziomu zabezpieczeń, na przykład w przypadku wyświetlania potencjalnie poufnych danych, najpierw sprawdź, czy wykrywanie nadgarstka jest włączone:

val wristDetectionEnabled =
        isWristDetectionAutoLockingEnabled(applicationContext)

Jeśli wartość zwracana przez tę metodę 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

Aby umożliwić samodzielnym aplikacjom na Wear OS uzyskiwanie danych uwierzytelniania użytkownika, użyj tych metod uwierzytelniania.

Przekazywanie tokenów za pomocą warstwy danych

Aplikacja towarzysząca na telefon może bezpiecznie przesyłać dane uwierzytelniania do aplikacji na Wear OS za pomocą warstwy danych na urządzeniach noszonych. 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 uwierzytelniania bez informowania użytkownika o tym, że jest logowany. Możesz poinformować użytkownika za pomocą prostego, zamykanego ekranu, na którym wyświetla się informacja, że jego konto jest przenoszone z urządzenia mobilnego.

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

Przekazywanie tokenów za pomocą warstwy danych z aplikacji mobilnej, jak 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)

Nasłuchuj zdarzenia zmiany danych w aplikacji na zegarku, 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 używaniu warstwy danych na urządzeniu do noszenia znajdziesz w artykule 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 protokołem Proof Key for Code Exchange (PKCE) zgodnie z definicją w RFC 7636
• Autoryzacja na urządzeniu zgodnie z definicją w RFC 8628

Uwaga: aby aplikacja nie wyłączała się, gdy zegarek przejdzie w tryb Ambient, włącz tryb zawsze aktywny za pomocą funkcji AmbientModeSupport.attach w aktywności przeprowadzającej 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 efektywnie korzystać z PKCE, użyj RemoteAuthClient.

Aby wysłać żądanie uwierzytelniania z aplikacji na Wear OS do dostawcy OAuth, utwórz obiekt OAuthRequest. Obiekt ten zawiera adres URL punktu końcowego OAuth do pobierania tokena oraz obiekt CodeChallenge. 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 autoryzacji 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 wyświetla interfejs autoryzacji w przeglądarce na telefonie komórkowym użytkownika. Dostawca OAuth 2.0 uwierzytelnia użytkownika i uzyskiwanie zgody na żądane uprawnienia. Odpowiedź jest wysyłana na automatycznie wygenerowany adres URL przekierowania.

Po pomyślnej autoryzacji lub jej niepowodzeniu serwer OAuth 2.0 przekierowuje do adresu URL określonego w żądaniu. Jeśli użytkownik zaakceptuje prośbę o dostęp, odpowiedź będzie zawierać 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 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 załadowanie strony, która przekieruje użytkownika do aplikacji towarzyszącej. Aplikacja towarzysząca zweryfikuje adres URL odpowiedzi i przekaże odpowiedź do aplikacji zewnętrznej na zegarku za pomocą interfejsu API onAuthorizationResponse.

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

Uwaga: po skompilowaniu OAuthRequest możesz znaleźć adres URL przekierowania, korzystając z 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 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 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, które są opisane w następnych sekcjach.

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 zalecanych metodach uwierzytelniania opisanych wcześniej logowanie w Google jest preferowanym rozwiązaniem, ponieważ działa też dobrze na 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. Więcej informacji znajdziesz w artykule Rozpoczynanie integracji logowania się przez Google z aplikacją na Androida.

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

• Utwórz identyfikator klienta aplikacji internetowej OAuth 2.0 dla serwera zaplecza. Ten identyfikator klienta różni się od identyfikatora klienta Twojej aplikacji. Więcej informacji znajdziesz w artykule Włączanie dostępu po stronie serwera.
• Bezpieczne zidentyfikowanie na serwerze aktualnie zalogowanego użytkownika przez wysłanie jego tokena ID 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ą

Aby zintegrować logowanie w Google z aplikacją na Wear OS, wykonaj te czynności opisane w następnych sekcjach:

1. Skonfiguruj logowanie przez Google.
2. Dodaj przycisk logowania w 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 funkcję Zaloguj się przez Google, aby prosić o dane użytkownika wymagane przez Twoją aplikację. Następnie utwórz obiekt GoogleApiClient z dostępem do interfejsu Zaloguj się przez Google i określonym przez Ciebie opcjami. Te czynności są pokazane 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);
    }
}

Dodawanie przycisku logowania w 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 przycisk OnClickListener, aby użytkownik mógł się zalogować po jego 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 zostaje poproszony o wybranie konta Google, na które chce się zalogować. Jeśli poprosisz o uprawnienia wykraczające poza profil, adres e-mail i identyfikator OpenID, użytkownik będzie musiał też przyznać dostęp 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 logowanie się powiedzie, możesz wywołać metodę getSignInAccount, aby uzyskać obiekt GoogleSignInAccount zawierający informacje o zalogowanym użytkowniku, takie jak jego imię i nazwisko. Te kroki są 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();
        }
    }
}