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
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.
Zintegruj Logowanie przez Google ze swoją aplikacją
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.
Skonfiguruj Logowanie przez Google i utwórz obiekt GoogleApiClient
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: -
W metodzie
onCreate()
w aplikacji zarejestrujOnClickListener
przycisku, aby zalogować użytkownika po kliknięciu:
<com.google.android.gms.common.SignInButton android:id="@+id/sign_in_button" android:layout_width="wrap_content" android:layout_height="wrap_content" />
Kotlin
findViewById<View>(R.id.sign_in_button).setOnClickListener(this)
Java
findViewById(R.id.sign_in_button).setOnClickListener(this);
Utwórz intencję logowania i rozpocznij proces logowania
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: