Dans cet article, nous allons parcourir les étapes pour construire rapidement l'expérience de connexion AWS SES (authentification utilisateur) avec .NET Core (MVC) et Logto.

Prérequis

• Une instance Logto en cours d'exécution. Consultez la page d'introduction pour commencer.
• Connaissance de base de .NET Core (MVC).
• Un compte AWS SES utilisable.

Créer une application dans Logto​

Logto est basé sur l'authentification OpenID Connect (OIDC) et l'autorisation OAuth 2.0. Il prend en charge la gestion des identités fédérées à travers plusieurs applications, communément appelée authentification unique (SSO).

Pour créer votre application Traditional web, suivez simplement ces étapes :

1. Ouvrez la Logto Console. Dans la section "Get started", cliquez sur le lien "View all" pour ouvrir la liste des frameworks d'application. Alternativement, vous pouvez naviguer vers Logto Console > Applications, et cliquer sur le bouton "Create application".
2. Dans la fenêtre modale qui s'ouvre, cliquez sur la section "Traditional web" ou filtrez tous les frameworks "Traditional web" disponibles en utilisant les cases à cocher de filtre rapide à gauche. Cliquez sur la carte du framework ".NET Core (MVC)" pour commencer à créer votre application.
3. Entrez le nom de l'application, par exemple, "Bookstore", et cliquez sur "Create application".

🎉 Ta-da ! Vous venez de créer votre première application dans Logto. Vous verrez une page de félicitations qui inclut un guide d'intégration détaillé. Suivez le guide pour voir quelle sera l'expérience dans votre application.

Intégrer Logto SDK​

Installation​

Ajoutez le package NuGet à votre projet :

dotnet add package Logto.AspNetCore.Authentication

Ajoutez l’authentification Logto​

Ouvrez Startup.cs (ou Program.cs) et ajoutez le code suivant pour enregistrer les services d'authentification Logto :

using Logto.AspNetCore.Authentication;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddLogtoAuthentication(options =>
{
  options.Endpoint = builder.Configuration["Logto:Endpoint"]!;
  options.AppId = builder.Configuration["Logto:AppId"]!;
  options.AppSecret = builder.Configuration["Logto:AppSecret"];
});

La méthode AddLogtoAuthentication effectuera les actions suivantes :

• Définir le schéma d'Authentification (Authentication) par défaut sur LogtoDefaults.CookieScheme.
• Définir le schéma de défi par défaut sur LogtoDefaults.AuthenticationScheme.
• Définir le schéma de déconnexion par défaut sur LogtoDefaults.AuthenticationScheme.
• Ajouter des gestionnaires d'authentification par cookie et OpenID Connect au schéma d'authentification.

Flux de connexion et de déconnexion​

Avant de continuer, il y a deux termes confus dans le middleware d'authentification .NET Core que nous devons clarifier :

1. CallbackPath : L'URI vers laquelle Logto redirigera l'utilisateur après qu'il se soit connecté (l'"URI de redirection" dans Logto)
2. RedirectUri : L'URI vers laquelle sera redirigé après que les actions nécessaires ont été effectuées dans le middleware d'authentification Logto.

Le processus de connexion peut être illustré comme suit :

De même, .NET Core a également SignedOutCallbackPath et RedirectUri pour le flux de déconnexion.

Pour plus de clarté, nous les appellerons comme suit :

Configurer les URIs de redirection​

Tout d'abord, configurons l' URI de redirection Logto. Ajoutez l'URI suivante à la liste des "URIs de redirection" sur la page des détails de l'application Logto :

http://localhost:3000/Callback

Pour configurer l' URI de redirection après déconnexion Logto, ajoutez l'URI suivante à la liste des "URIs de redirection après déconnexion" sur la page des détails de l'application Logto :

http://localhost:3000/SignedOutCallback

Modifier les chemins par défaut​

L' URI de redirection Logto a un chemin par défaut de /Callback, et l' URI de redirection après déconnexion Logto a un chemin par défaut de /SignedOutCallback.

Vous pouvez les laisser tels quels s'il n'y a pas de besoin particulier. Si vous souhaitez les modifier, vous pouvez définir la propriété CallbackPath et SignedOutCallbackPath pour LogtoOptions :

builder.Services.AddLogtoAuthentication(options =>
{
  // Autres configurations...
  options.CallbackPath = "/Foo";
  options.SignedOutCallbackPath = "/Bar";
});

N'oubliez pas de mettre à jour la valeur sur la page des détails de l'application Logto en conséquence.

Implémenter les boutons de connexion / déconnexion​

Tout d'abord, ajoutez des méthodes d'actions à votre Controller, par exemple :

public class HomeController : Controller
{
  public IActionResult SignIn()
  {
    // Cela redirigera l'utilisateur vers la page de connexion Logto.
    return Challenge(new AuthenticationProperties { RedirectUri = "/" });
  }

  // Utilisez le mot-clé `new` pour éviter les conflits avec la méthode `ControllerBase.SignOut`
  new public IActionResult SignOut()
  {
    // Cela effacera le cookie d'authentification et redirigera l'utilisateur vers la page de déconnexion Logto
    // pour effacer également la session Logto.
    return SignOut(new AuthenticationProperties { RedirectUri = "/" });
  }
}

Ensuite, ajoutez les liens à votre Vue :

<p>Est authentifié : @User.Identity?.IsAuthenticated</p>
@if (User.Identity?.IsAuthenticated == true) {
  <a asp-controller="Home" asp-action="SignOut">Se déconnecter</a>
} else {
  <a asp-controller="Home" asp-action="SignIn">Se connecter</a>
}

Cela affichera le lien "Se connecter" si l'utilisateur n'est pas authentifié, et affichera le lien "Se déconnecter" si l'utilisateur est authentifié.

Point de contrôle : Testez votre application​

Maintenant, vous pouvez tester votre application :

1. Exécutez votre application, vous verrez le bouton de connexion.
2. Cliquez sur le bouton de connexion, le SDK initiera le processus de connexion et vous redirigera vers la page de connexion Logto.
3. Après vous être connecté, vous serez redirigé vers votre application et verrez le bouton de déconnexion.
4. Cliquez sur le bouton de déconnexion pour effacer le stockage des jetons et vous déconnecter.

Ajouter le connecteur AWS SES​

Le connecteur Email est une méthode utilisée pour envoyer des mots de passe à usage unique (OTP) pour l'authentification. Il permet la vérification de Adresse e-mail pour prendre en charge l'authentification sans mot de passe, y compris l'inscription, la connexion, l'authentification à deux facteurs (2FA) et la récupération de compte basées sur Email. Vous pouvez facilement connecter AWS SES en tant que fournisseur Email. Avec le connecteur Email de Logto, vous pouvez configurer cela en quelques minutes seulement.

Pour ajouter un connecteur Email, suivez simplement ces étapes :

1. Accédez à Console > Connector > Email and SMS connectors.
2. Pour ajouter un nouveau connecteur Email, cliquez sur le bouton "Configurer" et sélectionnez "AWS SES".
3. Consultez la documentation README pour le fournisseur sélectionné.
4. Complétez les champs de configuration dans la section "Configuration des paramètres".
5. Personnalisez le modèle Email à l'aide de l'éditeur JSON.
6. Testez votre configuration en envoyant un code de vérification à votre Adresse e-mail.

Configurer Connecteur de messagerie AWS SES​

Configurer un service de messagerie dans la console de service AWS​

Enregistrer un compte AWS​

Rendez-vous sur AWS et créez un compte.

Créer une identité​

• Accédez à la console Amazon Simple Email Service
• Créez une identité, choisissez l'une des options suivantes :
  • Créer un domaine
  • Créer une adresse e-mail

Configuration du connecteur​

1. Cliquez sur votre nom d'utilisateur dans le coin supérieur droit de la console Amazon pour accéder à Security Credentials. Si vous n'en avez pas, créez une AccessKey et conservez-la soigneusement.
2. Complétez les paramètres du connecteur Amazon Simple Email Service :
   • Utilisez l'AccessKey ID et l'AccessKey Secret obtenus à l'étape 1 pour remplir respectivement accessKeyId et accessKeySecret.
   • region : Renseignez le champ region avec la région de l'identité que vous utilisez pour envoyer des e-mails.
   • emailAddress : L'adresse e-mail que vous utilisez pour envoyer des e-mails, au format Logto\<noreply@logto.io> ou \<noreply@logto.io>

Les paramètres suivants sont optionnels ; la description des paramètres est disponible dans la documentation de l’API AWS SES.

• feedbackForwardingEmailAddress
• feedbackForwardingEmailAddressIdentityArn
• configurationSetName

Tester le connecteur Amazon SES​

Vous pouvez saisir une adresse e-mail et cliquer sur "Envoyer" pour vérifier si les paramètres fonctionnent avant de cliquer sur "Enregistrer et terminer".

C'est tout. N'oubliez pas de Activer le connecteur dans l'inscription et la connexion.

Types de configuration​

Enregistrer votre configuration​

Vérifiez que vous avez rempli les valeurs nécessaires dans la zone de configuration du connecteur Logto. Cliquez sur "Enregistrer et terminer" (ou "Enregistrer les modifications") et le connecteur AWS SES devrait être disponible maintenant.

Activer le connecteur AWS SES dans l'expérience de connexion​

Une fois que vous avez créé un connecteur avec succès, vous pouvez activer la connexion et l'inscription sans mot de passe basées sur le numéro de téléphone.

