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: "configurations-requise",
title: "Configurations requise"
}, {
id: "avant-de-commencer",
title: "Avant de commencer"
}, {
id: "demande-d-autorisations-facebook",
title: "Demande d’autorisations Facebook"
}, {
id: "créer-la-méthode-performlogin",
title: "Créer la méthode performLogin"
}, {
id: "appeler-la-méthode-performlogin",
title: "Appeler la méthode performLogin"
}, {
id: "intégrer-facebook",
title: "Intégrer Facebook"
}, {
id: "récupérer-le-jeton-d-accès-à-la-session-facebook",
title: "Récupérer le jeton d’accès à la session Facebook"
}, {
id: "récupérer-le-profil-utilisateur-facebook",
title: "Récupérer le profil utilisateur Facebook"
}, {
id: "intégrer-auth0",
title: "Intégrer Auth0"
}, {
id: "échanger-les-données-reçues-contre-des-jetons-auth0",
title: "Échanger les données reçues contre des jetons Auth0"
}, {
id: "mettre-à-jour-la-méthode-performlogin",
title: "Mettre à jour la méthode performLogin"
}];
Ce tutoriel explique comment ajouter la connexion utilisateur à une application Android à l’aide de la méthode native Connexion Facebook. Nous vous recommandons de vous connecter pour suivre ce démarrage rapide avec les exemples configurés pour votre compte.
* Android Studio 3.6.1
* Trousse SDK Android 25
* Émulateur - Nexus 5X - Android 6.0
Ce tutoriel décrit comment mettre en œuvre la connexion avec la [trousse SDK Facebook](https://developers.facebook.com/docs/).
* Installez et configurez la [trousse SDK Connexion Facebook](https://developers.facebook.com/docs/facebook-login/). Vous découvrirez également le processus de création d’une application Facebook sur [https://developers.facebook.com](https://developers.facebook.com/). **À la fin de cette étape, vous devriez avoir une application mobile fonctionnant avec la fonction de connexion Facebook intégrée.**
Configurez votre application Auth0 dans le Dashboard pour utiliser la fonction Connexion Facebook en mode natif. Voir [Ajouter une connexion Facebook aux applications natives](https://auth0.com/docs/connections/nativesocial/facebook). **À la fin de cette étape, votre application sera en mesure d’implémenter la fonction Connexion Facebook en mode natif.**
Votre application est déjà capable de se connecter à Facebook. Cependant, pour garantir un profil utilisateur riche, vous devez mettre à jour les autorisations avec lesquelles le bouton de connexion Facebook a été configuré.
Définissez les autorisations demandées sur `public_profile` et `email`. De cette manière, l’adresse courriel de l’utilisateur sera également incluse dans la réponse, à condition que la demande d’accès soit acceptée par l’utilisateur.
`loginButton.setPermissions(Arrays.asList("public_profile", "email"));`
Maintenant, pour lancer le processus d’authentification avec Auth0, créez une nouvelle méthode où vous préparerez la charge utile à envoyer.
Vous utiliserez une interface simple pour gérer nos rappels internes.
Dans l’exemple, la méthode s’appelle `performLogin` et l’interface `SimpleCallback`. Ajoutez les deux.
Maintenant, appelez la méthode de la méthode `onSuccess` de rappel (Callback) de connexion Facebook.
Lorsque vous vous connectez à Facebook avec Auth0, le système dorsal effectue des vérifications en arrière-plan pour s’assurer que l’utilisateur est bien celui qu’il prétend être. Pour ce faire, il faut lui fournir un jeton d’accès à la session.
En outre, si un utilisateur doit être créé sur Auth0 pour représenter cet utilisateur Facebook, le système dorsal aura besoin de certaines de ses informations, comme le nom, le nom de famille et l’adresse électronique. L’adresse électronique, si elle est fournie, sera signalée comme non vérifiée dans le profil utilisateur Auth0.
Pour obtenir le jeton d’accès de session et le profil utilisateur, deux requêtes supplémentaires doivent être effectuées auprès de l’API Facebook.
Effectuez une nouvelle requête GET vers le point de terminaison `/oauth/access_token` de l’API Facebook. Utilisez les paramètres de requête suivants :
* `grant_type` : `fb_attenuate_token`.
* `fb_exchange_token` : le jeton d’accès reçu lors de la connexion.
* `client_id` : l’identifiant de votre application. Cette valeur provient du tableau de bord du développeur Facebook et devrait déjà être utilisée dans votre application si vous avez réussi à intégrer la connexion Facebook.
Placez la logique de cette étape dans sa propre méthode. Vous effectuerez cet appel plus tard, à partir de la méthode ajoutée précédemment.
L’exemple utilise la classe `GraphRequest` de la trousse SDK Facebook pour effectuer cette demande.
Effectuez à présent une autre demande GET, comme dans l’étape précédente. Le chemin du point de terminaison correspondra à la valeur de l’identificateur de l’utilisateur figurant dans le résultat de la connexion Facebook (p. ex., `/904636746222815`). Utilisez les paramètres suivants :
* `access_token` : le jeton d’accès reçu lors de la connexion.
* `fields` : les champs du profil utilisateur que vous souhaitez récupérer dans la réponse. Ces champs sont directement liés aux autorisations du bouton de connexion Facebook qui ont été configurées au début. Lorsqu’une autorisation est facultative, l’utilisateur doit d’abord consentir à y donner accès. Pour inscrire un utilisateur à Auth0, le nom complet et l’adresse électronique suffisent.
Maintenant que les artefacts requis ont été obtenus, vous êtes prêt à les échanger contre les identifiants utilisateur Auth0, comme l’identifiant et les jetons d’accès. Mais d’abord, vous devez configurer la trousse SDK Auth0 pour qu’il effectue cette dernière demande.
### Obtenir les clés de votre application
1. Allez dans la section **Applications** de [Auth0 Dashboard](https://manage.auth0.com/) et sélectionnez l’application existante dans laquelle vous avez activé la fonction **Sign in with Facebook (Se connecter avec Facebook)**. Si vous avez besoin d’aide pour cette étape, veuillez consulter la section des exigences en haut de cet article.
2. Copiez les valeurs **Domaine** et **Identifiant client** de la page des paramètres de l’application. Ces valeurs sont requises par la trousse SDK.
3. Créez deux nouvelles ressources dans le fichier strings.xml de votre application Android pour les stocker. Les noms des clés doivent correspondre à ceux utilisés ci-dessous :
```
{yourDomain}{yourClientId}
```
### Installer la trousse SDK Auth0
Dans votre application Android, ajoutez cette ligne au fichier app/build.gradle :
```
dependencies {
implementation 'com.auth0.android:auth0:1.+'
}
```
Il est maintenant temps d’exécuter la tâche Gradle Sync pour actualiser le projet et ses dépendances.
### Mise à jour du manifeste pour l’authentification Web
Si votre application ne prévoit pas d’utiliser le module d’authentification Web fourni par la trousse SDK, vous devrez supprimer l’activité inutilisée du fichier AndroidManifest.xml pour éviter les problèmes liés au placeholder du manifeste. Pour ce faire, il suffit d’ajouter une déclaration d’activité et de l’annoter avec tools:node="remove".
```html theme={null}
```
Toutefois, si vous envisagez de prendre en charge l’authentification Web, rendez-vous [ici](https://auth0.com/docs/libraries/auth0-android#authentication-via-universal-login) pour savoir comment déclarer les placeholder du manifeste.
Vous devez instancier la trousse SDK avant de l’utiliser. Définissez un champ au niveau de la classe et initialisez-le dans la méthode `onCreate`. Remarque : Les identifiants définis à l’étape précédente sont transmis au développeur `Auth0` et une nouvelle instance de `AuthenticationAPIClient` est créée avec lui.
```
private AuthenticationAPIClient auth0Client;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_login);
Auth0 account = new Auth0(getString(R.string.com_auth0_client_id), getString(R.string.com_auth0_domain));
auth0Client = new AuthenticationAPIClient(account);
//...
}
```
Créez la méthode qui contiendra la logique d’échange des deux artefacts obtenus contre les identifiants de l’utilisateur Auth0. Dans l’exemple, cette méthode s’appelle `exchangeTokens`.
Le client de l’API déclare la méthode `loginWithNativeSocialToken` qui reçoit un jeton et un type de sujet. Le premier correspond au jeton de session et le second indique le type de connexion avec lequel le système dorsal tentera de s’authentifier.
Pour la fonction native Connexion Facebook, vous devez utiliser la valeur suivante : `"http://auth0.com/oauth/token-type/facebook-info-session-access-token"`
Les autres valeurs à configurer sont le profil utilisateur (en utilisant la clé `user_profile`) et la permission que vous demandez aux jetons Auth0 de contenir.
Nous recommandons de conserver toutes les valeurs immuables en tant que constantes au début de la classe. L’exemple utilise des constantes pour le type de jeton sujet, les permissions Facebook et les permissions Auth0. Pour en savoir plus sur les permissions Auth0, lisez cet article.
Maintenant que chaque étape est définie dans sa propre méthode, il est temps de tout regrouper dans la méthode `performLogin`.
Si tout a bien fonctionné, vous devriez maintenant être en mesure de vous authentifier de manière native avec la trousse SDK de connexion à Facebook. Cela signifie que si l’application Facebook est installée sur l’appareil, l’authentification sera gérée par l’application et non par une application de navigateur.
## É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
* [Auth0 Marketplace](https://marketplace.auth0.com/) : découvrez des intégrations que vous pouvez activer pour étendre les fonctionnalités d’Auth0
```kt performLogin+SimpleCallback lines theme={null}
private fun performLogin(accessToken: AccessToken) {
// TODO
}
private interface SimpleCallback {
fun onResult(result: T)
fun onError(cause: Throwable)
}
```
```kt onCreate lines theme={null}
private lateinit var fbCallbackManager: CallbackManager
private val account: Auth0 by lazy {
// -- REPLACE this credentials with your own Auth0 app credentials!
val account = Auth0.getInstance(
getString(R.string.com_auth0_client_id),
getString(R.string.com_auth0_domain)
)
// Only enable network traffic logging on production environments!
account.networkingClient = DefaultClient(enableLogging = true)
account
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_login)
fbCallbackManager = CallbackManager.Factory.create()
val loginButton = findViewById(R.id.login_button)
loginButton.setPermissions("email", "public_profile")
loginButton.registerCallback(fbCallbackManager,
object : FacebookCallback {
override fun onSuccess(result: LoginResult) {
val accessToken = result.accessToken
performLogin(accessToken)
}
override fun onCancel() {
//User closed the dialog. Safe to ignore
}
override fun onError(error: FacebookException) {
//Handle Facebook authentication error
}
})
}
```
```kt fetchSessionToken lines theme={null}
private fun fetchSessionToken(accessToken: AccessToken, callback: SimpleCallback) {
val request = GraphRequest()
request.graphPath = "oauth/access_token"
val bundle = Bundle()
bundle.putString("grant_type", "fb_attenuate_token")
bundle.putString("client_id", getString(R.string.facebook_app_id))
bundle.putString("fb_exchange_token", accessToken.token)
request.parameters = bundle
request.callback = GraphRequest.Callback { response ->
if (response.error != null) {
//Failed to fetch session token
response.error?.exception?.let {
callback.onError(it)
}
} else {
response.jsonObject?.let { callback.onResult(it.getString("access_token")) }
}
}
request.executeAsync()
}
```
```kt fetchUserProfile lines theme={null}
private fun fetchUserProfile(
accessToken: AccessToken,
callback: SimpleCallback
) {
val request = GraphRequest.newMeRequest(accessToken) { _, response ->
val error = response?.error
if (error != null) {
// Failed to fetch user profile
error.exception?.let {
callback.onError(it)
}
} else {
callback.onResult(response?.rawResponse.toString())
}
}
val bundle = Bundle()
bundle.putString("fields", "first_name,last_name,email")
request.parameters = bundle
request.executeAsync()
}
```
```kt exchangeTokens lines theme={null}
private fun exchangeTokens(
sessionToken: String,
userProfile: String,
callback: SimpleCallback
) {
authenticationApiClient
.loginWithNativeSocialToken(sessionToken, "http://auth0.com/oauth/token-type/facebook-info-session-access-token")
.setScope("openid profile email offline_access")
.addParameter(name = "user_profile", value = userProfile)
.start(object : Callback {
override fun onSuccess(result: Credentials) {
callback.onResult(result)
}
override fun onFailure(error: AuthenticationException) {
callback.onError(error)
}
})
}
```
```kt performLogin lines theme={null}
fun performLogin(accessToken: AccessToken) {
fetchSessionToken(accessToken, object : SimpleCallback {
override fun onResult(sessionToken: String) {
fetchUserProfile(accessToken, object : SimpleCallback {
override fun onResult(result: String) {
exchangeTokens(sessionToken, result, object : SimpleCallback {
override fun onResult(result: Credentials) {
/*
* 4. Logged in!
* Use access token to call API
* or consume ID token locally
*/
}
override fun onError(cause: Throwable) {
//Handle token exchange error
}
})
}
override fun onError(cause: Throwable) {
//Handle profile request error
}
})
}
override fun onError(cause: Throwable) {
//Handle session token request error
}
})
}
```
```kt onCreate lines theme={null}
private lateinit var fbCallbackManager: CallbackManager
private val account: Auth0 by lazy {
// -- REPLACE this credentials with your own Auth0 app credentials!
val account = Auth0.getInstance(
getString(R.string.com_auth0_client_id),
getString(R.string.com_auth0_domain)
)
// Only enable network traffic logging on production environments!
account.networkingClient = DefaultClient(enableLogging = true)
account
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_login)
fbCallbackManager = CallbackManager.Factory.create()
val loginButton = findViewById(R.id.login_button)
loginButton.setPermissions("email", "public_profile")
loginButton.registerCallback(fbCallbackManager,
object : FacebookCallback {
override fun onSuccess(result: LoginResult) {
val accessToken = result.accessToken
performLogin(accessToken)
}
override fun onCancel() {
//User closed the dialog. Safe to ignore
}
override fun onError(error: FacebookException) {
//Handle Facebook authentication error
}
})
}
```
```kt performLogin+SimpleCallback lines theme={null}
private fun performLogin(accessToken: AccessToken) {
// TODO
}
private interface SimpleCallback {
fun onResult(result: T)
fun onError(cause: Throwable)
}
```
```kt fetchSessionToken lines theme={null}
private fun fetchSessionToken(accessToken: AccessToken, callback: SimpleCallback) {
val request = GraphRequest()
request.graphPath = "oauth/access_token"
val bundle = Bundle()
bundle.putString("grant_type", "fb_attenuate_token")
bundle.putString("client_id", getString(R.string.facebook_app_id))
bundle.putString("fb_exchange_token", accessToken.token)
request.parameters = bundle
request.callback = GraphRequest.Callback { response ->
if (response.error != null) {
//Failed to fetch session token
response.error?.exception?.let {
callback.onError(it)
}
} else {
response.jsonObject?.let { callback.onResult(it.getString("access_token")) }
}
}
request.executeAsync()
}
```
```kt fetchUserProfile lines theme={null}
private fun fetchUserProfile(
accessToken: AccessToken,
callback: SimpleCallback
) {
val request = GraphRequest.newMeRequest(accessToken) { _, response ->
val error = response?.error
if (error != null) {
// Failed to fetch user profile
error.exception?.let {
callback.onError(it)
}
} else {
callback.onResult(response?.rawResponse.toString())
}
}
val bundle = Bundle()
bundle.putString("fields", "first_name,last_name,email")
request.parameters = bundle
request.executeAsync()
}
```
```kt exchangeTokens lines theme={null}
private fun exchangeTokens(
sessionToken: String,
userProfile: String,
callback: SimpleCallback
) {
authenticationApiClient
.loginWithNativeSocialToken(sessionToken, "http://auth0.com/oauth/token-type/facebook-info-session-access-token")
.setScope("openid profile email offline_access")
.addParameter(name = "user_profile", value = userProfile)
.start(object : Callback {
override fun onSuccess(result: Credentials) {
callback.onResult(result)
}
override fun onFailure(error: AuthenticationException) {
callback.onError(error)
}
})
}
```
```kt performLogin lines theme={null}
fun performLogin(accessToken: AccessToken) {
fetchSessionToken(accessToken, object : SimpleCallback {
override fun onResult(sessionToken: String) {
fetchUserProfile(accessToken, object : SimpleCallback {
override fun onResult(result: String) {
exchangeTokens(sessionToken, result, object : SimpleCallback {
override fun onResult(result: Credentials) {
/*
* 4. Logged in!
* Use access token to call API
* or consume ID token locally
*/
}
override fun onError(cause: Throwable) {
//Handle token exchange error
}
})
}
override fun onError(cause: Throwable) {
//Handle profile request error
}
})
}
override fun onError(cause: Throwable) {
//Handle session token request error
}
})
}
```
```kt onCreate lines theme={null}
private lateinit var fbCallbackManager: CallbackManager
private val account: Auth0 by lazy {
// -- REPLACE this credentials with your own Auth0 app credentials!
val account = Auth0.getInstance(
getString(R.string.com_auth0_client_id),
getString(R.string.com_auth0_domain)
)
// Only enable network traffic logging on production environments!
account.networkingClient = DefaultClient(enableLogging = true)
account
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_login)
fbCallbackManager = CallbackManager.Factory.create()
val loginButton = findViewById(R.id.login_button)
loginButton.setPermissions("email", "public_profile")
loginButton.registerCallback(fbCallbackManager,
object : FacebookCallback {
override fun onSuccess(result: LoginResult) {
val accessToken = result.accessToken
performLogin(accessToken)
}
override fun onCancel() {
//User closed the dialog. Safe to ignore
}
override fun onError(error: FacebookException) {
//Handle Facebook authentication error
}
})
}
```
```kt performLogin+SimpleCallback lines theme={null}
private fun performLogin(accessToken: AccessToken) {
// TODO
}
private interface SimpleCallback {
fun onResult(result: T)
fun onError(cause: Throwable)
}
```
```kt fetchSessionToken lines theme={null}
private fun fetchSessionToken(accessToken: AccessToken, callback: SimpleCallback) {
val request = GraphRequest()
request.graphPath = "oauth/access_token"
val bundle = Bundle()
bundle.putString("grant_type", "fb_attenuate_token")
bundle.putString("client_id", getString(R.string.facebook_app_id))
bundle.putString("fb_exchange_token", accessToken.token)
request.parameters = bundle
request.callback = GraphRequest.Callback { response ->
if (response.error != null) {
//Failed to fetch session token
response.error?.exception?.let {
callback.onError(it)
}
} else {
response.jsonObject?.let { callback.onResult(it.getString("access_token")) }
}
}
request.executeAsync()
}
```
```kt fetchUserProfile lines theme={null}
private fun fetchUserProfile(
accessToken: AccessToken,
callback: SimpleCallback
) {
val request = GraphRequest.newMeRequest(accessToken) { _, response ->
val error = response?.error
if (error != null) {
// Failed to fetch user profile
error.exception?.let {
callback.onError(it)
}
} else {
callback.onResult(response?.rawResponse.toString())
}
}
val bundle = Bundle()
bundle.putString("fields", "first_name,last_name,email")
request.parameters = bundle
request.executeAsync()
}
```
```kt exchangeTokens lines theme={null}
private fun exchangeTokens(
sessionToken: String,
userProfile: String,
callback: SimpleCallback
) {
authenticationApiClient
.loginWithNativeSocialToken(sessionToken, "http://auth0.com/oauth/token-type/facebook-info-session-access-token")
.setScope("openid profile email offline_access")
.addParameter(name = "user_profile", value = userProfile)
.start(object : Callback {
override fun onSuccess(result: Credentials) {
callback.onResult(result)
}
override fun onFailure(error: AuthenticationException) {
callback.onError(error)
}
})
}
```
```kt performLogin lines theme={null}
fun performLogin(accessToken: AccessToken) {
fetchSessionToken(accessToken, object : SimpleCallback {
override fun onResult(sessionToken: String) {
fetchUserProfile(accessToken, object : SimpleCallback {
override fun onResult(result: String) {
exchangeTokens(sessionToken, result, object : SimpleCallback {
override fun onResult(result: Credentials) {
/*
* 4. Logged in!
* Use access token to call API
* or consume ID token locally
*/
}
override fun onError(cause: Throwable) {
//Handle token exchange error
}
})
}
override fun onError(cause: Throwable) {
//Handle profile request error
}
})
}
override fun onError(cause: Throwable) {
//Handle session token request error
}
})
}
```
```kt fetchUserProfile lines theme={null}
private fun fetchUserProfile(
accessToken: AccessToken,
callback: SimpleCallback
) {
val request = GraphRequest.newMeRequest(accessToken) { _, response ->
val error = response?.error
if (error != null) {
// Failed to fetch user profile
error.exception?.let {
callback.onError(it)
}
} else {
callback.onResult(response?.rawResponse.toString())
}
}
val bundle = Bundle()
bundle.putString("fields", "first_name,last_name,email")
request.parameters = bundle
request.executeAsync()
}
```
```kt performLogin+SimpleCallback lines theme={null}
private fun performLogin(accessToken: AccessToken) {
// TODO
}
private interface SimpleCallback {
fun onResult(result: T)
fun onError(cause: Throwable)
}
```
```kt onCreate lines theme={null}
private lateinit var fbCallbackManager: CallbackManager
private val account: Auth0 by lazy {
// -- REPLACE this credentials with your own Auth0 app credentials!
val account = Auth0.getInstance(
getString(R.string.com_auth0_client_id),
getString(R.string.com_auth0_domain)
)
// Only enable network traffic logging on production environments!
account.networkingClient = DefaultClient(enableLogging = true)
account
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_login)
fbCallbackManager = CallbackManager.Factory.create()
val loginButton = findViewById(R.id.login_button)
loginButton.setPermissions("email", "public_profile")
loginButton.registerCallback(fbCallbackManager,
object : FacebookCallback {
override fun onSuccess(result: LoginResult) {
val accessToken = result.accessToken
performLogin(accessToken)
}
override fun onCancel() {
//User closed the dialog. Safe to ignore
}
override fun onError(error: FacebookException) {
//Handle Facebook authentication error
}
})
}
```
```kt fetchSessionToken lines theme={null}
private fun fetchSessionToken(accessToken: AccessToken, callback: SimpleCallback) {
val request = GraphRequest()
request.graphPath = "oauth/access_token"
val bundle = Bundle()
bundle.putString("grant_type", "fb_attenuate_token")
bundle.putString("client_id", getString(R.string.facebook_app_id))
bundle.putString("fb_exchange_token", accessToken.token)
request.parameters = bundle
request.callback = GraphRequest.Callback { response ->
if (response.error != null) {
//Failed to fetch session token
response.error?.exception?.let {
callback.onError(it)
}
} else {
response.jsonObject?.let { callback.onResult(it.getString("access_token")) }
}
}
request.executeAsync()
}
```
```kt exchangeTokens lines theme={null}
private fun exchangeTokens(
sessionToken: String,
userProfile: String,
callback: SimpleCallback
) {
authenticationApiClient
.loginWithNativeSocialToken(sessionToken, "http://auth0.com/oauth/token-type/facebook-info-session-access-token")
.setScope("openid profile email offline_access")
.addParameter(name = "user_profile", value = userProfile)
.start(object : Callback {
override fun onSuccess(result: Credentials) {
callback.onResult(result)
}
override fun onFailure(error: AuthenticationException) {
callback.onError(error)
}
})
}
```
```kt performLogin lines theme={null}
fun performLogin(accessToken: AccessToken) {
fetchSessionToken(accessToken, object : SimpleCallback {
override fun onResult(sessionToken: String) {
fetchUserProfile(accessToken, object : SimpleCallback {
override fun onResult(result: String) {
exchangeTokens(sessionToken, result, object : SimpleCallback {
override fun onResult(result: Credentials) {
/*
* 4. Logged in!
* Use access token to call API
* or consume ID token locally
*/
}
override fun onError(cause: Throwable) {
//Handle token exchange error
}
})
}
override fun onError(cause: Throwable) {
//Handle profile request error
}
})
}
override fun onError(cause: Throwable) {
//Handle session token request error
}
})
}
```
```kt performLogin lines theme={null}
fun performLogin(accessToken: AccessToken) {
fetchSessionToken(accessToken, object : SimpleCallback {
override fun onResult(sessionToken: String) {
fetchUserProfile(accessToken, object : SimpleCallback {
override fun onResult(result: String) {
exchangeTokens(sessionToken, result, object : SimpleCallback {
override fun onResult(result: Credentials) {
/*
* 4. Logged in!
* Use access token to call API
* or consume ID token locally
*/
}
override fun onError(cause: Throwable) {
//Handle token exchange error
}
})
}
override fun onError(cause: Throwable) {
//Handle profile request error
}
})
}
override fun onError(cause: Throwable) {
//Handle session token request error
}
})
}
```
```kt performLogin+SimpleCallback lines theme={null}
private fun performLogin(accessToken: AccessToken) {
// TODO
}
private interface SimpleCallback {
fun onResult(result: T)
fun onError(cause: Throwable)
}
```
```kt onCreate lines theme={null}
private lateinit var fbCallbackManager: CallbackManager
private val account: Auth0 by lazy {
// -- REPLACE this credentials with your own Auth0 app credentials!
val account = Auth0.getInstance(
getString(R.string.com_auth0_client_id),
getString(R.string.com_auth0_domain)
)
// Only enable network traffic logging on production environments!
account.networkingClient = DefaultClient(enableLogging = true)
account
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_login)
fbCallbackManager = CallbackManager.Factory.create()
val loginButton = findViewById(R.id.login_button)
loginButton.setPermissions("email", "public_profile")
loginButton.registerCallback(fbCallbackManager,
object : FacebookCallback {
override fun onSuccess(result: LoginResult) {
val accessToken = result.accessToken
performLogin(accessToken)
}
override fun onCancel() {
//User closed the dialog. Safe to ignore
}
override fun onError(error: FacebookException) {
//Handle Facebook authentication error
}
})
}
```
```kt fetchSessionToken lines theme={null}
private fun fetchSessionToken(accessToken: AccessToken, callback: SimpleCallback) {
val request = GraphRequest()
request.graphPath = "oauth/access_token"
val bundle = Bundle()
bundle.putString("grant_type", "fb_attenuate_token")
bundle.putString("client_id", getString(R.string.facebook_app_id))
bundle.putString("fb_exchange_token", accessToken.token)
request.parameters = bundle
request.callback = GraphRequest.Callback { response ->
if (response.error != null) {
//Failed to fetch session token
response.error?.exception?.let {
callback.onError(it)
}
} else {
response.jsonObject?.let { callback.onResult(it.getString("access_token")) }
}
}
request.executeAsync()
}
```
```kt fetchUserProfile lines theme={null}
private fun fetchUserProfile(
accessToken: AccessToken,
callback: SimpleCallback
) {
val request = GraphRequest.newMeRequest(accessToken) { _, response ->
val error = response?.error
if (error != null) {
// Failed to fetch user profile
error.exception?.let {
callback.onError(it)
}
} else {
callback.onResult(response?.rawResponse.toString())
}
}
val bundle = Bundle()
bundle.putString("fields", "first_name,last_name,email")
request.parameters = bundle
request.executeAsync()
}
```
```kt exchangeTokens lines theme={null}
private fun exchangeTokens(
sessionToken: String,
userProfile: String,
callback: SimpleCallback
) {
authenticationApiClient
.loginWithNativeSocialToken(sessionToken, "http://auth0.com/oauth/token-type/facebook-info-session-access-token")
.setScope("openid profile email offline_access")
.addParameter(name = "user_profile", value = userProfile)
.start(object : Callback {
override fun onSuccess(result: Credentials) {
callback.onResult(result)
}
override fun onFailure(error: AuthenticationException) {
callback.onError(error)
}
})
}
```
Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.