Authentification sur les accessoires connectés

Les applications Wear OS peuvent s'exécuter de manière autonome sans application associée. Cela signifie qu'une application Wear OS doit gérer elle-même l'authentification lorsqu'elle accède aux données depuis Internet. Le petit écran et les fonctionnalités de saisie réduites des montres connectées 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. Fournissez plutôt autant de fonctionnalités que possible à l'utilisateur, sans qu'il ait à se connecter.

Les utilisateurs peuvent découvrir et installer votre application Wear sans avoir utilisé l'application mobile. Ils peuvent donc ne pas avoir de compte et ne pas savoir quelles fonctionnalités sont disponibles. 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 la détection du poignet, puis retire l'appareil de son poignet, le système maintient l'appareil déverrouillé pendant une période plus longue que d'habitude.

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

val wristDetectionEnabled =
        isWristDetectionAutoLockingEnabled(applicationContext)

Si la valeur renvoyée par cette méthode est false, invitez l'utilisateur à se connecter à un compte 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 d'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. Cette méthode offre une expérience utilisateur optimale et est facile à gérer, en particulier si vous l'avez déjà mise en œuvre dans vos applications mobiles.

Parmi les solutions privilégiées, Google Sign-In vient directement après les méthodes d'authentification recommandées décrites précédemment, car elle fonctionne également bien sur iOS. La section suivante explique comment effectuer une intégration Google Sign-In standard.

Prérequis

Avant de pouvoir intégrer Google Sign-In à votre application Wear OS, vous devez configurer un projet dans la console Google APIs et configurer votre projet Android Studio. Pour en savoir plus, consultez Démarrer l'intégration de Google Sign-In à votre application Android.

Si vous utilisez Google Sign-In avec une application ou un site qui communique avec un serveur backend, vous devez respecter deux conditions préalables:

• Créez 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 en savoir plus, consultez Activer l'accès côté serveur.
• Identifiez l'utilisateur actuellement connecté de manière sécurisée sur le serveur en envoyant le jeton d'ID de l'utilisateur via HTTPS. Pour découvrir comment authentifier l'utilisateur sur le serveur backend, consultez le guide S'authentifier avec un serveur backend.

Intégrer Google Sign-In à votre application

Examinez et mettez en œuvre les étapes suivantes, détaillées dans les sections ci-dessous, 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 l'utilisateur appuie sur le bouton de connexion.

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

Dans la méthode onCreate() de votre activité de connexion, configurez Google Sign-In de sorte qu'il demande les données utilisateur requises par votre application. Créez ensuite un objet GoogleApiClient ayant accès à l'API Google Sign-In et aux options que vous avez spécifiées. Ces étapes sont présentées 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 SignInButton à la mise en page de votre application:

 <com.google.android.gms.common.SignInButton
 android:id="@+id/sign_in_button"
 android:layout_width="wrap_content"
 android:layout_height="wrap_content" />

2. Dans la méthode onCreate() de votre application, enregistrez l'OnClickListener de votre bouton pour connecter l'utilisateur lorsqu'il appuie dessus:

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

Pour gérer les appuis sur le bouton de connexion dans la méthode onCLick(), créez un intent de connexion à l'aide de la méthode getSignInIntent(). Ensuite, démarrez l'intent avec la méthode 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é d'autres éléments que le profil, l'adresse e-mail et l'OpenID, l'utilisateur est également invité à accorder l'accès à ces ressources.

Enfin, dans la méthode onActivityResult de l'activité, récupérez le résultat de la connexion avec getSignInResultFromIntent. Après avoir récupéré le résultat de la connexion, vous pouvez vérifier si la connexion a abouti à l'aide de la méthode isSuccess. Si la connexion aboutit, vous pouvez appeler la méthode getSignInAccount pour obtenir un objet GoogleSignInAccount qui contient des informations sur l'utilisateur connecté, comme son nom. Ces étapes sont présentées dans l'exemple suivant :

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