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: "system-requirements",
title: "System requirements"
}, {
id: "before-you-start",
title: "Before You Start"
}, {
id: "request-facebook-permissions",
title: "Request Facebook permissions"
}, {
id: "create-performlogin-method",
title: "Create performLogin method"
}, {
id: "call-performlogin-method",
title: "Call performLogin method"
}, {
id: "integrate-facebook",
title: "Integrate Facebook"
}, {
id: "fetch-facebook-session-access-token",
title: "Fetch Facebook session Access Token"
}, {
id: "fetch-facebook-user-profile",
title: "Fetch Facebook user profile"
}, {
id: "integrate-auth0",
title: "Integrate Auth0"
}, {
id: "exchange-the-received-data-for-auth0-tokens",
title: "Exchange the received data for Auth0 tokens"
}, {
id: "update-performlogin-method",
title: "Update performLogin method"
}];
This tutorial demonstrates how to add user login to an Android application using native Facebook Login. We
recommend that you log in to follow this quickstart with examples configured for your account.
* Android Studio 3.6.1
* Android SDK 25
* Emulator - Nexus 5X - Android 6.0
This tutorial describes how to implement login with the [Facebook SDK](https://developers.facebook.com/docs/).
* Install and configure the [Facebook Login SDK](https://developers.facebook.com/docs/facebook-login/). You’ll also go through the process of creating a Facebook
app in [https://developers.facebook.com](https://developers.facebook.com/). **When you finish this step, you should have
a mobile app running with Facebook Login integrated.**
Configure your Auth0 application in the dashboard to use Facebook Native Sign In. See [Add Facebook Login to Native
Apps](https://auth0.com/docs/connections/nativesocial/facebook). **When you finish this step, your application will be able to implement Facebook Native Login.**
Your application is already able to sign in with Facebook. However, to ensure you have a rich user profile, you
need to update the permissions with which the Facebook Login Button was set up.
Set the requested permissions to `public_profile` and `email`. This way, the user email
will also be included as part of the response, provided the access request is accepted by the user.
```kt lines
loginButton.setPermissions(Arrays.asList("public_profile", "email"));
```
Now, to kick off the authentication process with Auth0, create a new method in which you will prepare the payload
to be sent.
You will make use of a small interface to handle our internal callbacks.
In the sample, the method was named `performLogin` and the interface `SimpleCallback`. Go
ahead and add both.
Now, call the method from the Facebook login callback's `onSuccess` method.
When you sign in with Facebook at Auth0, the backend will perform some checks in the background to ensure the
user is who they say they are. To achieve this, it needs to be provided with a Session Access Token.
Furthermore, if a user needs to be created on Auth0 to represent this Facebook user, the backend will require
some of their information, such as their name, last name, and email. The email, if provided, will be flagged as
non-verified on the Auth0 user profile.
To obtain the Session Access Token and the user profile, two additional requests need to be made against the
Facebook API.
Make a new GET request against the Facebook API's `/oauth/access_token` endpoint. Use the following
query parameters:
* `grant_type`: `fb_attenuate_token`.
* `fb_exchange_token`: the access token received upon login.
* `client_id`: your App ID. This value comes from the Facebook Developer's dashboard and should
already be in use in your application if you have integrated Facebook Login successfully.
Put the logic from this step in its own method. You will be calling it later from the previously-added method.
The sample uses the Facebook SDK's `GraphRequest` class to perform this request.
Now make another GET request, just like in the step above. The endpoint path will be the User ID value from the
Facebook login result (for example, `/904636746222815`). Use the following parameters:
* `access_token`: the access token received upon login.
* `fields`: the fields from the user profile that you'd like to get back in the response. These are
directly tied to the Facebook Login Button permissions that were configured at the beginning. When a
permission is optional, the user must first consent to give access to it. For the purpose of signing up a user
at Auth0, their full name and email will suffice.
Now that the required artifacts have been obtained, you are ready to trade them for Auth0 user credentials, such
as the ID and Access Tokens. But first, you must set up the Auth0 SDK to make that last request.
### Get your application keys
1. Go to the **Applications** section of the [Auth0 Dashboard](https://manage.auth0.com/) and select the existing application in which you enabled
**Sign in with Facebook**. If you need help with this step, please check the requirements section at the
top of this article.
2. Copy the **Domain** and **Client ID** values from the application settings page. These are required by
the SDK.
3. Create two new resources in your Android application's strings.xml file to store them. The name of the keys
must match the ones used below:
```xml lines
dev-gja8kxz4ndtex3rq.us.auth0.commz9iNEIo2PHu7oeh8QRt19ndTyyCIgai
```
### Install the Auth0 SDK
In your Android application, add this line to the app/build.gradle file:
```text lines
dependencies {
implementation 'com.auth0.android:auth0:1.+'
}
```
Now is time to run the Gradle Sync task to refresh the project and its dependencies.
### Update manifest for web authentication
If your application does not plan to make use of the Web Authentication module provided by the SDK, you will need
to remove the unused activity from the AndroidManifest.xml file to prevent Manifest Placeholder issues. This can
be achieved by adding an activity declaration and annotating it with tools:node="remove".
```xml lines
```
However, if you do plan to support Web Authentication, head over [here](https://auth0.com/docs/libraries/auth0-android#authentication-via-universal-login) to learn how to declare the Manifest Placeholders.
The SDK must be instantiated before use. Define a field at the class level and initialize it on the
`onCreate` method. Note how the credentials defined in the step above are passed to the
`Auth0` constructor and then a new instance of the `AuthenticationAPIClient` is created with
it.
```kt lines
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);
//...
}
```
Create the method that will hold the logic to exchange the two obtained artifacts for Auth0 user credentials. In
the sample, this method is named `exchangeTokens`.
The API client declares the method `loginWithNativeSocialToken` that receives a token and a subject
type. The former corresponds to the session token, and the latter indicates what type of connection the backend
will attempt to authenticate with.
For native Facebook Login, you will use the following value:
`"http://auth0.com/oauth/token-type/facebook-info-session-access-token"`
Other values that need to be configured are the user profile (using the `user_profile` key) and the
scope you request the Auth0 tokens contain.
It's a good practice to keep all the values that you know won't change as constants at the top of the
class. The sample makes use of constants for the subject token type, the Facebook permissions, and the
Auth0 scopes. You can read more about Auth0 scopes in the dedicated article.
Now that every step is defined in its own method, it's time to put everything together inside the
`performLogin` method.
If everything went well, you should now be able to authenticate natively with the Facebook Login SDK. This means
that if the Facebook app is installed on the device, the authentication will be handled via the application and
not a browser app.
```kt performLogin+SimpleCallback lines
private interface SimpleCallback {
fun onResult(result: T)
fun onError(cause: Throwable)
}
```
```kt onCreate lines
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
FacebookSdk.setClientToken(getString(R.string.facebook_client_token))
FacebookSdk.sdkInitialize(this)
setContentView(R.layout.activity_login)
val auth0 =
Auth0(getString(R.string.com_auth0_client_id), getString(R.string.com_auth0_domain))
apiClient = AuthenticationAPIClient(auth0)
fbCallbackManager = CallbackManager.Factory.create()
val loginButton = findViewById(R.id.login_button).apply {
setPermissions(*FACEBOOK_PERMISSIONS)
}
loginButton.registerCallback(fbCallbackManager, object : FacebookCallback {
override fun onSuccess(result: LoginResult) {
val accessToken = result.accessToken
performLogin(accessToken)
}
override fun onCancel() {
Log.i(TAG, "Facebook sign-in cancelled")
}
override fun onError(error: FacebookException) {
Log.e(TAG, "Error {error.message}")
}
})
}
```
```kt fetchSessionToken lines
private fun fetchSessionToken(token: String, callback: SimpleCallback) {
val params = Bundle().apply {
putString("grant_type", "fb_attenuate_token")
putString("fb_exchange_token", token)
putString("client_id", getString(R.string.facebook_app_id))
}
val request = GraphRequest().apply {
parameters = params
graphPath = "oauth/access_token"
}
request.callback = GraphRequest.Callback { response ->
if (response.error != null) {
callback.onError(response.error?.exception!!)
return@Callback
}
try {
val fbSessionToken = response.jsonObject!!.getString("access_token")
callback.onResult(fbSessionToken)
} catch (jsonException: JSONException) {
//Failed to parse session token
callback.onError(jsonException)
}
}
request.executeAsync()
}
```
```kt fetchUserProfile lines
private fun fetchUserProfile(token: String, userId: String, callback: SimpleCallback) {
val params = Bundle().apply {
putString("access_token", token)
putString("fields", "first_name,last_name,email")
}
val request = GraphRequest().apply {
parameters = params
graphPath = userId
}
request.callback = GraphRequest.Callback { response ->
val error = response.error
if (error != null) {
//Failed to fetch user profile
callback.onError(error.exception!!)
return@Callback
}
//Handle back the profile as received
callback.onResult(response.rawResponse!!)
}
request.executeAsync()
}
```
```kt exchangeTokens lines
private fun exchangeTokens(
sessionToken: String,
userProfile: String,
callback: SimpleCallback
) {
val params = mapOf("user_profile" to userProfile)
apiClient.loginWithNativeSocialToken(sessionToken, FACEBOOK_SUBJECT_TOKEN_TYPE)
.setScope(AUTH0_SCOPE)
.addParameters(params)
.start(object : Callback {
override fun onFailure(error: AuthenticationException) {
callback.onError(error)
}
override fun onSuccess(result: Credentials) {
callback.onResult(result)
}
})
}
```
```kt performLogin lines
private fun performLogin(accessToken: AccessToken) {
val token = accessToken.token
fetchSessionToken(token, object : SimpleCallback {
override fun onResult(sessionToken: String) {
//2. Obtained the Facebook session token
fetchUserProfile(token, accessToken.userId, object : SimpleCallback {
override fun onResult(userProfile: String) {
//3. Obtained the user profile
exchangeTokens(
sessionToken,
userProfile,
object : SimpleCallback {
override fun onResult(credentials: Credentials) {
//4. Exchanged the tokens
Log.i(TAG, "Logged in to Auth0")
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error exchanging tokens", cause)
}
})
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error fetching the profile", cause)
}
})
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error fetching the session token", cause)
}
})
}
```
```kt onCreate lines
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
FacebookSdk.setClientToken(getString(R.string.facebook_client_token))
FacebookSdk.sdkInitialize(this)
setContentView(R.layout.activity_login)
val auth0 =
Auth0(getString(R.string.com_auth0_client_id), getString(R.string.com_auth0_domain))
apiClient = AuthenticationAPIClient(auth0)
fbCallbackManager = CallbackManager.Factory.create()
val loginButton = findViewById(R.id.login_button).apply {
setPermissions(*FACEBOOK_PERMISSIONS)
}
loginButton.registerCallback(fbCallbackManager, object : FacebookCallback {
override fun onSuccess(result: LoginResult) {
val accessToken = result.accessToken
performLogin(accessToken)
}
override fun onCancel() {
Log.i(TAG, "Facebook sign-in cancelled")
}
override fun onError(error: FacebookException) {
Log.e(TAG, "Error {error.message}")
}
})
}
```
```kt performLogin+SimpleCallback lines
private interface SimpleCallback {
fun onResult(result: T)
fun onError(cause: Throwable)
}
```
```kt fetchSessionToken lines
private fun fetchSessionToken(token: String, callback: SimpleCallback) {
val params = Bundle().apply {
putString("grant_type", "fb_attenuate_token")
putString("fb_exchange_token", token)
putString("client_id", getString(R.string.facebook_app_id))
}
val request = GraphRequest().apply {
parameters = params
graphPath = "oauth/access_token"
}
request.callback = GraphRequest.Callback { response ->
if (response.error != null) {
callback.onError(response.error?.exception!!)
return@Callback
}
try {
val fbSessionToken = response.jsonObject!!.getString("access_token")
callback.onResult(fbSessionToken)
} catch (jsonException: JSONException) {
//Failed to parse session token
callback.onError(jsonException)
}
}
request.executeAsync()
}
```
```kt fetchUserProfile lines
private fun fetchUserProfile(token: String, userId: String, callback: SimpleCallback) {
val params = Bundle().apply {
putString("access_token", token)
putString("fields", "first_name,last_name,email")
}
val request = GraphRequest().apply {
parameters = params
graphPath = userId
}
request.callback = GraphRequest.Callback { response ->
val error = response.error
if (error != null) {
//Failed to fetch user profile
callback.onError(error.exception!!)
return@Callback
}
//Handle back the profile as received
callback.onResult(response.rawResponse!!)
}
request.executeAsync()
}
```
```kt exchangeTokens lines
private fun exchangeTokens(
sessionToken: String,
userProfile: String,
callback: SimpleCallback
) {
val params = mapOf("user_profile" to userProfile)
apiClient.loginWithNativeSocialToken(sessionToken, FACEBOOK_SUBJECT_TOKEN_TYPE)
.setScope(AUTH0_SCOPE)
.addParameters(params)
.start(object : Callback {
override fun onFailure(error: AuthenticationException) {
callback.onError(error)
}
override fun onSuccess(result: Credentials) {
callback.onResult(result)
}
})
}
```
```kt performLogin lines
private fun performLogin(accessToken: AccessToken) {
val token = accessToken.token
fetchSessionToken(token, object : SimpleCallback {
override fun onResult(sessionToken: String) {
//2. Obtained the Facebook session token
fetchUserProfile(token, accessToken.userId, object : SimpleCallback {
override fun onResult(userProfile: String) {
//3. Obtained the user profile
exchangeTokens(
sessionToken,
userProfile,
object : SimpleCallback {
override fun onResult(credentials: Credentials) {
//4. Exchanged the tokens
Log.i(TAG, "Logged in to Auth0")
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error exchanging tokens", cause)
}
})
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error fetching the profile", cause)
}
})
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error fetching the session token", cause)
}
})
}
```
```kt onCreate lines
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
FacebookSdk.setClientToken(getString(R.string.facebook_client_token))
FacebookSdk.sdkInitialize(this)
setContentView(R.layout.activity_login)
val auth0 =
Auth0(getString(R.string.com_auth0_client_id), getString(R.string.com_auth0_domain))
apiClient = AuthenticationAPIClient(auth0)
fbCallbackManager = CallbackManager.Factory.create()
val loginButton = findViewById(R.id.login_button).apply {
setPermissions(*FACEBOOK_PERMISSIONS)
}
loginButton.registerCallback(fbCallbackManager, object : FacebookCallback {
override fun onSuccess(result: LoginResult) {
val accessToken = result.accessToken
performLogin(accessToken)
}
override fun onCancel() {
Log.i(TAG, "Facebook sign-in cancelled")
}
override fun onError(error: FacebookException) {
Log.e(TAG, "Error {error.message}")
}
})
}
```
```kt performLogin+SimpleCallback lines
private interface SimpleCallback {
fun onResult(result: T)
fun onError(cause: Throwable)
}
```
```kt fetchSessionToken lines
private fun fetchSessionToken(token: String, callback: SimpleCallback) {
val params = Bundle().apply {
putString("grant_type", "fb_attenuate_token")
putString("fb_exchange_token", token)
putString("client_id", getString(R.string.facebook_app_id))
}
val request = GraphRequest().apply {
parameters = params
graphPath = "oauth/access_token"
}
request.callback = GraphRequest.Callback { response ->
if (response.error != null) {
callback.onError(response.error?.exception!!)
return@Callback
}
try {
val fbSessionToken = response.jsonObject!!.getString("access_token")
callback.onResult(fbSessionToken)
} catch (jsonException: JSONException) {
//Failed to parse session token
callback.onError(jsonException)
}
}
request.executeAsync()
}
```
```kt fetchUserProfile lines
private fun fetchUserProfile(token: String, userId: String, callback: SimpleCallback) {
val params = Bundle().apply {
putString("access_token", token)
putString("fields", "first_name,last_name,email")
}
val request = GraphRequest().apply {
parameters = params
graphPath = userId
}
request.callback = GraphRequest.Callback { response ->
val error = response.error
if (error != null) {
//Failed to fetch user profile
callback.onError(error.exception!!)
return@Callback
}
//Handle back the profile as received
callback.onResult(response.rawResponse!!)
}
request.executeAsync()
}
```
```kt exchangeTokens lines
private fun exchangeTokens(
sessionToken: String,
userProfile: String,
callback: SimpleCallback
) {
val params = mapOf("user_profile" to userProfile)
apiClient.loginWithNativeSocialToken(sessionToken, FACEBOOK_SUBJECT_TOKEN_TYPE)
.setScope(AUTH0_SCOPE)
.addParameters(params)
.start(object : Callback {
override fun onFailure(error: AuthenticationException) {
callback.onError(error)
}
override fun onSuccess(result: Credentials) {
callback.onResult(result)
}
})
}
```
```kt performLogin lines
private fun performLogin(accessToken: AccessToken) {
val token = accessToken.token
fetchSessionToken(token, object : SimpleCallback {
override fun onResult(sessionToken: String) {
//2. Obtained the Facebook session token
fetchUserProfile(token, accessToken.userId, object : SimpleCallback {
override fun onResult(userProfile: String) {
//3. Obtained the user profile
exchangeTokens(
sessionToken,
userProfile,
object : SimpleCallback {
override fun onResult(credentials: Credentials) {
//4. Exchanged the tokens
Log.i(TAG, "Logged in to Auth0")
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error exchanging tokens", cause)
}
})
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error fetching the profile", cause)
}
})
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error fetching the session token", cause)
}
})
}
```
```kt fetchUserProfile lines
private fun fetchUserProfile(token: String, userId: String, callback: SimpleCallback) {
val params = Bundle().apply {
putString("access_token", token)
putString("fields", "first_name,last_name,email")
}
val request = GraphRequest().apply {
parameters = params
graphPath = userId
}
request.callback = GraphRequest.Callback { response ->
val error = response.error
if (error != null) {
//Failed to fetch user profile
callback.onError(error.exception!!)
return@Callback
}
//Handle back the profile as received
callback.onResult(response.rawResponse!!)
}
request.executeAsync()
}
```
```kt performLogin+SimpleCallback lines
private interface SimpleCallback {
fun onResult(result: T)
fun onError(cause: Throwable)
}
```
```kt onCreate lines
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
FacebookSdk.setClientToken(getString(R.string.facebook_client_token))
FacebookSdk.sdkInitialize(this)
setContentView(R.layout.activity_login)
val auth0 =
Auth0(getString(R.string.com_auth0_client_id), getString(R.string.com_auth0_domain))
apiClient = AuthenticationAPIClient(auth0)
fbCallbackManager = CallbackManager.Factory.create()
val loginButton = findViewById(R.id.login_button).apply {
setPermissions(*FACEBOOK_PERMISSIONS)
}
loginButton.registerCallback(fbCallbackManager, object : FacebookCallback {
override fun onSuccess(result: LoginResult) {
val accessToken = result.accessToken
performLogin(accessToken)
}
override fun onCancel() {
Log.i(TAG, "Facebook sign-in cancelled")
}
override fun onError(error: FacebookException) {
Log.e(TAG, "Error {error.message}")
}
})
}
```
```kt fetchSessionToken lines
private fun fetchSessionToken(token: String, callback: SimpleCallback) {
val params = Bundle().apply {
putString("grant_type", "fb_attenuate_token")
putString("fb_exchange_token", token)
putString("client_id", getString(R.string.facebook_app_id))
}
val request = GraphRequest().apply {
parameters = params
graphPath = "oauth/access_token"
}
request.callback = GraphRequest.Callback { response ->
if (response.error != null) {
callback.onError(response.error?.exception!!)
return@Callback
}
try {
val fbSessionToken = response.jsonObject!!.getString("access_token")
callback.onResult(fbSessionToken)
} catch (jsonException: JSONException) {
//Failed to parse session token
callback.onError(jsonException)
}
}
request.executeAsync()
}
```
```kt exchangeTokens lines
private fun exchangeTokens(
sessionToken: String,
userProfile: String,
callback: SimpleCallback
) {
val params = mapOf("user_profile" to userProfile)
apiClient.loginWithNativeSocialToken(sessionToken, FACEBOOK_SUBJECT_TOKEN_TYPE)
.setScope(AUTH0_SCOPE)
.addParameters(params)
.start(object : Callback {
override fun onFailure(error: AuthenticationException) {
callback.onError(error)
}
override fun onSuccess(result: Credentials) {
callback.onResult(result)
}
})
}
```
```kt performLogin lines
private fun performLogin(accessToken: AccessToken) {
val token = accessToken.token
fetchSessionToken(token, object : SimpleCallback {
override fun onResult(sessionToken: String) {
//2. Obtained the Facebook session token
fetchUserProfile(token, accessToken.userId, object : SimpleCallback {
override fun onResult(userProfile: String) {
//3. Obtained the user profile
exchangeTokens(
sessionToken,
userProfile,
object : SimpleCallback {
override fun onResult(credentials: Credentials) {
//4. Exchanged the tokens
Log.i(TAG, "Logged in to Auth0")
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error exchanging tokens", cause)
}
})
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error fetching the profile", cause)
}
})
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error fetching the session token", cause)
}
})
}
```
```kt performLogin lines
private fun performLogin(accessToken: AccessToken) {
val token = accessToken.token
fetchSessionToken(token, object : SimpleCallback {
override fun onResult(sessionToken: String) {
//2. Obtained the Facebook session token
fetchUserProfile(token, accessToken.userId, object : SimpleCallback {
override fun onResult(userProfile: String) {
//3. Obtained the user profile
exchangeTokens(
sessionToken,
userProfile,
object : SimpleCallback {
override fun onResult(credentials: Credentials) {
//4. Exchanged the tokens
Log.i(TAG, "Logged in to Auth0")
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error exchanging tokens", cause)
}
})
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error fetching the profile", cause)
}
})
}
override fun onError(cause: Throwable) {
Log.e(TAG, "Error fetching the session token", cause)
}
})
}
```
```kt performLogin+SimpleCallback lines
private interface SimpleCallback {
fun onResult(result: T)
fun onError(cause: Throwable)
}
```
```kt onCreate lines
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
FacebookSdk.setClientToken(getString(R.string.facebook_client_token))
FacebookSdk.sdkInitialize(this)
setContentView(R.layout.activity_login)
val auth0 =
Auth0(getString(R.string.com_auth0_client_id), getString(R.string.com_auth0_domain))
apiClient = AuthenticationAPIClient(auth0)
fbCallbackManager = CallbackManager.Factory.create()
val loginButton = findViewById(R.id.login_button).apply {
setPermissions(*FACEBOOK_PERMISSIONS)
}
loginButton.registerCallback(fbCallbackManager, object : FacebookCallback {
override fun onSuccess(result: LoginResult) {
val accessToken = result.accessToken
performLogin(accessToken)
}
override fun onCancel() {
Log.i(TAG, "Facebook sign-in cancelled")
}
override fun onError(error: FacebookException) {
Log.e(TAG, "Error {error.message}")
}
})
}
```
```kt fetchSessionToken lines
private fun fetchSessionToken(token: String, callback: SimpleCallback) {
val params = Bundle().apply {
putString("grant_type", "fb_attenuate_token")
putString("fb_exchange_token", token)
putString("client_id", getString(R.string.facebook_app_id))
}
val request = GraphRequest().apply {
parameters = params
graphPath = "oauth/access_token"
}
request.callback = GraphRequest.Callback { response ->
if (response.error != null) {
callback.onError(response.error?.exception!!)
return@Callback
}
try {
val fbSessionToken = response.jsonObject!!.getString("access_token")
callback.onResult(fbSessionToken)
} catch (jsonException: JSONException) {
//Failed to parse session token
callback.onError(jsonException)
}
}
request.executeAsync()
}
```
```kt fetchUserProfile lines
private fun fetchUserProfile(token: String, userId: String, callback: SimpleCallback) {
val params = Bundle().apply {
putString("access_token", token)
putString("fields", "first_name,last_name,email")
}
val request = GraphRequest().apply {
parameters = params
graphPath = userId
}
request.callback = GraphRequest.Callback { response ->
val error = response.error
if (error != null) {
//Failed to fetch user profile
callback.onError(error.exception!!)
return@Callback
}
//Handle back the profile as received
callback.onResult(response.rawResponse!!)
}
request.executeAsync()
}
```
```kt exchangeTokens lines
private fun exchangeTokens(
sessionToken: String,
userProfile: String,
callback: SimpleCallback
) {
val params = mapOf("user_profile" to userProfile)
apiClient.loginWithNativeSocialToken(sessionToken, FACEBOOK_SUBJECT_TOKEN_TYPE)
.setScope(AUTH0_SCOPE)
.addParameters(params)
.start(object : Callback {
override fun onFailure(error: AuthenticationException) {
callback.onError(error)
}
override fun onSuccess(result: Credentials) {
callback.onResult(result)
}
})
}
```
Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.