Authentification sur les accessoires connectés

Les applications Wear OS peuvent fonctionner de manière autonome, sans application associée. Cela signifie que une application Wear OS doit gérer elle-même l'authentification lors de l'accès des données provenant d'Internet. Mais la petite taille de l'écran de la montre et les fonctionnalités de saisie limitent les options d'authentification qu'une application Wear OS peut utiliser.

Ce guide décrit les méthodes d'authentification recommandées pour les applications Wear OS, ainsi que les autres solutions qui ne conviennent pas au cas d'utilisation d'une application.

Pour en savoir plus sur la manière de concevoir une bonne expérience de connexion, consultez le guide de connexion de l'expérience utilisateur.

Mode Invité

N'exigez pas l'authentification pour toutes les fonctionnalités. Proposez plutôt autant de fonctionnalités que pour l'utilisateur sans qu'il ait à se connecter.

Les utilisateurs peuvent découvrir et installer votre appli Wear sans avoir utilisé l'appli mobile dans l'application. Il est donc possible qu'ils n'aient pas de compte et ne sachent pas quelles fonctionnalités . Assurez-vous que le mode Invité permette à l'utilisateur de découvrir avec précision les fonctionnalités de votre application.

Certains appareils peuvent rester déverrouillés plus longtemps

Sur les appareils compatibles équipés de Wear OS 5 ou version ultérieure, le système détecte si l'utilisateur porte l'appareil au poignet. Si l'utilisateur désactive son poignet puis retire l'appareil de son poignet, le système maintient un appareil déverrouillé plus longtemps qu'il ne le ferait autrement.

Si votre application nécessite un niveau de sécurité plus élevé, par exemple lors de l'affichage des données potentiellement sensibles ou privées. Vérifiez d'abord si la détection du poignet est activé:

val wristDetectionEnabled =
        isWristDetectionAutoLockingEnabled(applicationContext)

Si la valeur renvoyée par cette méthode est false, invitez l'utilisateur à se connecter à un dans votre application avant d'afficher du contenu spécifique à l'utilisateur.

Méthodes d'authentification recommandées

Utilisez les méthodes d'authentification suivantes pour permettre aux applications Wear OS autonomes de obtenir les identifiants d'authentification des utilisateurs.

Transmettre des jetons à l'aide de la couche de données

L'application mobile associée peut transférer de manière sécurisée les données d'authentification vers l'application Wear OS à l'aide de la couche Wearable Data Layer. Transférez les identifiants sous forme de messages ou de données.

Ce type d'authentification ne nécessite généralement aucune action de la part de l'utilisateur. Toutefois, évitez d'effectuer l'authentification sans informer l'utilisateur qu'il est en train de se connecter. Vous pouvez informer l'utilisateur que son compte est en cours de transfert depuis l'application mobile en lui affichant un simple écran qu'il pourra fermer ensuite.

Important : Votre application Wear doit proposer au moins une autre méthode d'authentification, car cette option ne fonctionne que sur les montres associées à un appareil Android sur lequel l'application mobile correspondante est installée. Fournissez une autre méthode d'authentification pour les utilisateurs qui ne disposent pas de l'application mobile correspondante ou pour les utilisateurs dont l'appareil Wear OS est associé à un appareil iOS.

Transmettez des jetons à l'aide de la couche de données de l'application mobile, comme illustré dans l'exemple suivant :

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)

Écoutez les événements de changement des données sur l'application de la montre, comme illustré dans l'exemple suivant :

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.
            }
        }
    }
}

Pour en savoir plus sur l'utilisation de Wearable Data Layer, consultez la page Envoyer et synchroniser des données sur Wear OS.

Utiliser OAuth 2.0

Wear OS est compatible avec deux flux OAuth 2.0, décrits dans les sections ci-dessous :

  • Octroi du code d'autorisation avec PKCE, comme défini dans le document RFC 7636
  • Autorisation via un appareil, tel que défini dans le document RFC 8628

Remarque : Pour que votre application ne s'éteigne pas quand la montre passe en mode Veille, activez le mode "Toujours activé" à l'aide d'AmbientModeSupport.attach dans l'activité effectuant l'authentification. Pour en savoir plus sur les bonnes pratiques en mode Veille, consultez la section Conserver la visibilité de votre application sur Wear.

Clé de vérification pour l'échange de code (PKCE)

Pour utiliser efficacement la PKCE, utilisez RemoteAuthClient.