1. Accédez à Console > Expérience de connexion > Inscription et connexion.
2. Configurez les méthodes d'inscription (Optionnel) :
   1. Sélectionnez "Adresse e-mail" ou "Email ou numéro de téléphone" comme identifiant d'inscription.
   2. "Vérifier à l'inscription" est forcé d'être activé. Vous pouvez également activer "Créer un mot de passe" lors de l'inscription.
3. Configurez les méthodes de connexion :
   1. Sélectionnez Adresse e-mail comme l'un des identifiants de connexion. Vous pouvez fournir plusieurs identifiants disponibles (email, numéro de téléphone et nom d'utilisateur).
   2. Sélectionnez "Code de vérification" et / ou "Mot de passe" comme facteur d'authentification.
4. Cliquez sur "Enregistrer les modifications" et testez-le dans "Aperçu en direct".

En plus de l'inscription et de la connexion via les OTP , vous pouvez également activer la récupération de mot de passe et la vérification de sécurité basée sur , ainsi que lier Adresse e-mail au profil. Voir Flux des utilisateurs finaux pour plus de détails.

Test et validation​

Retournez à votre application .NET Core (MVC). Vous devriez maintenant pouvoir vous connecter avec AWS SES. Profitez-en !

Lectures complémentaires​

Flux des utilisateurs finaux : Logto fournit des flux d'authentification prêts à l'emploi, y compris l'authentification multi-facteurs (MFA) et le SSO d’entreprise, ainsi que des API puissantes pour une mise en œuvre flexible des paramètres de compte, de la vérification de sécurité et de l'expérience multi-locataire.

Autorisation : L'autorisation définit les actions qu'un utilisateur peut effectuer ou les ressources auxquelles il peut accéder après avoir été authentifié. Découvrez comment protéger votre API pour les applications natives et monopages et mettre en œuvre le contrôle d’accès basé sur les rôles (RBAC).

Organisations : Particulièrement efficace dans les applications SaaS multi-locataires et B2B, la fonctionnalité d'organisation permet la création de locataires, la gestion des membres, le RBAC au niveau de l'organisation et l'approvisionnement juste-à-temps.

Série IAM client : Nos articles de blog en série sur la gestion des identités et des accès des clients (ou consommateurs), des sujets de base aux sujets avancés et au-delà.

Dans cet article, nous allons parcourir les étapes pour construire rapidement l'expérience de connexion Google Workspace enterprise SSO (authentification utilisateur) avec Android (Kotlin / Java) et Logto.

Prérequis

• Une instance Logto en cours d'exécution. Consultez la page d'introduction pour commencer.
• Connaissance de base de Android (Kotlin / Java).
• Un compte Google Workspace enterprise SSO utilisable.

Create an application in Logto​

Logto est basé sur l'authentification OpenID Connect (OIDC) et l'autorisation OAuth 2.0. Il prend en charge la gestion des identités fédérées à travers plusieurs applications, communément appelée authentification unique (SSO).

Pour créer votre application Native app, suivez simplement ces étapes :

1. Ouvrez la Logto Console. Dans la section "Get started", cliquez sur le lien "View all" pour ouvrir la liste des frameworks d'application. Alternativement, vous pouvez naviguer vers Logto Console > Applications, et cliquer sur le bouton "Create application".
2. Dans la fenêtre modale qui s'ouvre, cliquez sur la section "Native app" ou filtrez tous les frameworks "Native app" disponibles en utilisant les cases à cocher de filtre rapide à gauche. Cliquez sur la carte du framework "Android" pour commencer à créer votre application.
3. Entrez le nom de l'application, par exemple, "Bookstore", et cliquez sur "Create application".

🎉 Ta-da ! Vous venez de créer votre première application dans Logto. Vous verrez une page de félicitations qui inclut un guide d'intégration détaillé. Suivez le guide pour voir quelle sera l'expérience dans votre application.

Integrate Android SDK​

Installation​

Logto Android SDK se décline en deux versions majeures :

• v3 (beta) : Ouvre l'expérience de connexion dans les Chrome Custom Tabs (le navigateur système), ce qui permet la connexion par passkey et partage la session du navigateur. Notez que v3 supprime la prise en charge des connecteurs WeChat (Native) et Alipay (Native) ; vous pouvez utiliser WeChat (Web) et Alipay (Web) à la place, qui fonctionnent via le navigateur. Si vous dépendez des connecteurs natifs, restez sur v2.
• v2 : Ouvre l'expérience de connexion dans une WebView intégrée, ce qui est requis par les connecteurs sociaux natifs, mais ne prend pas en charge la connexion par passkey (WebView ne prend pas en charge WebAuthn, la norme sous-jacente des passkeys).

Ce guide couvre les deux versions. Choisissez votre version dans les onglets ci-dessous, et le choix sera synchronisé tout au long de ce guide.

Avant d'installer Logto Android SDK, assurez-vous que mavenCentral() est ajouté à votre configuration de dépôt dans le fichier de construction du projet Gradle :

dependencyResolutionManagement {
  repositories {
    mavenCentral()
  }
}

Ajoutez Logto Android SDK à vos dépendances :

dependencies {
  implementation("io.logto.sdk:android:3.0.0-beta")
}

dependencies {
  implementation 'io.logto.sdk:android:3.0.0-beta'
}

dependencies {
  implementation("io.logto.sdk:android:2.0.3")
}

dependencies {
  implementation 'io.logto.sdk:android:2.0.3'
}

Étant donné que le SDK nécessite un accès à Internet, vous devez ajouter la permission suivante à votre fichier AndroidManifest.xml :

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools">

  <!-- ajouter la permission internet -->
  <uses-permission android:name="android.permission.INTERNET" />

  <!-- autres configurations... -->
</manifest>

Init LogtoClient​

Créez un LogtoViewModel.kt et initialisez LogtoClient dans ce modèle de vue :

//...avec d'autres imports
import io.logto.sdk.android.LogtoClient
import io.logto.sdk.android.type.LogtoConfig

class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    private val logtoConfig = LogtoConfig(
          endpoint = "<votre-point-de-terminaison-logto>",
          appId = "<votre-id-app>",
          scopes = null,
          resources = null,
          usingPersistStorage = true,
    )

    private val logtoClient = LogtoClient(logtoConfig, application)

    companion object {
        val Factory: ViewModelProvider.Factory = object : ViewModelProvider.Factory {
            @Suppress("UNCHECKED_CAST")
            override fun <T : ViewModel> create(
                modelClass: Class<T>,
                extras: CreationExtras
            ): T {
                // Obtenez l'objet Application à partir des extras
                val application = checkNotNull(extras[APPLICATION_KEY])
                return LogtoViewModel(application) as T
            }
        }
    }
}

ensuite, créez un LogtoViewModel pour votre MainActivity.kt :

//...avec d'autres imports
class MainActivity : AppCompatActivity() {
    private val logtoViewModel: LogtoViewModel by viewModels { LogtoViewModel.Factory }
    //...autres codes
}

Configurer l'URI de redirection​

Passons à la page des détails de l'application de Logto Console. Ajoutez une URI de redirection io.logto.android://io.logto.sample/callback et cliquez sur "Enregistrer les modifications".

Implémenter la connexion et la déconnexion​

Vous pouvez utiliser logtoClient.signIn pour connecter l'utilisateur et logtoClient.signOut pour déconnecter l'utilisateur.

