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 danych z internetu. Mały ekran i mniejsze możliwości wprowadzania danych ograniczają opcje uwierzytelniania, z których może korzystać 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ę, jak zaprojektować dobry sposób logowania się, wyświetl Interfejs logowania się .
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 przez tę metodę wartość false
, poproś użytkownika o zalogowanie się
w aplikacji, zanim zaczną wyświetlać treści przeznaczone dla użytkowników.
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. Przenieś dane logowania jako wiadomości lub elementy danych.
Ten typ uwierzytelniania zwykle nie wymaga od użytkownika żadnego działania. Unikaj jednak przeprowadzanie uwierzytelniania bez informowania użytkownika, że jest zalogowany. Dostępne opcje Informować użytkownika za pomocą prostego, możliwego do zamknięcia ekranu, na którym widać, że jego konto przeniesione 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
Użyj protokołu OAuth 2.0
Wear OS obsługuje 2 procesy oparte na OAuth 2.0, które zostały opisane w sekcjach następujące:
- Przyznanie kodu autoryzacji z kluczem potwierdzającym wymianę kodu (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. Aby dowiedzieć się więcej o sprawdzonych metodach korzystania z Trybu nieaktywnego,
Więcej informacji znajdziesz w artykule na temat dbania o widoczność aplikacji na Wear.
Klucz potwierdzający wymianę kodu (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żej znajduje się przykład tworzenia żądania uwierzytelnienia:
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 wywołuje wywołanie aplikacji towarzyszącej, która następnie wyświetla interfejs autoryzacji w internecie. przeglądarki na telefonie komórkowym. Dostawca protokołu OAuth 2.0 uwierzytelnia użytkownika i pobiera zgody użytkownika na wymagane uprawnienia. Odpowiedź jest wysyłana do automatycznie wygenerowanego .
Po pomyślnej 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ć błąd .
Odpowiedź ma postać ciągu zapytania i wygląda jak w jednym 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 zegarek może następnie wymienić kod autoryzacji na token dostępu.
Uwaga: po utworzeniu tagu OAuthRequest
przekierowanie znajdziesz w
redirectUrl.
Przyznanie autoryzacji urządzenia
Gdy użytkownik korzysta z usługi Device Authorization, otwiera identyfikator URI do weryfikacji na innym urządzeniu. Potem serwer autoryzacji prosi o zatwierdzenie lub odrzucenie żądania.
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 uniwersalne linki do przechwycenia tej intencji w aplikacji, zamiast polegać na autoryzowaniu tokena przez przeglądarkę.
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ę przy użyciu istniejącego konta Google. Oferuje: są najlepsze dla użytkowników i łatwe w obsłudze, zwłaszcza jeśli już wdrażasz w aplikacjach podręcznych.
Po zastosowaniu opisanych powyżej zalecanych metod uwierzytelniania Kolejnym preferowanym rozwiązaniem jest logowanie się, ponieważ działa też dobrze w iOS. Poniżej zawiera informacje na temat podstawowej integracji Logowania przez Google.
Wymagania wstępne
Zanim zaczniesz integrować logowanie przez Google z aplikacją na Wear OS, musisz skonfigurować projekt w Konsoli interfejsów API Google, i skonfiguruj projekt 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 Więcej informacji zawiera 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. Aby dowiedzieć się, jak uwierzytelnić użytkownika na serwerze backendu, przeczytaj artykuł Uwierzytelnij się z użyciem serwera backendu.
Zintegruj Logowanie przez Google ze swoją aplikacją
Przejrzyj i zaimplementuj poniższe kroki opisane w sekcjach aby zintegrować Logowanie przez Google z aplikacją na Wear OS:
- Skonfiguruj Logowanie przez Google.
- Dodaj przycisk logowania przez Google
- Rozpocznij proces logowania po naciśnięciu przycisku logowania kliknij.
Konfigurowanie logowania przez Google i tworzenie obiektu GoogleApiClient
W metodzie onCreate()
aktywności związanej z logowaniem skonfiguruj Logowanie przez Google, aby żądać
danych użytkownika wymaganych przez aplikację. Następnie utwórz obiekt GoogleApiClient
z
dostęp do interfejsu Google Sign-In API i określonych opcji. Aby to zrobić:
widać 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 przez Google:
-
Dodaj
SignInButton
do układu aplikacji: -
W metodzie
onCreate()
aplikacji zarejestruj kod przyciskuOnClickListener
, 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.
Urządzenie onCLick()
obsługuje kliknięcia przycisku logowania
przez utworzenie intencji logowania za pomocą funkcji
getSignInIntent()
. Następnie zacznij intencję od
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 prosisz o zakresy oprócz profilu, adresu e-mail i identyfikatora OpenID, użytkownik jest również proszony o przyznanie dostępu i zasobami Google Cloud.
W sekcji Aktywność
onActivityResult
, pobierz wynik logowania za pomocą
.
getSignInResultFromIntent
Po pobraniu wyniku logowania możesz
sprawdzić, czy logowanie się udało,
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:
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 korzysta z Logowania przez Google, zobacz Przykładowa próbka logowania do Google horologa na GitHubie.
Uwierzytelnianie za pomocą kodu niestandardowego
Alternatywą dla metod uwierzytelniania opisanych powyżej może wymagać od użytkownika uwierzytelniania z innego urządzenia, np. telefonu komórkowego lub tabletu i uzyskać krótkotrwały kod numeryczny. Następnie użytkownik wpisuje na jego urządzeniu z Wear OS, aby potwierdzić tożsamość i otrzymać token uwierzytelniania.
Ten proces uwierzytelniania korzysta z modułu logowania aplikacji lub ręcznie integruje metodę logowania zewnętrznego dostawcy uwierzytelniania z kodem aplikacji. Chociaż ta metoda uwierzytelniania wymaga pracy ręcznej i dodatkowego wysiłku jest bezpieczniejsza. Możesz użyć tej metody, jeśli potrzebujesz uwierzytelniania 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 informuje wpisanie przez użytkownika kodu z określonego adresu URL.
- Użytkownik przełącza się na urządzenie mobilne, tablet lub komputer, a potem uruchamia przeglądarkę. przechodzi do adresu URL określonego w aplikacji Wear OS i się loguje.
- Użytkownik otrzymuje krótki kod numeryczny, który musi wpisać w aplikacji na Wear OS
ekranu uwierzytelniania za pomocą klawiatury wbudowanej w Wear OS:
- Od tej chwili możesz użyć podanego kodu jako dowodu, że jest on poprawny. użytkownika i wymieniać kod na token uwierzytelniania przechowywany i zabezpieczony na urządzeniu z Wear OS dla uwierzytelnionych połączeń.
Uwaga: kod generowany przez użytkownika muszą być czysto liczbowe i nie mogą zawierać żadnych liter znaków.
Proces autoryzacji został przedstawiony na tym wykresie: