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 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:

1. Skonfiguruj Logowanie przez Google.
2. Dodaj przycisk logowania przez Google
3. 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:

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 kod przycisku OnClickListener, 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);

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:

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();
        }
    }
}