/ /

/ /

SDK de dispositivos Atlas

SDK de Java

Administrar usuarios

Autenticar usuarios - SDK de Java

Los SDK de dispositivos Atlas están obsoletos. Consulte Página de desuso para más detalles.

Realm proporciona una API para autenticar usuarios mediante cualquier proveedor de autenticación habilitado. Crear una instancia Credentials objeto y páselo a cualquiera de los métodos app.login() o app.loginAsync() para autenticar el inicio de sesión de un usuario y crear un objeto User. Cada proveedor de autenticación corresponde a un método auxiliar estático que se utiliza para instanciar objetos Credentials mediante dicho proveedor.

Inicia sesión

Puede autenticar usuarios con los métodos app.login() o app.loginAsync() de la instancia de la clase io.realm.mongodb.App de su aplicación. Mientras que el método app.login() bloquea la ejecución del código en el hilo que realiza la llamada hasta que las credenciales proporcionadas hayan autenticado correctamente o no al usuario, el método app.loginAsync() permite que la ejecución continúe, gestionando el éxito o el fracaso con una función de devolución de llamada que garantiza su ejecución en el mismo hilo que llamó a app.loginAsync().

Si tiene éxito, el método app.login() devuelve un objeto User. En caso de fallo, el método app.login() genera una excepción de tipo ObjectServerError.

Pase una devolución de llamada al método app.loginAsync() para gestionar el éxito o el fracaso. Esta devolución de llamada acepta un único parámetro de tipo App.Result. El método isSuccess() del objeto App.Result pasado a la devolución de llamada devuelve un valor booleano que indica si la operación se realizó correctamente. En caso de fallo, puede ver el error que lo causó mediante el método getError().

Usuario anónimo

El El proveedor de autenticación anónima permite a los usuarios iniciar sesión en su aplicación con cuentas temporales que no almacenan información personal persistente. Para iniciar sesión con autenticación anónima, cree una credencial anónima llamando Credentials.anonymous() a y luego envíe la credencial generada a app.login() app.loginAsync()o.

String appID = YOUR_APP_ID; // replace this with your App ID
App app = new App(new AppConfiguration.Builder(appID)
        .build());
Credentials anonymousCredentials = Credentials.anonymous();
AtomicReference<User> user = new AtomicReference<User>();
app.loginAsync(anonymousCredentials, it -> {
    if (it.isSuccess()) {
        Log.v("AUTH", "Successfully authenticated anonymously.");
        user.set(app.currentUser());
    } else {
        Log.e("AUTH", it.getError().toString());
    }
});

val appID = YOUR_APP_ID // replace this with your App ID
val app: App = App(
    AppConfiguration.Builder(appID)
        .build()
)
val anonymousCredentials: Credentials = Credentials.anonymous()
var user: User?
app.loginAsync(anonymousCredentials) {
    if (it.isSuccess) {
        Log.v("AUTH", "Successfully authenticated anonymously.")
        user = app.currentUser()
    } else {
        Log.e("AUTH", it.error.toString())
    }
}

Correo electrónico/Contraseña Usuario

El proveedor de autenticación de correo electrónico/contraseña permite a los usuarios iniciar sesión en su aplicación con un nombre de usuario y una contraseña. Para iniciar sesión con autenticación de correo electrónico/contraseña, cree una credencial de correo electrónico/contraseña llamando Credentials.emailPassword() a con el correo electrónico y la contraseña del usuario. Luego, envíe la credencial generada a app.login() app.loginAsync()o.

String appID = YOUR_APP_ID; // replace this with your App ID
App app = new App(new AppConfiguration.Builder(appID)
        .build());
Credentials emailPasswordCredentials = Credentials.emailPassword("<email>", "<password>");
AtomicReference<User> user = new AtomicReference<User>();
app.loginAsync(emailPasswordCredentials, it -> {
    if (it.isSuccess()) {
        Log.v("AUTH", "Successfully authenticated using an email and password.");
        user.set(app.currentUser());
    } else {
        Log.e("AUTH", it.getError().toString());
    }
});

