Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.
;
};
export const sections = [{
id: "configuration-d-auth0",
title: "Configuration d’Auth0"
}, {
id: "installer-la-trousse-sdk-android-auth0",
title: "Installer la trousse SDK Android Auth0"
}, {
id: "ajouter-des-paramètres-fictifs-dans-le-manifeste",
title: "Ajouter des paramètres fictifs dans le manifeste"
}, {
id: "configuration-de-votre-application",
title: "Configuration de votre application"
}, {
id: "ajouter-une-fonctionnalité-de-connexion-à-votre-application",
title: "Ajouter une fonctionnalité de connexion à votre application"
}, {
id: "ajouter-une-fonctionnalité-de-déconnexion-à-votre-application",
title: "Ajouter une fonctionnalité de déconnexion à votre application"
}, {
id: "afficher-les-informations-du-profil-utilisateur",
title: "Afficher les informations du profil utilisateur"
}];
Pour utiliser les services Auth0, vous devez avoir une application installée dans Auth0 Dashboard. L’application Auth0 est l’endroit où vous allez configurer l’authentification pour votre projet.
### Configurer une application
Utilisez le sélecteur interactif pour créer une nouvelle application Auth0 ou sélectionner une application existante qui représente le projet avec lequel vous souhaitez effectuer l’intégration. Dans Auth0, chaque application se voit attribuer un identifiant client unique alphanumérique que votre code d’application utilisera pour appeler les API Auth0 via la trousse SDK.
Tous les paramètres que vous configurez à l’aide de ce guide de démarrage rapide seront automatiquement mis à jour pour votre application dans le [Tableau de bord](https://manage.auth0.com/#/), qui est l’endroit où vous pourrez gérer vos applications à l’avenir.
Si vous préférez explorer une configuration complète, consultez plutôt un exemple d’application.
### Configuration des URL de rappel
Une URL de rappel est l’URL de l’application vers laquelle Auth0 dirigera vos utilisateurs une fois qu’ils se seront authentifiés. Si vous ne définissez pas cette valeur, Auth0 ne renverra pas les utilisateurs vers votre application après leur connexion.
Si vous suivez notre projet à titre d’exemple, définissez ceci sur `demo://{yourDomain}/android/YOUR\_APP\_PACKAGE\_NAME/callback`.
### Configuration des URL de déconnexion
Une URL de déconnexion est l’URL de l’application vers laquelle Auth0 redirigera vos utilisateurs une fois qu’ils se seront déconnectés. Si vous ne définissez pas cette valeur, les utilisateurs ne pourront pas se déconnecter de votre application et recevront un message d’erreur.
Si vous suivez notre projet à titre d’exemple, définissez ceci sur `demo://{yourDomain}/android/YOUR\_APP\_PACKAGE\_NAME/callback`
Ajoutez la trousse SDK [Android Auth0](https://github.com/auth0/Auth0.Android) à votre projet. La bibliothèque adressera des demandes aux Authentication et Management API d’Auth0.
Dans la section dépendances du `build.gradle` de votre application, ajoutez ce qui suit :
```
implementation 'com.auth0.android:auth0:2. '
```
Veillez à cibler le code Java 8+ pour les plugiciels Android et Kotlin respectivement.
La trousse SDK nécessite des paramètres fictifs dans le manifeste. Auth0 utilise des paramètres fictifs en interne pour définir un `intent-filter`, qui capture l’URL de rappel pour l’authentification. Vous devez définir le domaine du locataire Auth0 et le schéma de l’URL de rappel.
Vous n’avez pas besoin de déclarer un `intent-filter` spécifique pour votre activité car vous avez défini les paramètres fictifs dans le manifeste avec vos valeurs Auth0 **Domaine** et **Schéma** et la bibliothèque traitera la redirection pour vous.
Nous avons utilisé la valeur `demo` pour `auth0Scheme` ici, afin qu’un schéma d’URL personnalisé puisse être utilisé pour l’URL vers laquelle Auth0 redirige après la connexion. L’alternative est `https` si vous voulez utiliser des [liens vers les applications Android](https://auth0.com/docs/applications/enable-android-app-links). Vous pouvez en savoir plus sur la définition de cette valeur dans le [SDK README d’Auth0.Android](https://github.com/auth0/Auth0.Android#a-note-about-app-deep-linking).
Pour que la trousse SDK fonctionne correctement, définissez les propriétés suivantes dans `strings.xml` :
* `com_auth0_domain` : Le domaine de votre locataire Auth0. En général, vous le trouvez dans Auth0 Dashboard sous vos paramètres d’application dans le champ Domain (Domaine). Si vous utilisez un [domaine personnalisé](https://auth0.com/docs/custom-domains), définissez-le plutôt sur la valeur de votre domaine personnalisé.
* `com_auth0_client_id` : l’identificateur de l’application Auth0 que vous avez configurée précédemment dans ce guide rapide. Vous pouvez le trouver dans Auth0 Dashboard, dans les paramètres de votre application, dans le champ Client ID (ID client).
Assurez-vous que le fichier `AndroidManifest.xml` spécifie l’autorisation `android.permissions.INTERNET` :
```html theme={null}
```
Exécutez **Sync Project with Gradle Files** dans Android Studio ou exécutez `./gradlew clean assembleDebug` à partir de la ligne de commande.
Pour en savoir plus sur l’utilisation de Gradle, consultez la [documentation officielle de Gradle](https://gradle.org/getting-started-android-build/).
La [connexion universelle](https://auth0.com/docs/hosted-pages/login) est le moyen le plus simple de mettre en place l’authentification dans votre application. Nous recommandons de l’utiliser pour une meilleure expérience, une meilleure sécurité et un plus grand nombre de fonctionnalités.
Dans la méthode `onCreate`, créez une nouvelle instance de la classe `Auth0` qui contiendra les informations d’identification de l’utilisateur.
Créez une méthode `loginWithBrowser` et utilisez la classe `WebAuthProvider` pour vous authentifier avec n’importe quelle connexion que vous avez activée sur votre application dans [Auth0 Dashboard](https://manage.auth0.com/#/). Ici, vous pouvez passer la valeur du schéma qui a été utilisée dans le paramètre fictif du manifeste `auth0Scheme` dans le cadre de la configuration initiale.
Après avoir appelé la fonction `WebAuthProvider#start`, le navigateur se lance et affiche la page de connexion. Une fois l’utilisateur authentifié, l’URL de rappel est appelée. L’URL de rappel contient le résultat final du processus d’authentification.
##### Point de contrôle
Ajoutez un bouton à votre application qui appelle `loginWithBrowser`. Lorsque vous cliquez dessus, vérifiez que votre application Next.js vous redirige vers la page [Connexion universelle Auth0](https://auth0.com/universal-login) et que vous pouvez maintenant vous connecter ou vous inscrire en utilisant un nom d’utilisateur et un mot de passe ou un fournisseur social.
Une fois l’opération terminée, vérifiez qu’Auth0 vous redirige vers votre application.
Utilisez `WebAuthProvider` pour supprimer le témoin défini par le navigateur au moment de l’authentification, de sorte que les utilisateurs soient obligés de saisir à nouveau leurs identifiants la prochaine fois qu’ils essaient de s’authentifier.
Ajoutez une méthode `logout` à votre application pour supprimer la session de l’utilisateur et le déconnecter de l’application. Ici, vous pouvez passer la valeur du schéma qui a été utilisée dans le placeholder du manifeste `auth0Scheme` dans le cadre de la configuration initiale.
Utilisez la classe `WebAuthProvider` pour mettre en œuvre la déconnexion. Cet appel ouvre le navigateur et dirige l’utilisateur vers le point de terminaison de déconnexion. Si l’utilisateur annule la déconnexion, envisagez de le rediriger vers l’URL précédente.
##### Point de contrôle
Ajoutez un bouton à votre application qui appelle `logout` et déconnecte l’utilisateur de votre application. Lorsque vous cliquez sur ce bouton, vérifiez que votre application Android vous redirige vers la page de déconnexion et vous renvoie, et que vous n’êtes plus connecté à votre application.
Utilisez la classe `AuthenticationAPIClient` pour [récupérer le profil utilisateur auprès de Auth0](https://auth0.com/docs/users/user-profiles#user-profile-management-api-access). Pour ce faire, les éléments suivants sont nécessaires :
* Le jeton d’accès renvoyé par la phase de connexion
* Le `WebAuthProvider.login` doit contenir la permission `profile`
Vous devez spécifier la permission `email` si vous avez besoin de récupérer l’adresse courriel de l’utilisateur.
Ce guide rapide définit par défaut les permissions `openid profile email` lors de l’étape de connexion ci-dessus.
L’exemple suivant démontre une fonction qui peut être utilisée pour récupérer le profil utilisateur et l’afficher à l’écran :
##### Point de contrôle
Appelez la fonction `showUserProfile` après la connexion. Vérifiez que le rappel `onSuccess` renvoie les informations du profil utilisateur.
## Étapes suivantes
Beau travail! Si vous en êtes arrivé là, vous devriez avoir la connexion, la déconnexion et les informations de profil utilisateur actives dans votre application.
Cela conclut notre tutoriel de démarrage rapide, mais il y a tellement plus à explorer. Pour en savoir plus sur ce que vous pouvez faire avec Auth0, consultez :
* [Auth0 Dashboard](https://manage.auth0.com/#) : apprenez à configurer et gérer votre locataire et vos applications Auth0
* [Trousse SDK Auth0.Android](https://github.com/auth0/Auth0.Android) : explorez en détail la trousse SDK utilisée dans ce tutoriel
* [Auth0 Marketplace](https://marketplace.auth0.com/) : découvrez des intégrations que vous pouvez activer pour étendre les fonctionnalités d’Auth0
```gradle build.gradle lines highlight={18} theme={null}
apply plugin: 'com.android.application'
android {
defaultConfig {
applicationId "com.auth0.samples"
minSdkVersion 21
targetSdkVersion 30
// ...
// ---> Add the next line
manifestPlaceholders = [auth0Domain: "@string/com_auth0_domain", auth0Scheme: "demo"]
// <---
}
}
dependencies {
// Add the Auth0 Android SDK
implementation 'com.auth0.android:auth0:2.+'
}
```
```xml strings.xml lines highlight={2-3} theme={null}
"{yourDomain}""{yourClientId}"
```
```kt MainActivity.kt lines highlight={6-38} theme={null}
import com.auth0.android.Auth0
import com.auth0.android.provider.WebAuthProvider
class MainActivity : AppCompatActivity() {
private lateinit var account: Auth0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Set up the account object with the Auth0 application details
account = Auth0(
getString(R.string.com_auth0_client_id),
getString(R.string.com_auth0_domain),
)
}
private fun loginWithBrowser() {
// Setup the WebAuthProvider, using the custom scheme and scope.
WebAuthProvider.login(account)
.withScheme("demo")
.withScope("openid profile email")
// Launch the authentication passing the callback where the results will be received
.start(this, object : Callback {
// Called when there is an authentication failure
override fun onFailure(exception: AuthenticationException) {
// Something went wrong!
}
// Called when authentication completed successfully
override fun onSuccess(credentials: Credentials) {
// Get the access token from the credentials object.
// This can be used to call APIs
val accessToken = credentials.accessToken
}
})
}
private fun logout() {
WebAuthProvider.logout(account)
.withScheme("demo")
.start(this, object : Callback {
override fun onSuccess(payload: Void?) {
// The user has been logged out!
}
override fun onFailure(error: AuthenticationException) {
// Something went wrong!
}
})
}
private fun showUserProfile(accessToken: String) {
var client = AuthenticationAPIClient(account)
// With the access token, call `userInfo` and get the profile from Auth0.
client.userInfo(accessToken)
.start(object : Callback {
override fun onFailure(exception: AuthenticationException) {
// Something went wrong!
}
override fun onSuccess(profile: UserProfile) {
// We have the user's profile!
val email = profile.email
val name = profile.name
}
})
}
}
```
```gradle build.gradle lines highlight={10-12} theme={null}
apply plugin: 'com.android.application'
android {
defaultConfig {
applicationId "com.auth0.samples"
minSdkVersion 21
targetSdkVersion 30
// ...
// ---> Add the next line
manifestPlaceholders = [auth0Domain: "@string/com_auth0_domain", auth0Scheme: "demo"]
// <---
}
}
dependencies {
// Add the Auth0 Android SDK
implementation 'com.auth0.android:auth0:2.+'
}
```
```xml strings.xml lines highlight={2-3} theme={null}
"{yourDomain}""{yourClientId}"
```
```kt MainActivity.kt lines highlight={6-38} theme={null}
import com.auth0.android.Auth0
import com.auth0.android.provider.WebAuthProvider
class MainActivity : AppCompatActivity() {
private lateinit var account: Auth0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Set up the account object with the Auth0 application details
account = Auth0(
getString(R.string.com_auth0_client_id),
getString(R.string.com_auth0_domain),
)
}
private fun loginWithBrowser() {
// Setup the WebAuthProvider, using the custom scheme and scope.
WebAuthProvider.login(account)
.withScheme("demo")
.withScope("openid profile email")
// Launch the authentication passing the callback where the results will be received
.start(this, object : Callback {
// Called when there is an authentication failure
override fun onFailure(exception: AuthenticationException) {
// Something went wrong!
}
// Called when authentication completed successfully
override fun onSuccess(credentials: Credentials) {
// Get the access token from the credentials object.
// This can be used to call APIs
val accessToken = credentials.accessToken
}
})
}
private fun logout() {
WebAuthProvider.logout(account)
.withScheme("demo")
.start(this, object : Callback {
override fun onSuccess(payload: Void?) {
// The user has been logged out!
}
override fun onFailure(error: AuthenticationException) {
// Something went wrong!
}
})
}
private fun showUserProfile(accessToken: String) {
var client = AuthenticationAPIClient(account)
// With the access token, call `userInfo` and get the profile from Auth0.
client.userInfo(accessToken)
.start(object : Callback {
override fun onFailure(exception: AuthenticationException) {
// Something went wrong!
}
override fun onSuccess(profile: UserProfile) {
// We have the user's profile!
val email = profile.email
val name = profile.name
}
})
}
}
```
```xml strings.xml lines highlight={2-3} theme={null}
"{yourDomain}""{yourClientId}"
```
```gradle build.gradle lines highlight={18} theme={null}
apply plugin: 'com.android.application'
android {
defaultConfig {
applicationId "com.auth0.samples"
minSdkVersion 21
targetSdkVersion 30
// ...
// ---> Add the next line
manifestPlaceholders = [auth0Domain: "@string/com_auth0_domain", auth0Scheme: "demo"]
// <---
}
}
dependencies {
// Add the Auth0 Android SDK
implementation 'com.auth0.android:auth0:2.+'
}
```
```kt MainActivity.kt lines highlight={6-38} theme={null}
import com.auth0.android.Auth0
import com.auth0.android.provider.WebAuthProvider
class MainActivity : AppCompatActivity() {
private lateinit var account: Auth0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Set up the account object with the Auth0 application details
account = Auth0(
getString(R.string.com_auth0_client_id),
getString(R.string.com_auth0_domain),
)
}
private fun loginWithBrowser() {
// Setup the WebAuthProvider, using the custom scheme and scope.
WebAuthProvider.login(account)
.withScheme("demo")
.withScope("openid profile email")
// Launch the authentication passing the callback where the results will be received
.start(this, object : Callback {
// Called when there is an authentication failure
override fun onFailure(exception: AuthenticationException) {
// Something went wrong!
}
// Called when authentication completed successfully
override fun onSuccess(credentials: Credentials) {
// Get the access token from the credentials object.
// This can be used to call APIs
val accessToken = credentials.accessToken
}
})
}
private fun logout() {
WebAuthProvider.logout(account)
.withScheme("demo")
.start(this, object : Callback {
override fun onSuccess(payload: Void?) {
// The user has been logged out!
}
override fun onFailure(error: AuthenticationException) {
// Something went wrong!
}
})
}
private fun showUserProfile(accessToken: String) {
var client = AuthenticationAPIClient(account)
// With the access token, call `userInfo` and get the profile from Auth0.
client.userInfo(accessToken)
.start(object : Callback {
override fun onFailure(exception: AuthenticationException) {
// Something went wrong!
}
override fun onSuccess(profile: UserProfile) {
// We have the user's profile!
val email = profile.email
val name = profile.name
}
})
}
}
```
```kt MainActivity.kt lines highlight={6-38} theme={null}
import com.auth0.android.Auth0
import com.auth0.android.provider.WebAuthProvider
class MainActivity : AppCompatActivity() {
private lateinit var account: Auth0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Set up the account object with the Auth0 application details
account = Auth0(
getString(R.string.com_auth0_client_id),
getString(R.string.com_auth0_domain),
)
}
private fun loginWithBrowser() {
// Setup the WebAuthProvider, using the custom scheme and scope.
WebAuthProvider.login(account)
.withScheme("demo")
.withScope("openid profile email")
// Launch the authentication passing the callback where the results will be received
.start(this, object : Callback {
// Called when there is an authentication failure
override fun onFailure(exception: AuthenticationException) {
// Something went wrong!
}
// Called when authentication completed successfully
override fun onSuccess(credentials: Credentials) {
// Get the access token from the credentials object.
// This can be used to call APIs
val accessToken = credentials.accessToken
}
})
}
private fun logout() {
WebAuthProvider.logout(account)
.withScheme("demo")
.start(this, object : Callback {
override fun onSuccess(payload: Void?) {
// The user has been logged out!
}
override fun onFailure(error: AuthenticationException) {
// Something went wrong!
}
})
}
private fun showUserProfile(accessToken: String) {
var client = AuthenticationAPIClient(account)
// With the access token, call `userInfo` and get the profile from Auth0.
client.userInfo(accessToken)
.start(object : Callback {
override fun onFailure(exception: AuthenticationException) {
// Something went wrong!
}
override fun onSuccess(profile: UserProfile) {
// We have the user's profile!
val email = profile.email
val name = profile.name
}
})
}
}
```
```gradle build.gradle lines highlight={18} theme={null}
apply plugin: 'com.android.application'
android {
defaultConfig {
applicationId "com.auth0.samples"
minSdkVersion 21
targetSdkVersion 30
// ...
// ---> Add the next line
manifestPlaceholders = [auth0Domain: "@string/com_auth0_domain", auth0Scheme: "demo"]
// <---
}
}
dependencies {
// Add the Auth0 Android SDK
implementation 'com.auth0.android:auth0:2.+'
}
```
```xml strings.xml lines highlight={2-3} theme={null}
"{yourDomain}""{yourClientId}"
```
```kt MainActivity.kt lines highlight={40-52} theme={null}
import com.auth0.android.Auth0
import com.auth0.android.provider.WebAuthProvider
class MainActivity : AppCompatActivity() {
private lateinit var account: Auth0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Set up the account object with the Auth0 application details
account = Auth0(
getString(R.string.com_auth0_client_id),
getString(R.string.com_auth0_domain),
)
}
private fun loginWithBrowser() {
// Setup the WebAuthProvider, using the custom scheme and scope.
WebAuthProvider.login(account)
.withScheme("demo")
.withScope("openid profile email")
// Launch the authentication passing the callback where the results will be received
.start(this, object : Callback {
// Called when there is an authentication failure
override fun onFailure(exception: AuthenticationException) {
// Something went wrong!
}
// Called when authentication completed successfully
override fun onSuccess(credentials: Credentials) {
// Get the access token from the credentials object.
// This can be used to call APIs
val accessToken = credentials.accessToken
}
})
}
private fun logout() {
WebAuthProvider.logout(account)
.withScheme("demo")
.start(this, object : Callback {
override fun onSuccess(payload: Void?) {
// The user has been logged out!
}
override fun onFailure(error: AuthenticationException) {
// Something went wrong!
}
})
}
private fun showUserProfile(accessToken: String) {
var client = AuthenticationAPIClient(account)
// With the access token, call `userInfo` and get the profile from Auth0.
client.userInfo(accessToken)
.start(object : Callback {
override fun onFailure(exception: AuthenticationException) {
// Something went wrong!
}
override fun onSuccess(profile: UserProfile) {
// We have the user's profile!
val email = profile.email
val name = profile.name
}
})
}
}
```
```gradle build.gradle lines highlight={18} theme={null}
apply plugin: 'com.android.application'
android {
defaultConfig {
applicationId "com.auth0.samples"
minSdkVersion 21
targetSdkVersion 30
// ...
// ---> Add the next line
manifestPlaceholders = [auth0Domain: "@string/com_auth0_domain", auth0Scheme: "demo"]
// <---
}
}
dependencies {
// Add the Auth0 Android SDK
implementation 'com.auth0.android:auth0:2.+'
}
```
```xml strings.xml lines highlight={2-3} theme={null}
"{yourDomain}""{yourClientId}"
```
```kt MainActivity.kt lines highlight={54-70} theme={null}
import com.auth0.android.Auth0
import com.auth0.android.provider.WebAuthProvider
class MainActivity : AppCompatActivity() {
private lateinit var account: Auth0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Set up the account object with the Auth0 application details
account = Auth0(
getString(R.string.com_auth0_client_id),
getString(R.string.com_auth0_domain),
)
}
private fun loginWithBrowser() {
// Setup the WebAuthProvider, using the custom scheme and scope.
WebAuthProvider.login(account)
.withScheme("demo")
.withScope("openid profile email")
// Launch the authentication passing the callback where the results will be received
.start(this, object : Callback {
// Called when there is an authentication failure
override fun onFailure(exception: AuthenticationException) {
// Something went wrong!
}
// Called when authentication completed successfully
override fun onSuccess(credentials: Credentials) {
// Get the access token from the credentials object.
// This can be used to call APIs
val accessToken = credentials.accessToken
}
})
}
private fun logout() {
WebAuthProvider.logout(account)
.withScheme("demo")
.start(this, object : Callback {
override fun onSuccess(payload: Void?) {
// The user has been logged out!
}
override fun onFailure(error: AuthenticationException) {
// Something went wrong!
}
})
}
private fun showUserProfile(accessToken: String) {
var client = AuthenticationAPIClient(account)
// With the access token, call `userInfo` and get the profile from Auth0.
client.userInfo(accessToken)
.start(object : Callback {
override fun onFailure(exception: AuthenticationException) {
// Something went wrong!
}
override fun onSuccess(profile: UserProfile) {
// We have the user's profile!
val email = profile.email
val name = profile.name
}
})
}
}
```
```gradle build.gradle lines highlight={18} theme={null}
apply plugin: 'com.android.application'
android {
defaultConfig {
applicationId "com.auth0.samples"
minSdkVersion 21
targetSdkVersion 30
// ...
// ---> Add the next line
manifestPlaceholders = [auth0Domain: "@string/com_auth0_domain", auth0Scheme: "demo"]
// <---
}
}
dependencies {
// Add the Auth0 Android SDK
implementation 'com.auth0.android:auth0:2.+'
}
```
```xml strings.xml lines highlight={2-3} theme={null}
"{yourDomain}""{yourClientId}"
```
Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.