Pour envoyer une requête d'authentification à un fournisseur OAuth à partir de votre application Wear OS, créez un objet OAuthRequest. Cet objet se compose d'une URL vers votre point de terminaison OAuth permettant d'obtenir un jeton et un objet CodeChallenge. Le code suivant montre un exemple de création d'une requête d'authentification :

val request = OAuthRequest.Builder(this.applicationContext)
    .setAuthProviderUrl(Uri.parse("https://...."))
    .setClientId(clientId)
    .setCodeChallenge(codeChallenge)
    .build()

Après avoir créé la requête d'authentification, envoyez-la à l'application associée à l'aide de la méthode 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
        }
    }
)

Cette requête déclenche un appel à l'application associée, qui présente ensuite une interface d'autorisation dans le navigateur Web du téléphone mobile de l'utilisateur. Le fournisseur OAuth 2.0 authentifie l'utilisateur et obtient son consentement pour les autorisations demandées. La réponse est envoyée à l'URL de redirection, automatiquement générée.

Après l'échec ou la réussite de l'autorisation, le serveur OAuth 2.0 renvoie vers l'URL spécifiée dans la requête. Si l'utilisateur approuve la demande d'accès, la réponse contient un code d'autorisation. Si l'utilisateur n'approuve pas la requête, la réponse contient un message d'erreur.

La réponse se présente sous la forme d'une chaîne de requête et ressemble à l'un des exemples suivants :

  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

Une page qui redirige l'utilisateur vers l'application associée se charge. Celle-ci vérifie l'URL de la réponse et transmet la réponse à l'application de montre tierce à l'aide de l'API onAuthorizationResponse.

L'application de la montre peut alors échanger le code d'autorisation contre un jeton d'accès.

Remarque : Une fois la requête OAuthRequest, accédez à redirectUrl pour trouver l'URL de redirection.

Autorisation via un appareil

Avec l'autorisation via un appareil, l'utilisateur ouvre l'URI de vérification sur un autre appareil. Le serveur d'autorisation lui demande ensuite d'approuver ou de refuser la demande.

Pour faciliter ce processus, utilisez un RemoteActivityHelper pour ouvrir une page Web sur l'appareil mobile associé de l'utilisateur, comme illustré dans l'exemple suivant :

// 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.

Si vous disposez d'une application iOS, utilisez des liens universels pour intercepter cet intent dans votre application au lieu de compter sur le navigateur pour autoriser le jeton.

Autres méthodes d'authentification

Wear OS est compatible avec d'autres méthodes de connexion, décrites dans les sections suivantes.

Google Sign-In

Google Sign-In permet à l'utilisateur de se connecter avec son compte Google existant. Il offre pour une expérience utilisateur optimale et une assistance facile, surtout si vous avez déjà mis en œuvre dans vos applications portables.

Après avoir suivi les méthodes d'authentification recommandées décrites précédemment, Google La connexion est la solution privilégiée suivante, car elle fonctionne également bien sur iOS. Les éléments suivants : explique comment effectuer une intégration de base de Google Sign-In.

Prérequis

Avant de commencer à intégrer Google Sign-In à votre application Wear OS, vous devez configurer un Projet de console Google APIs et configurer votre projet Android Studio. Pour plus d'informations, voir <ph type="x-smartling-placeholder"></ph> Commencez à intégrer Google Sign-In à votre application Android.

Si vous utilisez Google Sign-In avec une application ou un site communique avec un serveur backend, deux prérequis supplémentaires s'appliquent:

  • Créer un ID client d'application Web OAuth 2.0 pour à votre serveur backend. Cet ID client est différent de l'ID client de votre application. Pour plus pour en savoir plus, consultez <ph type="x-smartling-placeholder"></ph> Activer l'accès côté serveur
  • Identifier l'utilisateur actuellement connecté de manière sécurisée sur le serveur en envoyant son jeton d'ID à l'aide du protocole HTTPS. Pour savoir comment authentifier votre utilisateur sur le serveur backend, consultez <ph type="x-smartling-placeholder"></ph> S'authentifier auprès d'un serveur backend

Intégrer Google Sign-In à votre application

Examinez et mettez en œuvre les étapes suivantes, qui sont détaillées dans les sections pour intégrer Google Sign-In à votre application Wear OS:

  1. Configurez Google Sign-In.
  2. Ajoutez un bouton Google Sign-In.
  3. Démarrez le flux de connexion lorsque le bouton de connexion est sélectionné.

Configurer Google Sign-In et créer l'objet GoogleApiClient