val appID = YOUR_APP_ID // replace this with your App ID
val app: App = App(
    AppConfiguration.Builder(appID)
        .build()
)
val emailPasswordCredentials: Credentials = Credentials.emailPassword(
    "<email>",
    "<password>"
)
var user: User? = null
app.loginAsync(emailPasswordCredentials) {
    if (it.isSuccess) {
        Log.v("AUTH", "Successfully authenticated using an email and password.")
        user = app.currentUser()
    } else {
        Log.e("AUTH", it.error.toString())
    }
}

Usuario de clave API

El proveedor de autenticación de clave API permite a los usuarios iniciar sesión en su aplicación con una clave API generada automáticamente en el SDK del cliente. Para iniciar sesión con autenticación de clave API, cree una credencial Credentials.apiKey() de clave API llamando a con una clave API. Luego, pase la credencial generada a app.login() app.loginAsync()o.

String appID = YOUR_APP_ID; // replace this with your App ID
App app = new App(new AppConfiguration.Builder(appID)
        .build());
Credentials apiKeyCredentials = Credentials.apiKey("<key>");
AtomicReference<User> user = new AtomicReference<User>();
app.loginAsync(apiKeyCredentials, it -> {
    if (it.isSuccess()) {
        Log.v("AUTH", "Successfully authenticated using an API Key.");
        user.set(app.currentUser());
    } else {
        Log.e("AUTH", it.getError().toString());
    }
});

val appID = YOUR_APP_ID // replace this with your App ID
val app: App = App(
    AppConfiguration.Builder(appID)
        .build()
)
val apiKeyCredentials: Credentials = Credentials.apiKey("<key>")
var user: User? = null
app.loginAsync(apiKeyCredentials) {
    if (it.isSuccess) {
        Log.v("AUTH", "Successfully authenticated using an API Key.")
        user = app.currentUser()
    } else {
        Log.e("AUTH", "Error logging in: ${it.error.toString()}")
    }
}

Usuario JWT personalizado

El proveedor de autenticación JWT personalizada permite a los usuarios iniciar sesión en su aplicación con un token web JSON personalizado. Para iniciar sesión con autenticación JWT personalizada, cree una credencial JWT personalizada llamando Credentials.jwt() a con su JWT personalizado. Luego, pase la credencial generada a app.login() app.loginAsync()o.

String appID = YOUR_APP_ID; // replace this with your App ID
App app = new App(new AppConfiguration.Builder(appID)
        .build());
// fetch JWT from custom provider
Credentials customJWTCredentials = Credentials.jwt("<token>");
AtomicReference<User> user = new AtomicReference<User>();
app.loginAsync(customJWTCredentials, it -> {
    if (it.isSuccess()) {
        Log.v("AUTH", "Successfully authenticated using a custom JWT.");
        user.set(app.currentUser());
    } else {
        Log.e("AUTH", it.getError().toString());
    }
});

val appID = YOUR_APP_ID // replace this with your App ID
val app: App = App(
    AppConfiguration.Builder(appID)
        .build()
)
// fetch JWT from custom provider
val customJWTCredentials: Credentials = Credentials.jwt("<token>")
var user: User? = null
app.loginAsync(customJWTCredentials) {
    if (it.isSuccess) {
        Log.v("AUTH", "Successfully authenticated using a custom JWT.")
        user = app.currentUser()
    } else {
        Log.e("AUTH", "Error logging in: ${it.error.toString()}")
    }
}

Usuario de función personalizada

El proveedor de autenticación de funciones personalizadas permite a los usuarios iniciar sesión en su aplicación mediante una función de Realm definida en su aplicación. Para iniciar sesión con la autenticación de función personalizada, cree una credencial llamando Credentials.customFunction() a. El método customFunction() espera un documento que contenga las propiedades y los valores utilizados por la función de autenticación de Realm. Por ejemplo, supongamos que la función de backend espera que el parámetro de entrada incluya un campo username llamado, como este:

exports = async function(loginPayload) {
   const { username } = loginPayload;
   ...
}

El documento que pases a Credentials.customFunction() podría verse así:

Document("username", "bob")

Luego pasa la credencial generada a app.login() o app.loginAsync().

String appID = YOUR_APP_ID; // replace this with your App ID
App app = new App(new AppConfiguration.Builder(appID).build());
Credentials customFunctionCredentials =
        Credentials.customFunction(new org.bson.Document("username", "bob"));
AtomicReference<User> user = new AtomicReference<User>();
app.loginAsync(customFunctionCredentials, it -> {
    if (it.isSuccess()) {
        Log.v("AUTH", "Successfully authenticated using a custom function.");
        user.set(app.currentUser());
    } else {
        Log.e("AUTH", it.getError().toString());
    }
});

val appID = YOUR_APP_ID // replace this with your App ID
val app: App = App(
    AppConfiguration.Builder(appID)
        .build()
)
val customFunctionCredentials:
        Credentials = Credentials.customFunction(org.bson.Document("username", "bob"))
var user: User? = null
app.loginAsync(customFunctionCredentials) {
    if (it.isSuccess) {
        Log.v("AUTH", "Successfully authenticated using a custom function.")
        user = app.currentUser()
    } else {
        Log.e("AUTH", "Error logging in: ${it.error.toString()}")
    }
}

Usuario de Facebook

El proveedor de autenticación de Facebook le permite autenticar usuarios a través de una aplicación de Facebook utilizando su cuenta de Facebook existente.

Importante

Habilitar el proveedor de autenticación de Facebook

Para iniciar sesión un usuario con su cuenta de Facebook existente, debe configurar y habilitar el proveedor de autenticación de Facebook para su aplicación.

Importante

No almacene las URL de las imágenes de perfil de Facebook

Las URL de las fotos de perfil de Facebook incluyen el token de acceso del usuario para otorgar permiso a la imagen. Para garantizar la seguridad, no guardes una URL que incluya el token de acceso del usuario. En su lugar, accede a la URL directamente desde los campos de metadatos del usuario cuando necesites obtener la imagen.

Siga la guía de inicio rápido oficial de inicio de sesión de Facebook para AndroidPara configurar el flujo de autenticación de su aplicación. En el controlador de finalización de inicio de sesión, obtenga el token de acceso del usuario conectado de Facebook LoginResult. Use el token de acceso para crear una credencial de Facebook de Realm y luego inicie la sesión del usuario en su aplicación Realm.

FacebookSdk.setApplicationId(YOUR_FACEBOOK_SDK_APP_ID);
FacebookSdk.sdkInitialize(activity);
CallbackManager callbackManager = CallbackManager.Factory.create();
LoginManager.getInstance().registerCallback(callbackManager,
    new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            // Signed in successfully, forward credentials to MongoDB Realm.
            AccessToken accessToken = loginResult.getAccessToken();
            Credentials facebookCredentials = Credentials.facebook(accessToken.getToken());
            app.loginAsync(facebookCredentials, it -> {
                if (it.isSuccess()) {
                    Log.v("AUTH", "Successfully logged in to MongoDB Realm using Facebook OAuth.");
                } else {
                    Log.e("AUTH", "Failed to log in to MongoDB Realm", it.getError());
                }
            });
        }
        
        @Override
        public void onCancel() {
            Log.v("AUTH", "Facebook authentication cancelled.");
        }
        
        @Override
        public void onError(FacebookException exception) {
            Log.e("AUTH", "Failed to authenticate using Facebook: " + exception.getMessage());
        }
    }
);
LoginManager.getInstance().logIn(activity, null);

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
            val facebookCredentials: Credentials =
                Credentials.facebook(accessToken.token)
            app.loginAsync(facebookCredentials) {
                if (it.isSuccess) {
                    Log.v(
                        "AUTH",
                        "Successfully logged in to MongoDB Realm using Facebook OAuth."
                    )
                } else {
                    Log.e("AUTH", "Failed to log in to MongoDB Realm", it.error)
                }
            }
        }
        override fun onCancel() {
            Log.v("AUTH", "Cancelled Facebook login")
        }
        override fun onError(exception: FacebookException) {
            Log.e("AUTH", "Failed to authenticate with Facebook: ${exception.message}")
        }
    })