//...avec d'autres imports
class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    // ...autres codes

    // Ajouter une donnée en direct pour observer le statut d'authentification
    private val _authenticated = MutableLiveData(logtoClient.isAuthenticated)
    val authenticated: LiveData<Boolean>
        get() = _authenticated

    fun signIn(context: Activity) {
        logtoClient.signIn(context, "io.logto.android://io.logto.sample/callback") { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }

    fun signOut(context: Activity) {
        logtoClient.signOut(context, "io.logto.android://io.logto.sample/callback") { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        //...autres codes

        // Supposons que vous ayez un bouton avec l'identifiant "sign_in_button" dans votre mise en page
        val signInButton = findViewById<Button>(R.id.sign_in_button)
        signInButton.setOnClickListener {
            logtoViewModel.signIn(this)
        }

        // Supposons que vous ayez un bouton avec l'identifiant "sign_out_button" dans votre mise en page
        val signOutButton = findViewById<Button>(R.id.sign_out_button)
        signOutButton.setOnClickListener {
            if (logtoViewModel.authenticated) { // Vérifiez si l'utilisateur est authentifié
                logtoViewModel.signOut(this)
            }
        }

        // Observez le statut d'authentification pour mettre à jour l'interface utilisateur
        logtoViewModel.authenticated.observe(this) { authenticated ->
            if (authenticated) {
                // L'utilisateur est authentifié
                signInButton.visibility = View.GONE
                signOutButton.visibility = View.VISIBLE
            } else {
                // L'utilisateur n'est pas authentifié
                signInButton.visibility = View.VISIBLE
                signOutButton.visibility = View.GONE
            }
        }

    }
}

//...avec d'autres imports
class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    // ...autres codes

    // Ajouter une donnée en direct pour observer le statut d'authentification
    private val _authenticated = MutableLiveData(logtoClient.isAuthenticated)
    val authenticated: LiveData<Boolean>
        get() = _authenticated

    fun signIn(context: Activity) {
        logtoClient.signIn(context, "io.logto.android://io.logto.sample/callback") { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }

    fun signOut() {
        logtoClient.signOut { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        //...autres codes

        // Supposons que vous ayez un bouton avec l'identifiant "sign_in_button" dans votre mise en page
        val signInButton = findViewById<Button>(R.id.sign_in_button)
        signInButton.setOnClickListener {
            logtoViewModel.signIn(this)
        }

        // Supposons que vous ayez un bouton avec l'identifiant "sign_out_button" dans votre mise en page
        val signOutButton = findViewById<Button>(R.id.sign_out_button)
        signOutButton.setOnClickListener {
            if (logtoViewModel.authenticated) { // Vérifiez si l'utilisateur est authentifié
                logtoViewModel.signOut()
            }
        }

        // Observez le statut d'authentification pour mettre à jour l'interface utilisateur
        logtoViewModel.authenticated.observe(this) { authenticated ->
            if (authenticated) {
                // L'utilisateur est authentifié
                signInButton.visibility = View.GONE
                signOutButton.visibility = View.VISIBLE
            } else {
                // L'utilisateur n'est pas authentifié
                signInButton.visibility = View.VISIBLE
                signOutButton.visibility = View.GONE
            }
        }

    }
}

Point de contrôle : Testez votre application​

Maintenant, vous pouvez tester votre application :

1. Exécutez votre application, vous verrez le bouton de connexion.
2. Cliquez sur le bouton de connexion, le SDK initiera le processus de connexion et vous redirigera vers la page de connexion Logto.
3. Après vous être connecté, vous serez redirigé vers votre application et verrez le bouton de déconnexion.
4. Cliquez sur le bouton de déconnexion pour effacer le stockage des jetons et vous déconnecter.

Add Google Workspace enterprise SSO connector​

Pour simplifier la gestion des accès et obtenir des garanties de niveau entreprise pour vos grands clients, connectez-vous avec Android en tant que fournisseur d'identité fédéré. Le connecteur SSO d’entreprise Logto vous aide à établir cette connexion en quelques minutes en permettant l'entrée de plusieurs paramètres.

Pour ajouter un connecteur SSO d’entreprise, suivez simplement ces étapes :

1. Accédez à Logto console > Enterprise SSO.

2. Cliquez sur le bouton "Ajouter un connecteur d’entreprise" et choisissez votre type de fournisseur SSO. Choisissez parmi les connecteurs préconstruits pour Microsoft Entra ID (Azure AD), Google Workspace et Okta, ou créez une connexion SSO personnalisée en utilisant le protocole standard OpenID Connect (OIDC) ou SAML.
3. Fournissez un nom unique (par exemple, Connexion SSO pour Acme Company).

4. Configurez la connexion avec votre IdP dans l'onglet "Connexion". Consultez les guides ci-dessus pour chaque type de connecteur.

5. Personnalisez l'expérience SSO et le domaine de messagerie de l’entreprise dans l'onglet "Expérience". Les utilisateurs se connectant avec le domaine de messagerie activé pour le SSO seront redirigés vers l'authentification SSO.

6. Enregistrez les modifications.

Set up Google Cloud Platform​

Étape 1 : Créer un nouveau projet sur Google Cloud Platform​

Avant de pouvoir utiliser Google Workspace comme fournisseur d'authentification, vous devez configurer un projet dans la Google API Console pour obtenir des identifiants OAuth 2.0. Si vous avez déjà un projet, vous pouvez passer cette étape. Sinon, créez un nouveau projet sous votre organisation Google.

Étape 2 : Configurer l’écran de consentement pour votre application​

Pour créer de nouvelles informations d'identification OIDC, vous devez configurer l'écran de consentement pour votre application.

1. Accédez à la page de l'écran de consentement OAuth et sélectionnez le type d'utilisateur Interne. Cela rendra l'application OAuth disponible uniquement pour les utilisateurs au sein de votre organisation.

2. Remplissez les paramètres de l'Écran de consentement en suivant les instructions sur la page. Vous devez fournir les informations minimales suivantes :

• Nom de l'application : Le nom de votre application. Il sera affiché sur l'écran de consentement.
• Email de support : L'email de support de votre application. Il sera affiché sur l'écran de consentement.

3. Définissez les Portées pour votre application. Afin de récupérer correctement les informations d'identité et l'adresse e-mail de l'utilisateur depuis le fournisseur d’identité (IdP), les connecteurs SSO de Logto doivent accorder les portées suivantes depuis le IdP :

• openid : Cette portée est requise pour l'authentification OIDC. Elle est utilisée pour récupérer le jeton d’identifiant et accéder au point de terminaison userInfo du IdP.
• profile : Cette portée est requise pour accéder aux informations de profil de base de l'utilisateur.
• email : Cette portée est requise pour accéder à l'adresse e-mail de l'utilisateur.

Cliquez sur le bouton Enregistrer pour sauvegarder les paramètres de l'écran de consentement.

Étape 3 : Créer de nouvelles informations d’identification OAuth​

Accédez à la page Credentials et cliquez sur le bouton Create Credentials. Sélectionnez l'option OAuth client ID dans le menu déroulant pour créer une nouvelle référence OAuth pour votre application.

Continuez à configurer la référence OAuth en remplissant les informations suivantes :

1. Sélectionnez Web application comme type d'application.
2. Remplissez le Name de votre application cliente, par exemple Logto SSO Connector. Cela vous aidera à identifier les références à l'avenir.
3. Remplissez les Authorized redirect URIs avec l'URI de rappel Logto. C'est l'URI vers lequel Google redirigera le navigateur de l'utilisateur après une authentification réussie. Après qu'un utilisateur s'est authentifié avec succès auprès du fournisseur d’identité (IdP), l'IdP redirige le navigateur de l'utilisateur vers cet URI désigné avec un code d'autorisation. Logto complétera le processus d'authentification basé sur le code d'autorisation reçu de cet URI.
4. Remplissez les Authorized JavaScript origins avec l'origine de l'URI de rappel Logto. Cela garantit que seule votre application Logto peut envoyer des requêtes au serveur OAuth de Google.
5. Cliquez sur le bouton Create pour créer la référence OAuth.

Étape 4 : Configurer le connecteur Logto avec les identifiants client​

Après avoir créé avec succès l'identifiant OAuth, vous recevrez une fenêtre modale avec l'ID client et le secret client.

Copiez l'ID client et le secret client et remplissez les champs correspondants dans l'onglet Connection du connecteur SSO de Logto.

Vous avez maintenant configuré avec succès un connecteur SSO Google Workspace sur Logto.

Étape 5 : Portées supplémentaires (Optionnel)​

Les portées (Scopes) définissent les permissions que votre application demande aux utilisateurs et contrôlent à quelles données votre application peut accéder dans leurs comptes Google Workspace. La demande de permissions Google nécessite une configuration des deux côtés :

Dans la Google Cloud Console :

1. Accédez à APIs & Services > Écran de consentement OAuth > Portées (Scopes).
2. Cliquez sur Ajouter ou supprimer des portées et sélectionnez uniquement les portées dont votre application a besoin :
   • Authentification (obligatoire) :
     • https://www.googleapis.com/auth/userinfo.email
     • https://www.googleapis.com/auth/userinfo.profile
     • openid
   • Accès à l’API (optionnel) : Ajoutez toutes les portées supplémentaires nécessaires pour votre application (par exemple, Drive, Calendar, YouTube). Parcourez la bibliothèque d’API Google pour trouver les services disponibles. Si votre application a besoin d’accéder à des API Google au-delà des permissions de base, activez d’abord les API spécifiques que votre application utilisera (par exemple, Google Drive API, Gmail API, Calendar API) dans la bibliothèque d’API Google.
3. Cliquez sur Mettre à jour pour confirmer la sélection.
4. Cliquez sur Enregistrer et continuer pour appliquer les modifications.

Dans le connecteur Logto Google Workspace :

1. Logto inclut automatiquement les portées openid, profile et email pour récupérer les informations d'identité de base de l'utilisateur. Vous pouvez laisser le champ Scopes vide si vous n'avez besoin que des informations de base sur l'utilisateur.
2. Ajoutez des portées supplémentaires (séparées par des espaces) dans le champ Scopes pour demander plus de données à Google. Utilisez les URLs complètes des portées, par exemple : https://www.googleapis.com/auth/calendar.readonly

Étape 6 : Stocker les jetons pour accéder aux API Google (Optionnel)​

Si vous souhaitez accéder aux API Google et effectuer des actions avec l'autorisation de l'utilisateur, Logto doit obtenir des portées API spécifiques et stocker les jetons.

1. Ajoutez les portées requises dans la configuration de l'écran de consentement OAuth de votre Google Cloud Console et dans le connecteur Google de Logto.
2. Activez Stocker les jetons pour un accès API persistant dans le connecteur Google de Logto. Logto stockera de manière sécurisée les jetons d’accès Google et les jetons de rafraîchissement dans le Secret Vault.
3. Pour garantir que les jetons de rafraîchissement sont renvoyés, configurez votre connecteur Google Logto pour activer l’accès hors ligne.

Étape 7 : Définir les domaines e-mail et activer le connecteur SSO​

Fournissez les domaines e-mail de votre organisation dans l’onglet Expérience SSO du connecteur Logto. Cela activera le connecteur SSO comme méthode d’authentification pour ces utilisateurs.

Les utilisateurs ayant des adresses e-mail dans les domaines spécifiés seront redirigés pour utiliser votre connecteur SSO comme seule méthode d’authentification.

Pour plus d’informations sur le connecteur Google Workspace SSO, veuillez consulter Google OpenID Connector.

Save your configuration​

Vérifiez que vous avez rempli les valeurs nécessaires dans la zone de configuration du connecteur Logto. Cliquez sur "Enregistrer et terminer" (ou "Enregistrer les modifications") et le connecteur Google Workspace enterprise SSO devrait être disponible maintenant.

Enable Google Workspace enterprise SSO connector in Sign-in Experience​

Vous n'avez pas besoin de configurer individuellement les connecteurs d'entreprise, Logto simplifie l'intégration du SSO dans vos applications en un seul clic.

1. Accédez à : Console > Expérience de connexion > Inscription et connexion.
2. Activez le bouton "SSO d’entreprise".
3. Enregistrez les modifications.

Une fois activé, un bouton "Authentification unique (SSO)" apparaîtra sur votre page de connexion. Les utilisateurs d'entreprise avec des domaines de messagerie compatibles SSO peuvent accéder à vos services en utilisant leurs fournisseurs d’identité d’entreprise (IdPs).

Pour en savoir plus sur l'expérience utilisateur SSO, y compris le SSO initié par le SP et le SSO initié par l'IdP, consultez les flux utilisateur : SSO d’entreprise.

Testing and Validation​

Retournez à votre application Android (Kotlin / Java). Vous devriez maintenant pouvoir vous connecter avec Google Workspace enterprise SSO. Profitez-en !

Further readings​

Flux des utilisateurs finaux : Logto fournit des flux d'authentification prêts à l'emploi, y compris l'authentification multi-facteurs (MFA) et le SSO d’entreprise, ainsi que des API puissantes pour une mise en œuvre flexible des paramètres de compte, de la vérification de sécurité et de l'expérience multi-locataire.

Autorisation : L'autorisation définit les actions qu'un utilisateur peut effectuer ou les ressources auxquelles il peut accéder après avoir été authentifié. Découvrez comment protéger votre API pour les applications natives et monopages et mettre en œuvre le contrôle d’accès basé sur les rôles (RBAC).

Organisations : Particulièrement efficace dans les applications SaaS multi-locataires et B2B, la fonctionnalité d'organisation permet la création de locataires, la gestion des membres, le RBAC au niveau de l'organisation et l'approvisionnement juste-à-temps.

Série IAM client : Nos articles de blog en série sur la gestion des identités et des accès des clients (ou consommateurs), des sujets de base aux sujets avancés et au-delà.

Dans cet article, nous allons parcourir les étapes pour construire rapidement l'expérience de connexion Microsoft Entra ID OIDC enterprise SSO (authentification utilisateur) avec Android (Kotlin / Java) et Logto.

Prérequis

• Une instance Logto en cours d'exécution. Consultez la page d'introduction pour commencer.
• Connaissance de base de Android (Kotlin / Java).
• Un compte Microsoft Entra ID OIDC enterprise SSO utilisable.

Create an application in Logto​

Logto est basé sur l'authentification OpenID Connect (OIDC) et l'autorisation OAuth 2.0. Il prend en charge la gestion des identités fédérées à travers plusieurs applications, communément appelée authentification unique (SSO).

Pour créer votre application Native app, suivez simplement ces étapes :

1. Ouvrez la Logto Console. Dans la section "Get started", cliquez sur le lien "View all" pour ouvrir la liste des frameworks d'application. Alternativement, vous pouvez naviguer vers Logto Console > Applications, et cliquer sur le bouton "Create application".
2. Dans la fenêtre modale qui s'ouvre, cliquez sur la section "Native app" ou filtrez tous les frameworks "Native app" disponibles en utilisant les cases à cocher de filtre rapide à gauche. Cliquez sur la carte du framework "Android" pour commencer à créer votre application.
3. Entrez le nom de l'application, par exemple, "Bookstore", et cliquez sur "Create application".

🎉 Ta-da ! Vous venez de créer votre première application dans Logto. Vous verrez une page de félicitations qui inclut un guide d'intégration détaillé. Suivez le guide pour voir quelle sera l'expérience dans votre application.

Integrate Android SDK​

Installation​

Logto Android SDK se décline en deux versions majeures :

• v3 (beta) : Ouvre l'expérience de connexion dans les Chrome Custom Tabs (le navigateur système), ce qui permet la connexion par passkey et partage la session du navigateur. Notez que v3 supprime la prise en charge des connecteurs WeChat (Native) et Alipay (Native) ; vous pouvez utiliser WeChat (Web) et Alipay (Web) à la place, qui fonctionnent via le navigateur. Si vous dépendez des connecteurs natifs, restez sur v2.
• v2 : Ouvre l'expérience de connexion dans une WebView intégrée, ce qui est requis par les connecteurs sociaux natifs, mais ne prend pas en charge la connexion par passkey (WebView ne prend pas en charge WebAuthn, la norme sous-jacente des passkeys).

Ce guide couvre les deux versions. Choisissez votre version dans les onglets ci-dessous, et le choix sera synchronisé tout au long de ce guide.

Avant d'installer Logto Android SDK, assurez-vous que mavenCentral() est ajouté à votre configuration de dépôt dans le fichier de construction du projet Gradle :

dependencyResolutionManagement {
  repositories {
    mavenCentral()
  }
}

Ajoutez Logto Android SDK à vos dépendances :

dependencies {
  implementation("io.logto.sdk:android:3.0.0-beta")
}

dependencies {
  implementation 'io.logto.sdk:android:3.0.0-beta'
}

dependencies {
  implementation("io.logto.sdk:android:2.0.3")
}

dependencies {
  implementation 'io.logto.sdk:android:2.0.3'
}

Étant donné que le SDK nécessite un accès à Internet, vous devez ajouter la permission suivante à votre fichier AndroidManifest.xml :

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools">

  <!-- ajouter la permission internet -->
  <uses-permission android:name="android.permission.INTERNET" />

  <!-- autres configurations... -->
</manifest>

Init LogtoClient​

Créez un LogtoViewModel.kt et initialisez LogtoClient dans ce modèle de vue :

//...avec d'autres imports
import io.logto.sdk.android.LogtoClient
import io.logto.sdk.android.type.LogtoConfig

class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    private val logtoConfig = LogtoConfig(
          endpoint = "<votre-point-de-terminaison-logto>",
          appId = "<votre-id-app>",
          scopes = null,
          resources = null,
          usingPersistStorage = true,
    )

    private val logtoClient = LogtoClient(logtoConfig, application)

    companion object {
        val Factory: ViewModelProvider.Factory = object : ViewModelProvider.Factory {
            @Suppress("UNCHECKED_CAST")
            override fun <T : ViewModel> create(
                modelClass: Class<T>,
                extras: CreationExtras
            ): T {
                // Obtenez l'objet Application à partir des extras
                val application = checkNotNull(extras[APPLICATION_KEY])
                return LogtoViewModel(application) as T
            }
        }
    }
}

ensuite, créez un LogtoViewModel pour votre MainActivity.kt :

//...avec d'autres imports
class MainActivity : AppCompatActivity() {
    private val logtoViewModel: LogtoViewModel by viewModels { LogtoViewModel.Factory }
    //...autres codes
}

Configurer l'URI de redirection​

Passons à la page des détails de l'application de Logto Console. Ajoutez une URI de redirection io.logto.android://io.logto.sample/callback et cliquez sur "Enregistrer les modifications".

Implémenter la connexion et la déconnexion​

Vous pouvez utiliser logtoClient.signIn pour connecter l'utilisateur et logtoClient.signOut pour déconnecter l'utilisateur.

//...avec d'autres imports
class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    // ...autres codes

    // Ajouter une donnée en direct pour observer le statut d'authentification
    private val _authenticated = MutableLiveData(logtoClient.isAuthenticated)
    val authenticated: LiveData<Boolean>
        get() = _authenticated

    fun signIn(context: Activity) {
        logtoClient.signIn(context, "io.logto.android://io.logto.sample/callback") { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }

    fun signOut(context: Activity) {
        logtoClient.signOut(context, "io.logto.android://io.logto.sample/callback") { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        //...autres codes

        // Supposons que vous ayez un bouton avec l'identifiant "sign_in_button" dans votre mise en page
        val signInButton = findViewById<Button>(R.id.sign_in_button)
        signInButton.setOnClickListener {
            logtoViewModel.signIn(this)
        }

        // Supposons que vous ayez un bouton avec l'identifiant "sign_out_button" dans votre mise en page
        val signOutButton = findViewById<Button>(R.id.sign_out_button)
        signOutButton.setOnClickListener {
            if (logtoViewModel.authenticated) { // Vérifiez si l'utilisateur est authentifié
                logtoViewModel.signOut(this)
            }
        }

        // Observez le statut d'authentification pour mettre à jour l'interface utilisateur
        logtoViewModel.authenticated.observe(this) { authenticated ->
            if (authenticated) {
                // L'utilisateur est authentifié
                signInButton.visibility = View.GONE
                signOutButton.visibility = View.VISIBLE
            } else {
                // L'utilisateur n'est pas authentifié
                signInButton.visibility = View.VISIBLE
                signOutButton.visibility = View.GONE
            }
        }

    }
}

//...avec d'autres imports
class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    // ...autres codes

    // Ajouter une donnée en direct pour observer le statut d'authentification
    private val _authenticated = MutableLiveData(logtoClient.isAuthenticated)
    val authenticated: LiveData<Boolean>
        get() = _authenticated

    fun signIn(context: Activity) {
        logtoClient.signIn(context, "io.logto.android://io.logto.sample/callback") { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }

    fun signOut() {
        logtoClient.signOut { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        //...autres codes

        // Supposons que vous ayez un bouton avec l'identifiant "sign_in_button" dans votre mise en page
        val signInButton = findViewById<Button>(R.id.sign_in_button)
        signInButton.setOnClickListener {
            logtoViewModel.signIn(this)
        }

        // Supposons que vous ayez un bouton avec l'identifiant "sign_out_button" dans votre mise en page
        val signOutButton = findViewById<Button>(R.id.sign_out_button)
        signOutButton.setOnClickListener {
            if (logtoViewModel.authenticated) { // Vérifiez si l'utilisateur est authentifié
                logtoViewModel.signOut()
            }
        }

        // Observez le statut d'authentification pour mettre à jour l'interface utilisateur
        logtoViewModel.authenticated.observe(this) { authenticated ->
            if (authenticated) {
                // L'utilisateur est authentifié
                signInButton.visibility = View.GONE
                signOutButton.visibility = View.VISIBLE
            } else {
                // L'utilisateur n'est pas authentifié
                signInButton.visibility = View.VISIBLE
                signOutButton.visibility = View.GONE
            }
        }

    }
}

Point de contrôle : Testez votre application​

Maintenant, vous pouvez tester votre application :

1. Exécutez votre application, vous verrez le bouton de connexion.
2. Cliquez sur le bouton de connexion, le SDK initiera le processus de connexion et vous redirigera vers la page de connexion Logto.
3. Après vous être connecté, vous serez redirigé vers votre application et verrez le bouton de déconnexion.
4. Cliquez sur le bouton de déconnexion pour effacer le stockage des jetons et vous déconnecter.

Add Microsoft Entra ID OIDC enterprise SSO connector​

Pour simplifier la gestion des accès et obtenir des garanties de niveau entreprise pour vos grands clients, connectez-vous avec Android en tant que fournisseur d'identité fédéré. Le connecteur SSO d’entreprise Logto vous aide à établir cette connexion en quelques minutes en permettant l'entrée de plusieurs paramètres.

Pour ajouter un connecteur SSO d’entreprise, suivez simplement ces étapes :

1. Accédez à Logto console > Enterprise SSO.

2. Cliquez sur le bouton "Ajouter un connecteur d’entreprise" et choisissez votre type de fournisseur SSO. Choisissez parmi les connecteurs préconstruits pour Microsoft Entra ID (Azure AD), Google Workspace et Okta, ou créez une connexion SSO personnalisée en utilisant le protocole standard OpenID Connect (OIDC) ou SAML.
3. Fournissez un nom unique (par exemple, Connexion SSO pour Acme Company).

4. Configurez la connexion avec votre IdP dans l'onglet "Connexion". Consultez les guides ci-dessus pour chaque type de connecteur.

5. Personnalisez l'expérience SSO et le domaine de messagerie de l’entreprise dans l'onglet "Expérience". Les utilisateurs se connectant avec le domaine de messagerie activé pour le SSO seront redirigés vers l'authentification SSO.

6. Enregistrez les modifications.

Set up Azure AD SSO application​

Étape 1 : Créer une application OIDC Microsoft EntraID​

1. Allez sur le centre d'administration Microsoft Entra et connectez-vous en tant qu'administrateur.

2. Accédez à Identity > Applications > App registrations.

3. Sélectionnez New registration.

4. Entrez le nom de l'application et sélectionnez le type de compte approprié pour votre application.

5. Sélectionnez Web comme plateforme de l'application.

6. Copiez et collez l'URI de redirection depuis la page des paramètres SSO de Logto. L'URI de redirection est l'URL où l'utilisateur est redirigé après s'être authentifié avec Microsoft Entra ID.

6. Cliquez sur Register pour créer l'application.

Étape 2 : Configurer le SSO OIDC Microsoft Entra ID dans Logto​

Après avoir créé avec succès une application Microsoft Entra OIDC, vous devrez fournir les configurations du fournisseur d’identité (IdP) à Logto. Rendez-vous dans l’onglet Connection de la Console Logto et renseignez les configurations suivantes :

1. ID client : Un identifiant unique attribué à votre application OIDC par Microsoft Entra. Cet identifiant est utilisé par Logto pour identifier et authentifier l’application lors du flux OIDC. Vous pouvez le trouver sur la page d’aperçu de l’application sous Application (client) ID.

2. Secret client : Créez un nouveau secret client et copiez la valeur dans Logto. Ce secret est utilisé pour authentifier l’application OIDC et sécuriser la communication entre Logto et le fournisseur d’identité (IdP).

3. Émetteur (Issuer) : L’URL de l’émetteur, un identifiant unique pour le fournisseur d’identité (IdP), spécifiant l’emplacement où le fournisseur d’identité OIDC peut être trouvé. Il s’agit d’une partie cruciale de la configuration OIDC car elle permet à Logto de découvrir les points de terminaison nécessaires.

   Au lieu de fournir manuellement tous ces points de terminaison OIDC, Logto récupère automatiquement toutes les configurations requises et les points de terminaison du fournisseur d’identité (IdP). Cela se fait en utilisant l’URL de l’émetteur que vous avez fournie et en effectuant un appel au point de terminaison de découverte du fournisseur d’identité (IdP).

   Pour obtenir l’URL de l’émetteur, vous pouvez la trouver dans la section Endpoints de la page d’aperçu de l’application.

   Repérez le point de terminaison OpenID Connect metadata document et copiez l’URL SANS le chemin final .well-known/openid-configuration. En effet, Logto ajoutera automatiquement .well-known/openid-configuration à l’URL de l’émetteur lors de la récupération des configurations OIDC.

4. Portée (Scope) (optionnel) : Logto inclut automatiquement les portées requises (openid, profile et email) dans toutes les requêtes. Vous pouvez spécifier des portées supplémentaires sous forme de liste séparée par des espaces si votre application nécessite des permissions ou des niveaux d’accès supplémentaires du fournisseur d’identité (IdP).

Cliquez sur Save pour terminer le processus de configuration

Étape 3 : Portées supplémentaires (facultatif)​

Les portées (Scopes) définissent les permissions que votre application demande aux utilisateurs et contrôlent à quelles données votre application peut accéder depuis leurs comptes Microsoft Entra ID. La demande de permissions Microsoft Graph nécessite une configuration des deux côtés :

Dans le centre d'administration Microsoft Entra :

1. Accédez à Microsoft Entra ID > Enregistrements d'applications et sélectionnez votre application.
2. Allez dans Permissions API > Ajouter une permission > Microsoft Graph > Permissions déléguées.
3. Sélectionnez uniquement les permissions requises par votre application :
   • Permissions OpenID :
     • openid (Obligatoire) - Connecter les utilisateurs
     • profile (Obligatoire) - Voir le profil de base des utilisateurs
     • email (Obligatoire) - Voir l'adresse e-mail des utilisateurs
     • offline_access (Optionnel) - Nécessaire uniquement si vous activez Stocker les jetons pour un accès API persistant dans le connecteur Logto et que vous devez obtenir des jetons de rafraîchissement pour un accès longue durée aux API Microsoft Graph.
   • Accès API (Optionnel) : Ajoutez toutes les permissions supplémentaires nécessaires à votre application. Les permissions courantes de Microsoft Graph incluent Mail.Read, Calendars.Read, Files.Read, etc. Parcourez la référence des permissions Microsoft Graph pour trouver les permissions disponibles.
4. Cliquez sur Ajouter des permissions pour confirmer la sélection.
5. Si votre application nécessite un consentement administrateur pour certaines permissions, cliquez sur Accorder le consentement administrateur pour [Votre organisation].

Dans le connecteur Logto Microsoft Entra ID :

1. Logto inclut automatiquement les portées openid, profile et email pour récupérer les informations d'identité de base de l'utilisateur. Vous pouvez laisser le champ Scopes vide si vous n'avez besoin que des informations de base de l'utilisateur.
2. Ajoutez offline_access au champ Scopes si vous prévoyez de stocker des jetons pour un accès API persistant. Cette portée permet d'obtenir des jetons de rafraîchissement pour un accès longue durée à l'API.
3. Ajoutez des portées supplémentaires (séparées par des espaces) dans le champ Scopes pour demander plus de données à Microsoft Graph. Utilisez les noms de portées standards, par exemple : User.Read Mail.Read Calendars.Read

Étape 4 : Stocker les jetons pour accéder aux API Microsoft (facultatif)​

Si vous souhaitez accéder aux API Microsoft Graph et effectuer des actions avec l'autorisation de l'utilisateur, Logto doit obtenir des portées API spécifiques et stocker les jetons.

1. Ajoutez les portées requises dans la configuration des permissions API de votre centre d'administration Microsoft Entra et dans le connecteur Microsoft Entra ID de Logto.
2. Activez Stocker les jetons pour un accès API persistant dans le connecteur Microsoft Entra ID de Logto. Logto stockera de manière sécurisée les jetons d’accès Microsoft et les jetons de rafraîchissement dans le Secret Vault.
3. Pour garantir que les jetons de rafraîchissement sont renvoyés, ajoutez la portée offline_access aux permissions de votre application Microsoft Entra ID et incluez-la dans les portées de votre connecteur Microsoft Entra ID de Logto. Cette portée permet à votre application de maintenir l'accès aux ressources pendant de longues périodes.

Étape 5 : Définir les domaines e-mail et activer le connecteur SSO​

Fournissez les domains e-mail de votre organisation dans l’onglet experience du connecteur. Cela activera le connecteur SSO comme méthode d’authentification pour ces utilisateurs.

Les utilisateurs ayant des adresses e-mail dans les domaines spécifiés seront exclusivement limités à l’utilisation de votre connecteur SSO comme seule méthode d’authentification.

Save your configuration​

Vérifiez que vous avez rempli les valeurs nécessaires dans la zone de configuration du connecteur Logto. Cliquez sur "Enregistrer et terminer" (ou "Enregistrer les modifications") et le connecteur Microsoft Entra ID OIDC enterprise SSO devrait être disponible maintenant.

Enable Microsoft Entra ID OIDC enterprise SSO connector in Sign-in Experience​

Vous n'avez pas besoin de configurer individuellement les connecteurs d'entreprise, Logto simplifie l'intégration du SSO dans vos applications en un seul clic.

1. Accédez à : Console > Expérience de connexion > Inscription et connexion.
2. Activez le bouton "SSO d’entreprise".
3. Enregistrez les modifications.

Une fois activé, un bouton "Authentification unique (SSO)" apparaîtra sur votre page de connexion. Les utilisateurs d'entreprise avec des domaines de messagerie compatibles SSO peuvent accéder à vos services en utilisant leurs fournisseurs d’identité d’entreprise (IdPs).

Pour en savoir plus sur l'expérience utilisateur SSO, y compris le SSO initié par le SP et le SSO initié par l'IdP, consultez les flux utilisateur : SSO d’entreprise.

Testing and Validation​

Retournez à votre application Android (Kotlin / Java). Vous devriez maintenant pouvoir vous connecter avec Microsoft Entra ID OIDC enterprise SSO. Profitez-en !

Further readings​

Flux des utilisateurs finaux : Logto fournit des flux d'authentification prêts à l'emploi, y compris l'authentification multi-facteurs (MFA) et le SSO d’entreprise, ainsi que des API puissantes pour une mise en œuvre flexible des paramètres de compte, de la vérification de sécurité et de l'expérience multi-locataire.

Autorisation : L'autorisation définit les actions qu'un utilisateur peut effectuer ou les ressources auxquelles il peut accéder après avoir été authentifié. Découvrez comment protéger votre API pour les applications natives et monopages et mettre en œuvre le contrôle d’accès basé sur les rôles (RBAC).

Organisations : Particulièrement efficace dans les applications SaaS multi-locataires et B2B, la fonctionnalité d'organisation permet la création de locataires, la gestion des membres, le RBAC au niveau de l'organisation et l'approvisionnement juste-à-temps.

Série IAM client : Nos articles de blog en série sur la gestion des identités et des accès des clients (ou consommateurs), des sujets de base aux sujets avancés et au-delà.

Dans cet article, nous allons parcourir les étapes pour construire rapidement l'expérience de connexion Microsoft Entra ID SAML enterprise SSO (authentification utilisateur) avec Android (Kotlin / Java) et Logto.

Prérequis

• Une instance Logto en cours d'exécution. Consultez la page d'introduction pour commencer.
• Connaissance de base de Android (Kotlin / Java).
• Un compte Microsoft Entra ID SAML enterprise SSO utilisable.

Create an application in Logto​

Logto est basé sur l'authentification OpenID Connect (OIDC) et l'autorisation OAuth 2.0. Il prend en charge la gestion des identités fédérées à travers plusieurs applications, communément appelée authentification unique (SSO).

Pour créer votre application Native app, suivez simplement ces étapes :

1. Ouvrez la Logto Console. Dans la section "Get started", cliquez sur le lien "View all" pour ouvrir la liste des frameworks d'application. Alternativement, vous pouvez naviguer vers Logto Console > Applications, et cliquer sur le bouton "Create application".
2. Dans la fenêtre modale qui s'ouvre, cliquez sur la section "Native app" ou filtrez tous les frameworks "Native app" disponibles en utilisant les cases à cocher de filtre rapide à gauche. Cliquez sur la carte du framework "Android" pour commencer à créer votre application.
3. Entrez le nom de l'application, par exemple, "Bookstore", et cliquez sur "Create application".

🎉 Ta-da ! Vous venez de créer votre première application dans Logto. Vous verrez une page de félicitations qui inclut un guide d'intégration détaillé. Suivez le guide pour voir quelle sera l'expérience dans votre application.

Integrate Android SDK​

Installation​

Logto Android SDK se décline en deux versions majeures :

• v3 (beta) : Ouvre l'expérience de connexion dans les Chrome Custom Tabs (le navigateur système), ce qui permet la connexion par passkey et partage la session du navigateur. Notez que v3 supprime la prise en charge des connecteurs WeChat (Native) et Alipay (Native) ; vous pouvez utiliser WeChat (Web) et Alipay (Web) à la place, qui fonctionnent via le navigateur. Si vous dépendez des connecteurs natifs, restez sur v2.
• v2 : Ouvre l'expérience de connexion dans une WebView intégrée, ce qui est requis par les connecteurs sociaux natifs, mais ne prend pas en charge la connexion par passkey (WebView ne prend pas en charge WebAuthn, la norme sous-jacente des passkeys).

Ce guide couvre les deux versions. Choisissez votre version dans les onglets ci-dessous, et le choix sera synchronisé tout au long de ce guide.

Avant d'installer Logto Android SDK, assurez-vous que mavenCentral() est ajouté à votre configuration de dépôt dans le fichier de construction du projet Gradle :

dependencyResolutionManagement {
  repositories {
    mavenCentral()
  }
}

Ajoutez Logto Android SDK à vos dépendances :

dependencies {
  implementation("io.logto.sdk:android:3.0.0-beta")
}

dependencies {
  implementation 'io.logto.sdk:android:3.0.0-beta'
}

dependencies {
  implementation("io.logto.sdk:android:2.0.3")
}

dependencies {
  implementation 'io.logto.sdk:android:2.0.3'
}

Étant donné que le SDK nécessite un accès à Internet, vous devez ajouter la permission suivante à votre fichier AndroidManifest.xml :

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools">

  <!-- ajouter la permission internet -->
  <uses-permission android:name="android.permission.INTERNET" />

  <!-- autres configurations... -->
</manifest>

Init LogtoClient​

Créez un LogtoViewModel.kt et initialisez LogtoClient dans ce modèle de vue :

//...avec d'autres imports
import io.logto.sdk.android.LogtoClient
import io.logto.sdk.android.type.LogtoConfig

class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    private val logtoConfig = LogtoConfig(
          endpoint = "<votre-point-de-terminaison-logto>",
          appId = "<votre-id-app>",
          scopes = null,
          resources = null,
          usingPersistStorage = true,
    )

    private val logtoClient = LogtoClient(logtoConfig, application)

    companion object {
        val Factory: ViewModelProvider.Factory = object : ViewModelProvider.Factory {
            @Suppress("UNCHECKED_CAST")
            override fun <T : ViewModel> create(
                modelClass: Class<T>,
                extras: CreationExtras
            ): T {
                // Obtenez l'objet Application à partir des extras
                val application = checkNotNull(extras[APPLICATION_KEY])
                return LogtoViewModel(application) as T
            }
        }
    }
}

ensuite, créez un LogtoViewModel pour votre MainActivity.kt :

//...avec d'autres imports
class MainActivity : AppCompatActivity() {
    private val logtoViewModel: LogtoViewModel by viewModels { LogtoViewModel.Factory }
    //...autres codes
}

Configurer l'URI de redirection​

Passons à la page des détails de l'application de Logto Console. Ajoutez une URI de redirection io.logto.android://io.logto.sample/callback et cliquez sur "Enregistrer les modifications".

Implémenter la connexion et la déconnexion​

Vous pouvez utiliser logtoClient.signIn pour connecter l'utilisateur et logtoClient.signOut pour déconnecter l'utilisateur.

//...avec d'autres imports
class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    // ...autres codes

    // Ajouter une donnée en direct pour observer le statut d'authentification
    private val _authenticated = MutableLiveData(logtoClient.isAuthenticated)
    val authenticated: LiveData<Boolean>
        get() = _authenticated

    fun signIn(context: Activity) {
        logtoClient.signIn(context, "io.logto.android://io.logto.sample/callback") { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }

    fun signOut(context: Activity) {
        logtoClient.signOut(context, "io.logto.android://io.logto.sample/callback") { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        //...autres codes

        // Supposons que vous ayez un bouton avec l'identifiant "sign_in_button" dans votre mise en page
        val signInButton = findViewById<Button>(R.id.sign_in_button)
        signInButton.setOnClickListener {
            logtoViewModel.signIn(this)
        }

        // Supposons que vous ayez un bouton avec l'identifiant "sign_out_button" dans votre mise en page
        val signOutButton = findViewById<Button>(R.id.sign_out_button)
        signOutButton.setOnClickListener {
            if (logtoViewModel.authenticated) { // Vérifiez si l'utilisateur est authentifié
                logtoViewModel.signOut(this)
            }
        }

        // Observez le statut d'authentification pour mettre à jour l'interface utilisateur
        logtoViewModel.authenticated.observe(this) { authenticated ->
            if (authenticated) {
                // L'utilisateur est authentifié
                signInButton.visibility = View.GONE
                signOutButton.visibility = View.VISIBLE
            } else {
                // L'utilisateur n'est pas authentifié
                signInButton.visibility = View.VISIBLE
                signOutButton.visibility = View.GONE
            }
        }

    }
}

//...avec d'autres imports
class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    // ...autres codes

    // Ajouter une donnée en direct pour observer le statut d'authentification
    private val _authenticated = MutableLiveData(logtoClient.isAuthenticated)
    val authenticated: LiveData<Boolean>
        get() = _authenticated

    fun signIn(context: Activity) {
        logtoClient.signIn(context, "io.logto.android://io.logto.sample/callback") { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }

    fun signOut() {
        logtoClient.signOut { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        //...autres codes

        // Supposons que vous ayez un bouton avec l'identifiant "sign_in_button" dans votre mise en page
        val signInButton = findViewById<Button>(R.id.sign_in_button)
        signInButton.setOnClickListener {
            logtoViewModel.signIn(this)
        }

        // Supposons que vous ayez un bouton avec l'identifiant "sign_out_button" dans votre mise en page
        val signOutButton = findViewById<Button>(R.id.sign_out_button)
        signOutButton.setOnClickListener {
            if (logtoViewModel.authenticated) { // Vérifiez si l'utilisateur est authentifié
                logtoViewModel.signOut()
            }
        }

        // Observez le statut d'authentification pour mettre à jour l'interface utilisateur
        logtoViewModel.authenticated.observe(this) { authenticated ->
            if (authenticated) {
                // L'utilisateur est authentifié
                signInButton.visibility = View.GONE
                signOutButton.visibility = View.VISIBLE
            } else {
                // L'utilisateur n'est pas authentifié
                signInButton.visibility = View.VISIBLE
                signOutButton.visibility = View.GONE
            }
        }

    }
}

Point de contrôle : Testez votre application​

Maintenant, vous pouvez tester votre application :

1. Exécutez votre application, vous verrez le bouton de connexion.
2. Cliquez sur le bouton de connexion, le SDK initiera le processus de connexion et vous redirigera vers la page de connexion Logto.
3. Après vous être connecté, vous serez redirigé vers votre application et verrez le bouton de déconnexion.
4. Cliquez sur le bouton de déconnexion pour effacer le stockage des jetons et vous déconnecter.

Add Microsoft Entra ID SAML enterprise SSO connector​

Pour simplifier la gestion des accès et obtenir des garanties de niveau entreprise pour vos grands clients, connectez-vous avec Android en tant que fournisseur d'identité fédéré. Le connecteur SSO d’entreprise Logto vous aide à établir cette connexion en quelques minutes en permettant l'entrée de plusieurs paramètres.

Pour ajouter un connecteur SSO d’entreprise, suivez simplement ces étapes :

1. Accédez à Logto console > Enterprise SSO.

2. Cliquez sur le bouton "Ajouter un connecteur d’entreprise" et choisissez votre type de fournisseur SSO. Choisissez parmi les connecteurs préconstruits pour Microsoft Entra ID (Azure AD), Google Workspace et Okta, ou créez une connexion SSO personnalisée en utilisant le protocole standard OpenID Connect (OIDC) ou SAML.
3. Fournissez un nom unique (par exemple, Connexion SSO pour Acme Company).

4. Configurez la connexion avec votre IdP dans l'onglet "Connexion". Consultez les guides ci-dessus pour chaque type de connecteur.

5. Personnalisez l'expérience SSO et le domaine de messagerie de l’entreprise dans l'onglet "Expérience". Les utilisateurs se connectant avec le domaine de messagerie activé pour le SSO seront redirigés vers l'authentification SSO.

6. Enregistrez les modifications.

Set up Application SSO Azure AD​

Étape 1 : Créer une application Azure AD SSO​

Initiez l'intégration SSO Azure AD en créant une application SSO du côté Azure AD.

1. Allez sur le portail Azure et connectez-vous en tant qu'administrateur.
2. Sélectionnez le service Microsoft Entra ID.
3. Naviguez vers les Applications d'entreprise à l'aide du menu latéral. Cliquez sur Nouvelle application, et sélectionnez Créer votre propre application.

1. Entrez le nom de l'application et sélectionnez Intégrer toute autre application que vous ne trouvez pas dans la galerie (Non-galerie).
2. Sélectionnez Configurer l’authentification unique > SAML.

1. Suivez les instructions, comme première étape, vous devrez remplir la configuration SAML de base en utilisant les informations suivantes fournies par Logto.

• URI d’audience (ID d’entité SP) : Il représente un identifiant unique global pour votre service Logto, fonctionnant comme l'EntityId pour SP lors des requêtes d’authentification vers le fournisseur d’identité (IdP). Cet identifiant est essentiel pour l'échange sécurisé des assertions SAML et d'autres données liées à l'authentification entre l'IdP et Logto.
• URL ACS : L'URL du service consommateur d'assertions (ACS) est l'emplacement où l'assertion SAML est envoyée avec une requête POST. Cette URL est utilisée par l'IdP pour envoyer l'assertion SAML à Logto. Elle agit comme une URL de rappel où Logto s'attend à recevoir et à consommer la réponse SAML contenant les informations d'identité de l'utilisateur.

Cliquez sur Enregistrer pour continuer.

Étape 2 : Configurer SAML SSO sur Logto​

Pour que l'intégration SAML SSO fonctionne, vous devrez fournir les métadonnées de l'IdP à Logto. Revenons du côté de Logto et accédons à l'onglet Connection de votre connecteur Azure AD SSO.

Logto propose trois manières différentes de configurer les métadonnées de l'IdP. La manière la plus simple est de fournir l'URL des métadonnées de l'application Azure AD SSO.

Copiez l'URL des métadonnées de fédération de l'application à partir de la section Certificats SAML de votre application Azure AD SSO et collez-la dans le champ Metadata URL dans Logto.

Logto récupérera les métadonnées à partir de l'URL et configurera automatiquement l'intégration SAML SSO.

Étape 3 : Configurer le mappage des attributs utilisateur​

Logto offre un moyen flexible de mapper les attributs utilisateur renvoyés par le fournisseur d’identité (IdP) aux attributs utilisateur dans Logto. Logto synchronisera par défaut les attributs utilisateur suivants depuis l'IdP :

• id : L'identifiant unique de l'utilisateur. Logto lira la revendication nameID de la réponse SAML comme identifiant d'identité SSO de l'utilisateur.
• email : L'adresse e-mail de l'utilisateur. Logto lira la revendication email de la réponse SAML comme e-mail principal de l'utilisateur par défaut.
• name : Le nom de l'utilisateur.

Vous pouvez gérer la logique de mappage des attributs utilisateur soit du côté Azure AD, soit du côté Logto.

1. Mapper les attributs utilisateur AzureAD aux attributs utilisateur Logto du côté Logto.

   Visitez la section Attributes & Claims de votre application SSO Azure AD.

   Copiez les noms d'attributs suivants (avec le préfixe de l'espace de noms) et collez-les dans les champs correspondants dans Logto.

   • http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress
   • http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name (Recommandation : mettez à jour cette carte de valeur d'attribut à user.displayname pour une meilleure expérience utilisateur)

1. Mapper les attributs utilisateur AzureAD aux attributs utilisateur Logto du côté AzureAD.

   Visitez la section Attributes & Claims de votre application SSO Azure AD.

   Cliquez sur Edit, et mettez à jour les champs Additional claims en fonction des paramètres des attributs utilisateur Logto :

   • mettez à jour la valeur du nom de revendication en fonction des paramètres des attributs utilisateur Logto.
   • supprimez le préfixe de l'espace de noms.
   • cliquez sur Save pour continuer.

   Vous devriez obtenir les paramètres suivants :

Vous pouvez également spécifier des attributs utilisateur supplémentaires du côté Azure AD. Logto conservera un enregistrement des attributs utilisateur originaux renvoyés par l'IdP sous le champ sso_identity de l'utilisateur.

Étape 4 : Assigner des utilisateurs à l'application Azure AD SSO​

Visitez la section Users and groups de votre application Azure AD SSO. Cliquez sur Add user/group pour attribuer des utilisateurs à l'application Azure AD SSO. Seuls les utilisateurs attribués à votre application Azure AD SSO pourront s'authentifier via le connecteur Azure AD SSO.

Étape 5 : Définir les domaines de messagerie et activer le connecteur SSO​

Fournissez les domaines de messagerie de votre organisation dans l'onglet SSO experience du connecteur de Logto. Cela activera le connecteur SSO comme méthode d'authentification pour ces utilisateurs.

Les utilisateurs ayant des adresses e-mail dans les domaines spécifiés seront redirigés pour utiliser le connecteur SAML SSO comme seule méthode d'authentification.

Veuillez consulter la documentation officielle d'Azure AD pour plus de détails sur l'intégration SSO d'Azure AD.

Save your configuration​

Vérifiez que vous avez rempli les valeurs nécessaires dans la zone de configuration du connecteur Logto. Cliquez sur "Enregistrer et terminer" (ou "Enregistrer les modifications") et le connecteur Microsoft Entra ID SAML enterprise SSO devrait être disponible maintenant.

Enable Microsoft Entra ID SAML enterprise SSO connector in Sign-in Experience​

Vous n'avez pas besoin de configurer individuellement les connecteurs d'entreprise, Logto simplifie l'intégration du SSO dans vos applications en un seul clic.

1. Accédez à : Console > Expérience de connexion > Inscription et connexion.
2. Activez le bouton "SSO d’entreprise".
3. Enregistrez les modifications.

Une fois activé, un bouton "Authentification unique (SSO)" apparaîtra sur votre page de connexion. Les utilisateurs d'entreprise avec des domaines de messagerie compatibles SSO peuvent accéder à vos services en utilisant leurs fournisseurs d’identité d’entreprise (IdPs).

Pour en savoir plus sur l'expérience utilisateur SSO, y compris le SSO initié par le SP et le SSO initié par l'IdP, consultez les flux utilisateur : SSO d’entreprise.

Testing and Validation​

Retournez à votre application Android (Kotlin / Java). Vous devriez maintenant pouvoir vous connecter avec Microsoft Entra ID SAML enterprise SSO. Profitez-en !

Further readings​

Flux des utilisateurs finaux : Logto fournit des flux d'authentification prêts à l'emploi, y compris l'authentification multi-facteurs (MFA) et le SSO d’entreprise, ainsi que des API puissantes pour une mise en œuvre flexible des paramètres de compte, de la vérification de sécurité et de l'expérience multi-locataire.

Autorisation : L'autorisation définit les actions qu'un utilisateur peut effectuer ou les ressources auxquelles il peut accéder après avoir été authentifié. Découvrez comment protéger votre API pour les applications natives et monopages et mettre en œuvre le contrôle d’accès basé sur les rôles (RBAC).

Organisations : Particulièrement efficace dans les applications SaaS multi-locataires et B2B, la fonctionnalité d'organisation permet la création de locataires, la gestion des membres, le RBAC au niveau de l'organisation et l'approvisionnement juste-à-temps.

Série IAM client : Nos articles de blog en série sur la gestion des identités et des accès des clients (ou consommateurs), des sujets de base aux sujets avancés et au-delà.

Dans cet article, nous allons parcourir les étapes pour construire rapidement l'expérience de connexion OIDC enterprise SSO (authentification utilisateur) avec Android (Kotlin / Java) et Logto.

Prérequis

• Une instance Logto en cours d'exécution. Consultez la page d'introduction pour commencer.
• Connaissance de base de Android (Kotlin / Java).
• Un compte OIDC enterprise SSO utilisable.

Create an application in Logto​

Logto est basé sur l'authentification OpenID Connect (OIDC) et l'autorisation OAuth 2.0. Il prend en charge la gestion des identités fédérées à travers plusieurs applications, communément appelée authentification unique (SSO).

Pour créer votre application Native app, suivez simplement ces étapes :

1. Ouvrez la Logto Console. Dans la section "Get started", cliquez sur le lien "View all" pour ouvrir la liste des frameworks d'application. Alternativement, vous pouvez naviguer vers Logto Console > Applications, et cliquer sur le bouton "Create application".
2. Dans la fenêtre modale qui s'ouvre, cliquez sur la section "Native app" ou filtrez tous les frameworks "Native app" disponibles en utilisant les cases à cocher de filtre rapide à gauche. Cliquez sur la carte du framework "Android" pour commencer à créer votre application.
3. Entrez le nom de l'application, par exemple, "Bookstore", et cliquez sur "Create application".

🎉 Ta-da ! Vous venez de créer votre première application dans Logto. Vous verrez une page de félicitations qui inclut un guide d'intégration détaillé. Suivez le guide pour voir quelle sera l'expérience dans votre application.

Integrate Android SDK​

Installation​

Logto Android SDK se décline en deux versions majeures :

• v3 (beta) : Ouvre l'expérience de connexion dans les Chrome Custom Tabs (le navigateur système), ce qui permet la connexion par passkey et partage la session du navigateur. Notez que v3 supprime la prise en charge des connecteurs WeChat (Native) et Alipay (Native) ; vous pouvez utiliser WeChat (Web) et Alipay (Web) à la place, qui fonctionnent via le navigateur. Si vous dépendez des connecteurs natifs, restez sur v2.
• v2 : Ouvre l'expérience de connexion dans une WebView intégrée, ce qui est requis par les connecteurs sociaux natifs, mais ne prend pas en charge la connexion par passkey (WebView ne prend pas en charge WebAuthn, la norme sous-jacente des passkeys).

Ce guide couvre les deux versions. Choisissez votre version dans les onglets ci-dessous, et le choix sera synchronisé tout au long de ce guide.

Avant d'installer Logto Android SDK, assurez-vous que mavenCentral() est ajouté à votre configuration de dépôt dans le fichier de construction du projet Gradle :

dependencyResolutionManagement {
  repositories {
    mavenCentral()
  }
}

Ajoutez Logto Android SDK à vos dépendances :

dependencies {
  implementation("io.logto.sdk:android:3.0.0-beta")
}

dependencies {
  implementation 'io.logto.sdk:android:3.0.0-beta'
}

dependencies {
  implementation("io.logto.sdk:android:2.0.3")
}

dependencies {
  implementation 'io.logto.sdk:android:2.0.3'
}

Étant donné que le SDK nécessite un accès à Internet, vous devez ajouter la permission suivante à votre fichier AndroidManifest.xml :

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools">

  <!-- ajouter la permission internet -->
  <uses-permission android:name="android.permission.INTERNET" />

  <!-- autres configurations... -->
</manifest>

Init LogtoClient​

Créez un LogtoViewModel.kt et initialisez LogtoClient dans ce modèle de vue :

//...avec d'autres imports
import io.logto.sdk.android.LogtoClient
import io.logto.sdk.android.type.LogtoConfig

class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    private val logtoConfig = LogtoConfig(
          endpoint = "<votre-point-de-terminaison-logto>",
          appId = "<votre-id-app>",
          scopes = null,
          resources = null,
          usingPersistStorage = true,
    )

    private val logtoClient = LogtoClient(logtoConfig, application)

    companion object {
        val Factory: ViewModelProvider.Factory = object : ViewModelProvider.Factory {
            @Suppress("UNCHECKED_CAST")
            override fun <T : ViewModel> create(
                modelClass: Class<T>,
                extras: CreationExtras
            ): T {
                // Obtenez l'objet Application à partir des extras
                val application = checkNotNull(extras[APPLICATION_KEY])
                return LogtoViewModel(application) as T
            }
        }
    }
}

ensuite, créez un LogtoViewModel pour votre MainActivity.kt :

//...avec d'autres imports
class MainActivity : AppCompatActivity() {
    private val logtoViewModel: LogtoViewModel by viewModels { LogtoViewModel.Factory }
    //...autres codes
}

Configurer l'URI de redirection​

Passons à la page des détails de l'application de Logto Console. Ajoutez une URI de redirection io.logto.android://io.logto.sample/callback et cliquez sur "Enregistrer les modifications".

Implémenter la connexion et la déconnexion​

Vous pouvez utiliser logtoClient.signIn pour connecter l'utilisateur et logtoClient.signOut pour déconnecter l'utilisateur.

//...avec d'autres imports
class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    // ...autres codes

    // Ajouter une donnée en direct pour observer le statut d'authentification
    private val _authenticated = MutableLiveData(logtoClient.isAuthenticated)
    val authenticated: LiveData<Boolean>
        get() = _authenticated

    fun signIn(context: Activity) {
        logtoClient.signIn(context, "io.logto.android://io.logto.sample/callback") { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }

    fun signOut(context: Activity) {
        logtoClient.signOut(context, "io.logto.android://io.logto.sample/callback") { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        //...autres codes

        // Supposons que vous ayez un bouton avec l'identifiant "sign_in_button" dans votre mise en page
        val signInButton = findViewById<Button>(R.id.sign_in_button)
        signInButton.setOnClickListener {
            logtoViewModel.signIn(this)
        }

        // Supposons que vous ayez un bouton avec l'identifiant "sign_out_button" dans votre mise en page
        val signOutButton = findViewById<Button>(R.id.sign_out_button)
        signOutButton.setOnClickListener {
            if (logtoViewModel.authenticated) { // Vérifiez si l'utilisateur est authentifié
                logtoViewModel.signOut(this)
            }
        }

        // Observez le statut d'authentification pour mettre à jour l'interface utilisateur
        logtoViewModel.authenticated.observe(this) { authenticated ->
            if (authenticated) {
                // L'utilisateur est authentifié
                signInButton.visibility = View.GONE
                signOutButton.visibility = View.VISIBLE
            } else {
                // L'utilisateur n'est pas authentifié
                signInButton.visibility = View.VISIBLE
                signOutButton.visibility = View.GONE
            }
        }

    }
}

//...avec d'autres imports
class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    // ...autres codes

    // Ajouter une donnée en direct pour observer le statut d'authentification
    private val _authenticated = MutableLiveData(logtoClient.isAuthenticated)
    val authenticated: LiveData<Boolean>
        get() = _authenticated

    fun signIn(context: Activity) {
        logtoClient.signIn(context, "io.logto.android://io.logto.sample/callback") { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }

    fun signOut() {
        logtoClient.signOut { logtoException ->
            logtoException?.let { println(it) }
            // Mettre à jour la donnée en direct
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }
}