Create and Authenticate Users - Kotlin SDK

Anonymous

La autenticación anónima permite a los usuarios iniciar sesión en tu aplicación con cuentas a corto plazo que no almacenan información personal persistente. Se puede usar esto para permitir que los usuarios prueben tu aplicación antes de registrarse para una cuenta o mientras desarrollan y prueban la aplicación. Los usuarios anónimos no requieren registro. Consulta Autenticación Anónima en la documentación de App Services para obtener más información.

Para iniciar sesión con autenticación anónima, crea una credencial anónima llamando a Credentials.anonymous(), y luego pasa la credencial generada a app.login():

val app: App = App.create(YOUR_APP_ID) // Replace this with your App ID
runBlocking {
    val anonymousCredentials = Credentials.anonymous()
    val user = app.login(anonymousCredentials)
}

By default, the Kotlin SDK reuses the same anonymous user if that user has not logged out. If you want to create more than one anonymous user, set reuseExisting = false when logging in with additional anonymous credentials:

// Logs in with an anonymous user
val anonUser = app.login(Credentials.anonymous())
// Logs in with a new, different anonymous user
val otherAnonUser =
    app.login(Credentials.anonymous(reuseExisting = false))

Correo electrónico/Contraseña

El proveedor de autenticación de correo electrónico/contraseña permite a los usuarios iniciar sesión en tu aplicación con un nombre de usuario de correo electrónico y una contraseña. Consulta Autenticación con correo electrónico/contraseña en la documentación de App Services para obtener más información.

Para iniciar sesión con autenticación por correo electrónico/contraseña, crear una credencial por correo electrónico/contraseña llamando a Credentials.emailPassword() con el correo electrónico y la contraseña registrados del usuario, y luego pasar las credenciales generadas a aplicación.login():

val app: App = App.create(YOUR_APP_ID) // Replace this with your App ID
runBlocking {
    val emailPasswordCredentials = Credentials.emailPassword(email, password)
    val user = app.login(emailPasswordCredentials)
}

JWT personalizado

The Custom JWT authentication provider enables users to log in to your application with a custom JSON Web Token (JWT). Registration for JWT authentication is handled by the JWT provider. Refer to Custom JWT Authentication in the App Services documentation for more information.

Para iniciar sesión con autenticación JWT, cree una credencial JWT llamando a Credentials.jwt() con el JWT del usuario y luego pase la credencial generada a app.login():

val app: App = App.create(YOUR_APP_ID) // Replace this with your App ID
runBlocking {
    // Registration is handled by the JWT provider
    val jwtCredentials = Credentials.jwt(jwtToken)
    val user = app.login(jwtCredentials)
}

Llave API

El proveedor de autenticación de clave API permite que los usuarios autenticados no anónimos inicien sesión en tu aplicación con dicha clave. Consulte Autenticación con clave de API en la documentación de Servicios de aplicación para obtener más información.

Para iniciar sesión con autenticación de clave API, cree una credencial de clave API llamando a Credentials.apiKey() con la clave API del usuario y luego pasando la credencial generada a app.login():

val app: App = App.create(YOUR_APP_ID) // Replace this with your App ID
runBlocking {
    val user = app.login(Credentials.apiKey(key))
}

User API keys are generated automatically and managed by the Kotlin SDK. Learn how to Manage User API Keys - Kotlin SDK.

Función personalizada

El proveedor de autenticación de función personalizada permite que los usuarios inicien sesión en tu aplicación utilizando lógica de autenticación personalizada gestionada por una Atlas Function. Consulta Autenticación de función personalizada en la documentación de App Services para más información.

To log in with Custom Function authentication, pass your custom arguments as a payload to Credentials.customFunction(), and then pass the generated credential to app.login():

// Create custom arguments for your Atlas Function
val customCredentials = Credentials.customFunction(
    payload = mapOf("username" to "bob")
)
val user = app.login(customCredentials)

Learn how to Call an Atlas Function - Kotlin SDK.

You can serialize data for a Custom Function credential using an EJSON encoder. For more information, including examples, refer to EJSON Encoding for Atlas.

Google

El proveedor de autenticación de Google permite autenticar a los usuarios a través de su cuenta de Google existente mediante un 2.0 token OAuth.Consulta "Autenticación de Google" en la documentación de App Services para obtener más información.

Before you can authenticate users with Google, you must set up your application for Google User authentication:

1. In the Google Cloud Platform console, create an OAuth 2.0 client ID of type "Web application".

2. Configure your backend App to use that client ID and the associated client secret.

3. Enable OpenID Connect on the backend.

Utilice el Inicio de sesión de Google para Android oficial de Google para autenticar usuarios de Google en su aplicación de Android. El siguiente código implementa este flujo, comenzando con una llamada a un método a loginWithGoogle():