Usuario de Google

Importante

Para iniciar sesión un usuario con su cuenta de Google existente, debe configurar y habilitar el proveedor de autenticación de Google para su aplicación.

Para configurar su aplicación para la autenticación de usuario de Google:

En la consola de Google Cloud Platform, cree 2 un0 ID de cliente OAuth. del tipo "Aplicación web".
Configure su aplicación backend para usar ese ID de cliente y el secreto de cliente asociado.
Habilitar OpenID Connect en el backend.

Utilice el inicio de sesión oficial de Google para Android para autenticar a los usuarios de Google en su aplicación de Android:

Nota

Ejemplo de código a continuación

Para implementar estas instrucciones, consulte el bloque de código a continuación.

Agregue la dependencia de inicio de sesión de Google para Android al bloque dependencies de su nivel de aplicación build.gradle:
```
com.google.android.gms:play-services-auth:19.2.0
```
Cree un GoogleSignInOptions con las siguientes opciones de creación:
- inicio de sesión por defecto
- una solicitud de token de identificación: pase su 2 0 ID de cliente OAuth.serverClientId como.
Utilice GoogleSignInOptions para crear un GoogleSignInClient con GoogleSignIn.getClient()
Utilice GoogleSignInClient para crear un Intent capaz de activar el inicio de sesión de Google.
Utilice registerForActivityResult() para configurar una devolución de llamada. Esta debe usar GoogleSignIn.getSignedInAccountFromIntent() para acceder al resultado del inicio de sesión de Google:Task<GoogleSignInAccount> un.
Usa el método launch() del ActivityResultLauncher devuelto en el paso anterior para iniciar el inicio de sesión de Google. Pasa el launch() método a tu inicio de sesión de Intent Google.
Utilice isSuccessful() para gestionar los errores de inicio de sesión con Google.
Accede al resultado de la tarea (una GoogleSignInAccount) con getResult().
Accede al ID token para el GoogleSignInAccount con getIdToken().
Cree un objeto Realm Credentials con Credentials.google() Pasa el token de ID como primer parámetro y GoogleAuthType.ID_TOKEN como segundo parámetro.
Utilice los métodos app.loginAsync() o app.login() para autenticarse con el backend de Atlas App Services usando el token.

El siguiente código implementa este flujo, comenzando con una llamada al método loginWithGoogle():

private void signInWithGoogle() {
    GoogleSignInOptions gso = new GoogleSignInOptions
            .Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestIdToken("YOUR WEB APPLICATION CLIENT ID FOR GOOGLE AUTH")
            .build();
    GoogleSignInClient googleSignInClient = GoogleSignIn.getClient(this, gso);
    Intent signInIntent = googleSignInClient.getSignInIntent();
    ActivityResultLauncher<Intent> resultLauncher =
            registerForActivityResult(
                    new ActivityResultContracts.StartActivityForResult(),
            new ActivityResultCallback<ActivityResult>() {
                @Override
                public void onActivityResult(ActivityResult result) {
                    Task<GoogleSignInAccount> task =
                            GoogleSignIn.getSignedInAccountFromIntent(result.getData());
                    handleSignInResult(task);
                }
            });
    resultLauncher.launch(signInIntent);
}
private void handleSignInResult(Task<GoogleSignInAccount> completedTask) {
    try {
        if (completedTask.isSuccessful()) {
            GoogleSignInAccount account = completedTask.getResult(ApiException.class);
            String token = account.getIdToken();
            Credentials googleCredentials =
                    Credentials.google(token, GoogleAuthType.ID_TOKEN);
            app.loginAsync(googleCredentials, it -> {
                if (it.isSuccess()) {
                    Log.v("AUTH",
                            "Successfully logged in to MongoDB Realm using Google OAuth.");
                } else {
                    Log.e("AUTH",
                            "Failed to log in to MongoDB Realm: ", it.getError());
                }
            });
        } else {
            Log.e("AUTH", "Google Auth failed: "
                    + completedTask.getException().toString());
        }
    } catch (ApiException e) {
        Log.w("AUTH", "Failed to log in with Google OAuth: " + e.getMessage());
    }
}

