Skip to main content
Lock for Android peut s’intégrer à vos applications Android natives pour offrir à vos utilisateurs une interface élégante pour se connecter et s’inscrire à votre application. Il prend en charge les sociaux comme Facebook, Google ou X, ainsi que les fournisseurs d’entreprise comme Active Directory. Consultez le dépôt Lock.Android sur GitHub.

​
Exigences

Pour utiliser l’interface de Lock ou votre propre interface au moyen de la bibliothèque Auth0.Android, le niveau d’API Android minimal requis est 21+ et la version de Java doit être 8 ou ultérieure. Vous aurez également besoin d’une application Auth0 de type “Native”. Voici ce qu’il vous faut dans build.gradle pour cibler le bytecode Java 8 avec les plugins Android et Kotlin, respectivement. 
android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = '1.8'
    }
}

​
Installation

Lock est disponible sur Maven Central. Pour commencer à utiliser Lock, ajoutez cette ligne au fichier de dépendances build.gradle : implementation 'com.auth0.android:lock:3.+' Vous pouvez consulter la version la plus récente dans le README du dépôt ou sur Maven. Après avoir ajouté votre dépendance Gradle, n’oubliez pas de synchroniser votre projet avec les fichiers Gradle.

​
Paramètres d’Auth0 Dashboard

Vous devez configurer quelques paramètres dans votre Auth0 Dashboard avant de commencer.

​
URL de rappel

Accédez à votre , puis ouvrez les paramètres de l’application. Ajoutez l’URL suivante aux Allowed Callback URLs de l’application : https://{yourDomain}/android/{yourAppPackageName}/callback Remplacez {yourAppPackageName} par le véritable nom de package de votre application, indiqué dans votre fichier app/build.gradle comme valeur de applicationId.

​
Keystores et hachages de clés

Les applications Android doivent être signées avant de pouvoir être installées sur un appareil. À cette fin, l’IDE Android Studio génère, lors de sa première exécution, un « Android Debug Keystore » par défaut qu’il utilisera pour signer les versions de développement. Ce Keystore sera probablement différent de celui de votre version de production, puisqu’il servira à vous identifier en tant que développeur. Lorsque vous utilisez la fonctionnalité Web Authentication (c.-à-d. les connexions sociales), Lock est configuré par défaut pour tenter d’utiliser Android App Links. Cela nécessite un paramètre supplémentaire dans le tableau de bord de l’application Auth0. Utilisez notre guide des keystores Android et des hachages de clés pour terminer cette étape.

​
Implémentation de Lock (social, base de données, entreprise)

Les instructions suivantes expliquent comment implémenter Classic Lock pour Android. Si vous cherchez plutôt à implémenter Lock pour Android, consultez Lock.Android : Passwordless.

​
Configuration du SDK

Dans votre fichier app/build.gradle, ajoutez les Manifest Placeholders pour les propriétés Domaine Auth0 et Schéma Auth0, qui seront utilisées en interne par la bibliothèque pour enregistrer un intent-filter qui capte le résultat de l’authentification. 
plugins {
    id "com.android.application"
    id "kotlin-android"
}

android {
    compileSdkVersion 30
    defaultConfig {
        applicationId "com.auth0.samples"
        minSdkVersion 21
        targetSdkVersion 30
        // ...

        // ---> Ajouter la ligne suivante
        manifestPlaceholders = [auth0Domain: "@string/com_auth0_domain", auth0Scheme: "https"]
        // <---
    }
}
Il est recommandé d’ajouter ces valeurs au fichier strings.xml comme ressources de chaîne qui pourront être référencées plus tard dans le code. Ce guide suivra cette approche.

​
Utilisation du SDK

Dans l’activité où vous comptez invoquer Lock, créez une instance d’Auth0 avec les informations de votre application. Le plus simple est de la créer en lui transmettant un contexte Android. Les valeurs définies précédemment dans le fichier strings.xml seront alors utilisées. Pour que cela fonctionne, les ressources de chaîne doivent être définies avec les mêmes clés que celles indiquées ci-dessus. 
val account = Auth0(context)
Définissez une implémentation de AuthenticationCallback qui gérera les événements d’authentification de l’utilisateur. L’objet Credentials renvoyé en cas d’authentification réussie contiendra les jetons que votre application ou votre API utilisera. Consultez Tokens pour en savoir plus. 
private val callback = object : AuthenticationCallback() {
    override fun onAuthentication(credentials: Credentials) {
        // Authentifié
    }

    override fun onError(error: AuthenticationException) {
        // Une exception s'est produite
    }
}
Préparez une nouvelle instance de Lock à l’aide de la classe Builder pour la configurer. Fournissez les informations du compte et l’implémentation du rappel déclarée ci-dessus. Des valeurs comme , scope et les connexions disponibles peuvent être configurées ici. Une fois terminé, créez l’instance Lock. Cette instance est conçue pour être réutilisée et doit être libérée lorsqu’elle n’est plus nécessaire. Un bon endroit pour le faire est dans la méthode onDestroy de votre activité. 
// Cette activité affichera Lock
class MyActivity : AppCompatActivity() {

    private lateinit var lock: Lock

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val account = Auth0(this)
        // Instancier Lock une seule fois
        lock = Lock.newBuilder(account, callback)
            // Personnaliser Lock
            .build(this)
    }

    override fun onDestroy() {
        super.onDestroy()
        // Important ! Libérer Lock et ses ressources
        lock.onDestroy(this)
    }

    private val callback = object : AuthenticationCallback() {
        override fun onAuthentication(credentials: Credentials) {
            // Authentifié
        }

        override fun onError(error: AuthenticationException) {
            // Une exception s'est produite
        }
    }
}
Enfin, lancez le widget Lock dans votre activité. 
startActivity(lock.newIntent(this))
Et voilà ! Lock s’occupe du reste. Le schéma d’URI de rappel utilisé dans cet article et, par défaut, par Lock est https. Cela fonctionne de façon optimale sur Android Marshmallow (API 23) ou version ultérieure si vous utilisez les Android App Links. En revanche, sur les versions antérieures d’Android, la boîte de dialogue de sélection peut s’afficher et inviter l’utilisateur à choisir entre votre application et le navigateur pour traiter l’intent. On appelle cela la « boîte de dialogue de désambiguïsation ». Vous pouvez modifier ce comportement en utilisant un schéma personnalisé unique afin que le système d’exploitation ouvre directement le lien dans votre application.
  1. Mettez à jour la valeur de l’espace réservé du manifeste auth0Scheme dans le fichier app/build.gradle, ou directement dans la définition du filtre d’intent du fichier AndroidManifest.xml, en remplaçant le schéma existant par le nouveau.
  2. Mettez à jour le paramètre “Allowed Callback URLs” dans les paramètres de votre application dans Auth0 Dashboard afin qu’il corresponde à des URL qui commencent par le nouveau schéma.
  3. Appelez withScheme() lors de la configuration de Lock avec le générateur, en lui transmettant le schéma que vous souhaitez utiliser.
La valeur du schéma doit être entièrement en minuscules. Un message d’avertissement sera consigné si ce n’est pas le cas, et l’authentification ne se terminera jamais.

​
Configuration de Lock

Pour consulter la liste complète des options de configuration de Lock, consultez Lock.Android: Configuration.

​
Messages d’erreur

Pour obtenir une description des messages d’erreur courants, consultez la page Error Messages. De plus, si votre rappel reçoit une AuthenticationException, vous pouvez aussi consulter le code source pour savoir comment identifier chaque scénario d’erreur.

​
En savoir plus