Dans la méthode onCreate() de votre activité de connexion, configurez Google Sign-In pour demander les données utilisateur requises par votre application. Ensuite, créez un objet GoogleApiClient avec l'accès à l'API Google Sign-In et aux options que vous avez spécifiées. Ces étapes sont illustrés dans l'exemple suivant:

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

Ajouter un bouton Google Sign-In à votre application

Pour ajouter un bouton Google Sign-In, procédez comme suit:

  1. Ajoutez le <ph type="x-smartling-placeholder"></ph> SignInButton à la mise en page de votre application:
  2.  <com.google.android.gms.common.SignInButton
     android:id="@+id/sign_in_button"
     android:layout_width="wrap_content"
     android:layout_height="wrap_content" />
    
  3. Dans la méthode onCreate() de votre application, enregistrez les éléments OnClickListener pour connecter l'utilisateur lorsqu'il appuie dessus:
  4. Kotlin

    findViewById<View>(R.id.sign_in_button).setOnClickListener(this)
    

    Java

    findViewById(R.id.sign_in_button).setOnClickListener(this);
    

Créer un intent de connexion et démarrer le flux de connexion

Gérer les appuis sur le bouton de connexion dans votre onCLick() en créant un intent de connexion <ph type="x-smartling-placeholder"></ph> getSignInIntent(). Commencez ensuite l'intent par <ph type="x-smartling-placeholder"></ph> startActivityForResult().

Intent intent = mSignInClient.getSignInIntent();
startActivityForResult(intent, RC_SIGN_IN);

L'utilisateur est invité à sélectionner un compte Google avec lequel se connecter. Si vous avez demandé des niveaux d'accès au-delà du profil, de l'adresse e-mail et de l'OpenID, l'utilisateur est également invité à accorder l'accès à ces ressources.

Enfin, dans le fichier <ph type="x-smartling-placeholder"></ph> onActivityResult, récupérez le résultat de la connexion avec <ph type="x-smartling-placeholder"></ph> getSignInResultFromIntent Après avoir récupéré le résultat de la connexion, vous pouvez vérifiez si la connexion a réussi à l'aide du <ph type="x-smartling-placeholder"></ph> isSuccess. Si la connexion réussit, vous pouvez appeler la méthode <ph type="x-smartling-placeholder"></ph> getSignInAccount pour obtenir <ph type="x-smartling-placeholder"></ph> Objet GoogleSignInAccount contenant des informations sur les utilisateurs connectés utilisateur, comme son nom. Ces étapes sont présentées dans l'exemple suivant :

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

Pour voir un exemple d'application mettant en œuvre Google Sign-In, consultez la <ph type="x-smartling-placeholder"></ph> Exemple d'utilisation de Google Sign-In pour Horologist sur GitHub.

Authentification par code personnalisé

Au lieu des méthodes d'authentification décrites précédemment, vous pouvez peut exiger que l'utilisateur s'authentifie depuis un autre appareil, comme un téléphone mobile ou une tablette, et d'obtenir un code numérique éphémère. L'utilisateur entre ensuite sur son appareil Wear OS pour confirmer son identité et recevoir un jeton d'authentification.

Ce flux d'authentification utilise le module de connexion de votre application intègre manuellement une méthode de connexion via un fournisseur d'authentification tiers dans le code de votre application. Bien que cette méthode d'authentification nécessite un travail manuel et des efforts supplémentaires vous pouvez l'utiliser si vous avez besoin d'une authentification plus tôt dans vos applications autonomes Wear OS.

Le flux d'authentification pour cette configuration fonctionne comme suit :

  1. L'utilisateur effectue une action avec l'application Wear OS nécessitant une autorisation.
  2. L'application Wear OS présente un écran d'authentification à l'utilisateur et lui demande à l'utilisateur d'entrer un code à partir d'une URL spécifiée.
  3. L'utilisateur passe à un appareil mobile, à une tablette ou à un PC, puis lance un navigateur, accède à l'URL spécifiée dans l'application Wear OS et se connecte.
  4. L'utilisateur reçoit un code numérique éphémère qu'il saisit dans l'application Wear OS. écran d'authentification à l'aide du clavier intégré dans Wear OS:

  5. À ce stade, vous pouvez utiliser le code saisi comme preuve qu'il s'agit du bon et échanger le code contre un jeton d'authentification stocké et sécurisé sur l'appareil Wear OS pour les appels authentifiés.

Remarque : le code généré par l'utilisateur doit être purement numérique et ne peut pas contenir de caractères alphabétiques.

Ce flux d'authentification est illustré dans le graphique suivant :