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 utrzyma je w stanie odblokowanym przez dłuższy czas niż w przeciwnym wypadku.
Jeśli Twoja aplikacja wymaga wyższego poziomu zabezpieczeń, na przykład podczas wyświetlania potencjalnie poufnych lub prywatnych danych, najpierw sprawdź, czy wykrywanie nadgarstka jest włączone:
val wristDetectionEnabled =
isWristDetectionAutoLockingEnabled(applicationContext)
Jeśli zwracana wartość tej metody to false, poproś użytkownika o zalogowanie się na konto w aplikacji, zanim wyświetlisz treści dla konkretnego użytkownika.
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 jako 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, który pokazuje, ż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ądzeniach noszonych 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
- Uprawnienia autoryzacji urządzenia 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 lub nieudanej autoryzacji 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 zaakceptuje 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 onAuthorizationResponse API.
Aplikacja na zegarku może następnie wymienić kod autoryzacji na token dostępu.
Uwaga: po utworzeniu OAuthRequest możesz znaleźć adres URL przekierowania, korzystając z redirectUrl.
Przyznanie uprawnień na urządzeniu
Gdy korzystasz z uprawnień autoryzacji urządzenia, użytkownik otwiera identyfikator URI weryfikacji na innym urządzeniu. Następnie serwer autoryzacji prosi ich 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, opisane w następnych sekcjach.
Logowanie przez Google
Logowanie przez Google umożliwia użytkownikowi zalogowanie się na swoje istniejące konto Google. W tej sekcji opisaliśmy, jak przeprowadzić podstawową integrację z Google Sign-In.
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.
- Bezpiecznie zidentyfikuj aktualnie zalogowanego użytkownika na serwerze, wysyłając 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ą
Aby zintegrować logowanie w Google z aplikacją na Wear OS, wykonaj te czynności:
- Skonfiguruj logowanie przez Google.
- Dodaj przycisk logowania w Google.
- Rozpocznij proces logowania po kliknięciu przycisku logowania.
Konfigurowanie logowania przez Google i tworzenie obiektu GoogleApiClient
W metodzie onCreate() aktywności logowania skonfiguruj funkcję Zaloguj się przez Google, aby żądać danych użytkownika wymaganych przez Twoją aplikację. Następnie utwórz obiekt GoogleApiClient z dostępem do interfejsu Zaloguj się przez Google i określonymi 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:
-
Dodaj
SignInButtondo układu aplikacji: -
W metodzie
onCreate()aplikacji zarejestruj przyciskOnClickListener, aby użytkownik mógł się zalogować po jego kliknięciu:
<com.google.android.gms.common.SignInButton android:id="@+id/sign_in_button" android:layout_width="wrap_content" android:layout_height="wrap_content" />
Tworzenie zamiaru zalogowania 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 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(); } } }
Przykładową aplikację z implementacją logowania Google znajdziesz na GitHubie w pliku Horologist Google Sign-In Sample.
Uwierzytelnianie za pomocą kodu niestandardowego
Jako alternatywę dla opisanych wcześniej metod uwierzytelniania możesz wymagać od użytkownika uwierzytelnienia się na innym urządzeniu, takim jak telefon komórkowy czy tablet, i uzyskania krótkotrwałego kodu numerycznego. Użytkownik wpisuje kod na urządzeniu z Wear OS, aby potwierdzić swoją tożsamość, i otrzymuje token uwierzytelniający.
Ten proces uwierzytelniania wykorzystuje moduł logowania w aplikacji lub ręcznie integruje metodę logowania zewnętrznego dostawcy uwierzytelniania z kodem aplikacji. Ta metoda uwierzytelniania wymaga wykonania ręcznych czynności i dodatkowych wysiłków, aby zwiększyć jej bezpieczeństwo, ale możesz z niej korzystać, jeśli potrzebujesz uwierzytelnienia wcześniej w samodzielnych aplikacjach na Wear OS.
Proces uwierzytelniania w przypadku tej konfiguracji działa w ten sposób:
- Użytkownik wykonuje działanie w aplikacji na Wear OS, które wymaga autoryzacji.
- Aplikacja Wear OS wyświetla użytkownikowi ekran uwierzytelniania i prosi 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 do adresu URL określonego w aplikacji Wear OS i loguje się.
- Użytkownik otrzymuje krótkotrwały kod numeryczny, który wpisze na ekranie uwierzytelniania aplikacji na Wear OS za pomocą wbudowanej klawiatury na Wear OS:
- Od tego momentu możesz użyć wpisanego kodu jako dowodu, że to jest właściwy użytkownik, a potem wymienić go na token uwierzytelniający przechowywany i chroniony na urządzeniu z Wear OS, aby w przyszłości móc wykonywać uwierzytelnione połączenia.
Uwaga: kod wygenerowany przez użytkownika musi składać się wyłącznie z cyfr i nie może zawierać znaków alfabetu.
Ten proces uwierzytelniania przedstawia wykres poniżej:
