Lock.Android : Débuter

Lock pour Android peut s’intégrer à vos applications Android natives pour offrir une manière élégante de connecter vos utilisateurs et de les inscrire dans votre application. Il prend en charge les fournisseurs d’identité sociale tels que Facebook, Google ou X, ainsi que les fournisseurs d’entreprise tels qu’Active Directory.

Découvrez le référentiel Lock.Android sur GitHub

Pour utiliser l’interface utilisateur de Lock ou votre propre interface utilisateur via la Auth0.Android library (Bibliothèque Auth0.Android), le niveau d’API Android minimum requis est 21+ et Java version 8 ou supérieure. Vous aurez également besoin d’une application Auth0 de type « Native ».

Voici le nécessaire dans build.gradle pour cibler le code à 8 octets pour les plugiciels Android et Kotlin respectivement.

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = '1.8'
    }
}

Lock est disponible dans Maven Central. Pour commencer à utiliser Lock, ajoutez ces lignes à votre fichier de dépendances build.gradle :

implémentation « com.auth0.android:lock:3.+ »

Vous pouvez vérifier la dernière version sur le référentiel Readme ou dans Maven.

N’oubliez pas de synchroniser votre projet avec les fichiers Gradle après avoir ajouté votre dépendance Gradle.

Avant de commencer, vous devez remplir quelques paramètres dans votre Auth0 Dashboard (Tableau de bord Auth0).

Accédez à votre tableau de bord Auth0 et aux paramètres de l’application. Ajoutez l’URL suivante à l’application URL de rappel autorisées :

https://{yourDomain}/android/{yourAppPackageName}/callback

Remplacez {yourAppPackageName} par le nom du package réel de votre application, disponible dans votre fichier app/build.gradle comme valeur applicationId.

Les applications Android doivent être signées avant de pouvoir être installées sur un appareil. Pour cela, 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 builds de développement. Ce Keystore (Magasin de clés) sera probablement différent pour votre version de production, car il sera utilisé pour vous identifier en tant que développeur.

Lorsque vous utilisez la fonction d’authentification Web (c’est-à-dire les connexions sociales), Lock sera configuré par défaut pour tenter d’utiliser les liens d’application Android. Cela nécessite un paramètre supplémentaire dans le tableau de bord de l’application Auth0. Utilisez notre Android Keystores and Key Hashes Guide (Guide des magasins de clés et des hachages de clés Android) pour compléter cette étape.

Les instructions suivantes décrivent la mise en œuvre de Classic Lock pour Android. Si vous souhaitez implémenter spécifiquement Passwordless Lock pour Android (Lock sans mot de passe pour Android), veuillez consulter Lock.Android : Sans mot de passe.

Dans votre fichier app/build.gradle ajoutez les paramètres fictifs Manifest Placeholders pour les propriétés Auth0 Domain et Auth0 Scheme, qui vont être utilisés en interne par la bibliothèque pour enregistrer un « filtre d’intention » qui capture 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
        // ...

        // ---> Add the next line
        manifestPlaceholders = [auth0Domain: "@string/com_auth0_domain", auth0Scheme: "https"]
        // <---
    }
}

Il est recommandé d’ajouter ces valeurs au fichier strings.xml en tant que ressources de chaîne qui peuvent être référencées ultérieurement à partir du code. Ce guide suivra cette pratique.

<resources>
    <string name="com_auth0_client_id">{yourClientId}</string>
    <string name="com_auth0_domain">{yourDomain}</string>
</resources>

Dans l’activité où vous prévoyez d’invoquer Lock, créez une instance de Auth0 avec les informations de votre application. Le moyen le plus simple de le créer est de transmettre un contexte Android. Cela prendra en compte les valeurs définies précédemment dans le fichier strings.xml. Pour que cela fonctionne, les ressources de chaîne doivent être définies à l’aide des mêmes clés que celles répertoriées ci-dessus.

val account = Auth0(context)

Déclarer une implémentation AuthenticationCallback (Rappel d’authentification) qui gérera les événements d’authentification des utilisateurs. L’objet Credentials (Informations d’identification) renvoyé dans les scénarios d’authentification réussis contiendra les jetons que votre application ou API finira par consommer. Veillez consulter Tokens (Jetons) pour plus de détails.

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

    override fun onError(error: AuthenticationException) {
        // Exception occurred
    }
}

Préparez une nouvelle instance de Lock en utilisant la classe Builder pour la configurer. Fournissez les détails du compte et l’implémentation de rappel déclarée ci-dessus. Des valeurs telles que l'audience, la permission et les connexions disponibles peuvent être configurées ici.

Une fois terminé, créez l’instance Lock. Cette instance est destinée à être réutilisée et doit être supprimée lorsqu’elle n’est plus nécessaire. Un bon endroit pour procéder ainsi est dans le dossier de votre méthode d’activité onDestroy.

// This activity will show Lock
class MyActivity : AppCompatActivity() {

    private lateinit var lock: Lock

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

        val account = Auth0(this)
        // Instantiate Lock once
        lock = Lock.newBuilder(account, callback)
            // Customize Lock
            .build(this)
    }

    override fun onDestroy() {
        super.onDestroy()
        // Important! Release Lock and its resources
        lock.onDestroy(this)
    }

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

        override fun onError(error: AuthenticationException) {
            // An exception occurred
        }
    }
}

Enfin, lancez le widget Lock à l’intérieur de votre activité.

startActivity(lock.newIntent(this))

C’est tout ! Lock s’occupera du reste pour vous.

Le schéma d’URI de rappel utilisé dans cet article et par défaut par Lock est https. Cela fonctionne mieux pour Android Marshmallow (API 23) ou version plus récente si vous utilisez Android App Links (Liens vers les applications Android), mais dans les versions Android précédentes, cela peut afficher la boîte de dialogue de sélection d’intention invitant l’utilisateur à choisir soit votre application, soit le navigateur pour résoudre l’intention. C’est ce qu’on appelle la « boîte de dialogue de désambiguïsation ». Vous pouvez modifier ce comportement en utilisant un schéma unique personnalisé afin que le système d’exploitation ouvre le lien directement avec votre application.

1. Mettez à jour la valeur de l’espace réservé au Manifest auth0Scheme dans le fichier app/build.gradle ou directement dans la définition du filtre d’intention dans le fichier AndroidManifest.xml en remplaçant le schéma existant par le nouveau.

2. Mettez à jour les « URL de rappel autorisées » dans les paramètres de votre application Auth0 Dashboard pour qu’elles correspondent aux URL qui commencent par le nouveau schéma.

3. Appelez withScheme() lors de la configuration de Lock avec le monteur, en passant le schéma que vous voulez utiliser.

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

Pour obtenir une description des messages d’erreur courants, veuillez consulter la page Error Messages (Messages d’erreur). De plus, si votre rappel reçoit une AuthenticationException (Exception d’authentification) vous pouvez vérifier source pour apprendre à identifier chaque scénario d’erreur.

• Lock.Android: thème personnalisé
• Lock.Android: Configuration
• Lock.Android: Champs personnalisés à l’inscription
• Lock.Android : internationalisation
• Déconnexion