fun loginWithGoogle() {
    val gso = GoogleSignInOptions
        .Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
        .requestIdToken("YOUR WEB APPLICATION CLIENT ID FOR GOOGLE AUTH")
        .build()
    val googleSignInClient = GoogleSignIn.getClient(this, gso)
    val signInIntent: Intent = googleSignInClient.signInIntent
    val resultLauncher: ActivityResultLauncher<Intent> =
        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 googleCredentials: Credentials =
                Credentials.google(token, GoogleAuthType.ID_TOKEN)
            app.loginAsync(googleCredentials) {
                if (it.isSuccess) {
                    Log.v(
                        "AUTH",
                        "Successfully logged in to MongoDB Realm using Google OAuth."
                    )
                } else {
                    Log.e("AUTH",
                        "Failed to log in to MongoDB Realm", it.error)
                }
            }
        } else {
            Log.e("AUTH", "Google Auth failed: ${completedTask.exception}")
        }
    } catch (e: ApiException) {
        Log.e("AUTH", "Failed to authenticate using Google OAuth: " + e.message);
    }
}

Tip

Para obtener más información sobre el inicio de sesión de Google para Android, consulta la Guía de integración oficial del inicio de sesión de Google para Android.

Usuario de 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. Para iniciar sesión con la autenticación Sign-in with Apple, crea una credencial de Sign-in with Apple llamando a Credentials.apple() con el token proporcionado por Apple. Luego pasa la credencial generada a app.login() o app.loginAsync().

String appID = YOUR_APP_ID; // replace this with your App ID
App app = new App(new AppConfiguration.Builder(appID)
        .build());
// fetch apple token using Apple SDK
Credentials appleCredentials = Credentials.apple("<token>");
AtomicReference<User> user = new AtomicReference<User>();
app.loginAsync(appleCredentials, it -> {
    if (it.isSuccess()) {
        Log.v("AUTH", "Successfully authenticated using Sign-in with Apple.");
        user.set(app.currentUser());
    } else {
        Log.e("AUTH", it.getError().toString());
    }
});

val appID = YOUR_APP_ID // replace this with your App ID
val app: App = App(
    AppConfiguration.Builder(appID)
        .build()
)
// fetch IDToken using Apple SDK
val appleCredentials: Credentials = Credentials.apple("<token>")
var user: User? = null
app.loginAsync(appleCredentials) {
    if (it.isSuccess) {
        Log.v("AUTH", "Successfully authenticated using Sign-in with Apple.")
        user = app.currentUser()
    } else {
        Log.e("AUTH", "Error logging in: ${it.error.toString()}")
    }
}

Tip

Si recibe un error Login failed que indica que token contains an invalid number of segments, verifique que esté pasando una versión de cadena codificada en UTF-8del JWT.

Inicio de sesión sin conexión

App Services administra sesiones con tokens de acceso y tokens de actualización. Los SDK de cliente proporcionan la lógica para administrar los tokens y proporcionarles solicitudes.

El SDK almacena estos tokens en Preferencias compartidas.

Tip

Sesiones de usuario

Cuando tu aplicación Realm autentica a un usuario, almacena en caché las credenciales del usuario. Puedes comprobar si existen credenciales de usuario para omitir el flujo de inicio de sesión y acceder al usuario almacenado en caché. Usa esto para abrir un realm sin conexión.

Nota

El inicio de sesión inicial requiere una conexión de red

Cuando un usuario se registra en tu aplicación o inicia sesión por primera vez con una cuenta existente en un cliente, este debe tener conexión de red. Comprobar las credenciales de usuario en caché permite abrir un reino sin conexión, pero solo si el usuario ha iniciado sesión previamente con conexión.