fun loginWithGoogle() {
    val gso = GoogleSignInOptions
        .Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
        .requestIdToken("YOUR WEB APPLICATION CLIENT ID FOR GOOGLE AUTH")
        .build()
    val googleSignInClient = GoogleSignIn.getClient(activity, gso)
    val signInIntent: Intent = googleSignInClient.signInIntent
    val resultLauncher: ActivityResultLauncher<Intent> =
        // Note: this activity MUST inherit from ComponentActivity or AppCompatActivity to use this API
        registerForActivityResult(ActivityResultContracts.StartActivityForResult())
        { result ->
            val task: Task<GoogleSignInAccount> =
                GoogleSignIn.getSignedInAccountFromIntent(result.data)
            handleSignInResult(task)
        }
    resultLauncher.launch(signInIntent)
}
fun handleSignInResult(completedTask: Task<GoogleSignInAccount>) {
    try {
        if (completedTask.isSuccessful) {
            val account: GoogleSignInAccount? = completedTask.getResult(ApiException::class.java)
            val token: String = account?.idToken!!
            val app: App = App.create(YOUR_APP_ID) // Replace this with your App ID
            runBlocking {
                val user = app.login(Credentials.google(token, GoogleAuthType.ID_TOKEN))
            }
        } else {
            Log.e("AUTH", "Google Auth failed: ${completedTask.exception}")
        }
    } catch (e: ApiException) {
        Log.e("AUTH", "Failed to authenticate using Google OAuth: " + e.message);
    }
}

Kotlin Multiplatform (KMP) supports many environments, but this example shows sign-in on the Android platform. For information about signing into a Google account on Apple platforms, refer to the Swift SDK Example.

Facebook

The Facebook authentication provider allows you to authenticate users through a Facebook app using their existing Facebook account. Refer to Facebook Authentication in the App Services documentation for more information.

Before you can authenticate users with Facebook, you must set up the authentication flow for your application by following the official Facebook Login for Android Quickstart.

In the login completion handler, get the logged in user's access token from the Facebook LoginResult. Use the access token to create a Facebook credential by calling Credentials.facebook() with the user's access token, and then pass the generated credential to app.login():

val app: App = App.create(YOUR_APP_ID) // Replace this with your App ID
FacebookSdk.setApplicationId(YOUR_FACEBOOK_SDK_APP_ID)
FacebookSdk.sdkInitialize(activity)
val callbackManager = CallbackManager.Factory.create()
LoginManager.getInstance().registerCallback(
    callbackManager,
    object : FacebookCallback<LoginResult> {
        override fun onSuccess(loginResult: LoginResult) {
            // Signed in successfully, forward credentials to MongoDB Realm.
            val accessToken = loginResult.accessToken
            runBlocking {
                val user = app.login(Credentials.facebook(accessToken.token))
            }
        }
        override fun onCancel() {
            Log.v("AUTH", "Cancelled Facebook login")
        }
        override fun onError(exception: FacebookException) {
            Log.e("AUTH", "Failed to authenticate with Facebook: ${exception.message}")
        }
    })

Kotlin Multiplatform (KMP) es compatible con muchos entornos, pero este ejemplo muestra cómo iniciar sesión en la plataforma Android. Para información sobre cómo iniciar sesión en una cuenta de Facebook en plataformas Apple, consulta el ejemplo del SDK de Swift.

Apple

El proveedor de autenticación Sign-in with Apple permite a los usuarios iniciar sesión en tu aplicación con un token personalizado proporcionado por Apple. Consulta Autenticación de Apple ID en la documentación de App Services para obtener más información.

Para iniciar sesión con la autenticación de Apple, cree una credencial de Apple llamando a Credentials.apple() con el token del usuario y luego pase la credencial generada a app.login():

val app: App = App.create(YOUR_APP_ID) // Replace this with your App ID
runBlocking {
    // Registration is handled by Apple
    val appleCredentials = Credentials.apple(idToken)
    val user = app.login(appleCredentials)
}

Kotlin Multiplatform (KMP) es compatible con muchos entornos, pero este ejemplo muestra cómo iniciar sesión en la plataforma Android. Para información sobre cómo iniciar sesión con Apple en las plataformas de Apple, ve el Swift SDK Ejemplo.

Obtener un token de acceso de usuario

Puede obtener el token de acceso actual de un usuario que haya iniciado sesión con la propiedad user.accessToken:

val token = user.accessToken

Si envía solicitudes fuera del SDK, debe incluir el token de acceso del usuario en cada solicitud y actualizarlo manualmente cuando caduque. Los tokens de acceso caducan 30 minutos después de que el usuario inicie sesión.

Puede obtener el token de actualización actual de un usuario que haya iniciado sesión con la propiedad user.refreshToken, que puede usar para solicitar un nuevo token de acceso:

// Gets the current refresh token for the user
fun getRefreshToken(): String {
    return user.refreshToken
}

Configurar la expiración del token de actualización

Refresh tokens expire after a set period of time. When the refresh token expires, the access token can no longer be refreshed and the user must log in again.

If the refresh token expires after the realm is open, the device will not be able to sync until the user logs in again. Your sync error handler should implement logic that catches a token expired error when attempting to sync, then redirect users to a login flow.

For information on configuring refresh token expiration, refer to Manage User Sessions in the App Services documentation.