// Log the user into the backend app.
// The first time you login, the user must have a network connection.
String appID = YOUR_APP_ID; // replace this with your App ID
App app = new App(new AppConfiguration.Builder(appID)
        .build());
// Check for an existing user.
// If the user is offline but credentials are
// cached, this returns the existing user.
AtomicReference<User> user = new AtomicReference<User>();
user.set(app.currentUser());
if (user.get() == null) {
    // If the device has no cached user
    // credentials, log them in.
    Credentials anonymousCredentials = Credentials.anonymous();
    app.loginAsync(anonymousCredentials, it -> {
        if (it.isSuccess()) {
            Log.v("AUTH", "Successfully authenticated anonymously.");
            user.set(app.currentUser());
        } else {
            Log.e("AUTH", it.getError().toString());
        }
    });
}

// Log the user into the backend app.
// The first time you login, the user must have a network connection.
val appID = YOUR_APP_ID // replace this with your App ID
val app = App(
    AppConfiguration.Builder(appID)
        .build()
)
// Check for an existing user.
// If the user is offline but credentials are
// cached, this returns the existing user.
val user =
    AtomicReference<User?>()
user.set(app.currentUser())
if (user.get() == null) {
    // If the device has no cached user
    // credentials, log them in.
    val anonymousCredentials =
        Credentials.anonymous()
    app.loginAsync(
        anonymousCredentials
    ) { it: App.Result<User?> ->
        if (it.isSuccess) {
            Log.v("AUTH", "Successfully authenticated anonymously.")
            user.set(app.currentUser())
        } else {
            Log.e("AUTH", it.error.toString())
        }
    }
}

Obtener un token de acceso de usuario

Cuando un usuario inicia sesión, Atlas App Services crea un token de acceso que le otorga acceso a su aplicación. El SDK de Realm administra automáticamente los tokens de acceso, los actualiza cuando caducan e incluye un token de acceso válido para el usuario actual con cada solicitud. Realm no actualiza automáticamente el token de actualización. Cuando este caduque, el usuario deberá volver a iniciar sesión.

Si envía solicitudes fuera del SDK, debe incluir el token de acceso del usuario con cada solicitud y actualizar manualmente el token cuando caduque.

Puede acceder y actualizar el token de acceso de un usuario que haya iniciado sesión en el SDK desde su objeto Realm.User, como en el siguiente ejemplo:

// Gets a valid user access token to authenticate requests
public String getValidAccessToken(User user) {
    // An already logged in user's access token might be stale. To
    // guarantee that the token is valid, refresh it if necessary.
    user.refreshCustomData();
    return user.getAccessToken();
}

// Gets a valid user access token to authenticate requests
fun getValidAccessToken(user: User?): String {
    // An already logged in user's access token might be stale. To
    // guarantee that the token is valid, refresh it if necessary.
    user!!.refreshCustomData()
    return user.accessToken
}

Cerrar la sesión de un usuario

Puede cerrar la sesión de cualquier usuario, independientemente del proveedor de autenticación utilizado para iniciar sesión, mediante los métodos user.logOut() o user.logOutAsync(). Ambos métodos:

eliminar las credenciales de usuario almacenadas localmente en el dispositivo
Detener inmediatamente cualquier sincronización hacia y desde los dominios del usuario

Debido a que al cerrar la sesión se detiene la sincronización, solo debes cerrar la sesión después de que todas las actualizaciones locales de Realm se hayan cargado en el servidor.

user.get().logOutAsync( result -> {
    if (result.isSuccess()) {
        Log.v("AUTH", "Successfully logged out.");
    } else {
        Log.e("AUTH", result.getError().toString());
    }
});

user?.logOutAsync {
    if (it.isSuccess) {
        Log.v("AUTH", "Successfully logged out.")
    } else {
        Log.e("AUTH", it.error.toString())
    }
}

Volver

Crear y eliminar usuarios

Datos de usuario personalizados