Menu Docs
Página inicial do Docs
/
MongoDB Atlas
/
Atlas Device SDKs
/
SDK para Java
/
Gerenciar usuários

Aplicativos de vários usuários - Java SDK

Nesta página

  • Estados da conta de usuário
  • Adicionar um novo usuário ao dispositivo
  • Listar todos os usuários no dispositivo
  • Remover um usuário do dispositivo
  • Alterar o usuário ativo

O Realm SDK permite que váriosusuários do façam login em um aplicativo simultaneamente em um determinado dispositivo. Os aplicativos de cliente do Realm são executados no contexto de um único usuário ativo, mesmo que vários usuários estejam conectados simultaneamente. Você pode alternar rapidamente entre usuários autenticados sem exigir que eles façam login novamente.

Aviso

Qualquer usuário conectado pode se tornar o usuário ativo sem autenticar novamente. Dependendo do seu aplicativo, essa pode ser uma vulnerabilidade de segurança. Por exemplo, um usuário em um dispositivo compartilhado pode mudar para a conta conectada de um colega de trabalho sem fornecer suas credenciais ou exigir sua permissão explícita. Se seu aplicativo exigir uma autenticação mais rigorosa, evite alternar entre usuários e prefira desconectar explicitamente o usuário ativo antes de autenticar outro usuário.

Estados da conta de usuário

Quando um usuário se conecta pela primeira vez por meio de um Realm SDK em um determinado dispositivo ou navegador, o SDK salva as informações do usuário e controla o estado do usuário no dispositivo. Os dados do usuário permanecem no dispositivo, mesmo que eles se desconectem, a menos que você remova ativamente o usuário.

Os estados a seguir descrevem um usuário no dispositivo a qualquer momento:

  • Autenticado: qualquer usuário que tenha feito login no dispositivo e não se desconectou nem teve a sessão revogada.

    • Ativo: um único usuário autenticado que está usando o aplicativo atualmente em um determinado dispositivo. O SDK associa este usuário com solicitações de saída e o Atlas App Services avalia permissões de acesso aos dados e executa funções no contexto deste usuário. Consulte usuário ativo para obter mais informações.

    • Inativo: todos os usuários autenticados que não são o usuário ativo atual. Você pode alterar o usuário ativo para um usuário atualmente inativo a qualquer momento.

  • Logged Out: qualquer usuário que tenha se autenticado no dispositivo, mas que tenha se desconectado ou tido sua sessão revogada.

O diagrama a seguir mostra como os usuários dentro de uma transição de aplicativo cliente do Realm entre estados quando ocorrem determinados eventos:

Um diagrama que descreve os diferentes estados em que um usuário pode estar: desconectado, conectado e ativo, e conectado e inativo.

Adicionar um novo usuário ao dispositivo

O Realm SDK adiciona automaticamente usuários a um dispositivo quando eles fazem login pela primeira vez nesse dispositivo. Quando um usuário faz login, ele se torna imediatamente o usuário ativodo aplicativo.

String appID = YOUR_APP_ID; // replace this with your App ID
App app = new App(new AppConfiguration.Builder(appID).build());
// Log in as Joe
Credentials joeCredentials = Credentials.emailPassword(firstUserEmail, firstUserPassword);
app.loginAsync(joeCredentials, it -> {
    if (it.isSuccess()) {
        // The active user is now Joe
        User joe = it.get();
        assert joe == app.currentUser();
    } else {
        Log.e("EXAMPLE", "Failed to log in: " + it.getError().getErrorMessage());
    }
});
// Log in as Emma
Credentials emmaCredentials = Credentials.emailPassword(secondUserEmail, secondUserPassword);
app.loginAsync(emmaCredentials, it -> {
    if (it.isSuccess()) {
        // The active user is now Emma
        User emma = it.get();
        assert emma == app.currentUser();
    } else {
        Log.e("EXAMPLE", "Failed to log in: " + it.getError().getErrorMessage());
    }
});
val appID: String = YOUR_APP_ID // replace this with your App ID
val app = App(AppConfiguration.Builder(appID).build())
// Log in as Joe
val joeCredentials = Credentials.emailPassword(firstUserEmail, firstUserPassword)
app.loginAsync(joeCredentials) {
    if (it.isSuccess) {
        // The active user is now Joe
        val joe = it.get()
        assert(joe === app.currentUser())
    } else {
        Log.e("EXAMPLE", "Failed to log in: ${it.error.errorMessage}")
    }
}
// Log in as Emma
val emmaCredentials = Credentials.emailPassword(secondUserEmail, secondUserPassword)
app.loginAsync(emmaCredentials) {
    if (it.isSuccess) {
        // The active user is now Emma
        val emma = it.get()
        assert(emma === app.currentUser())
    } else {
        Log.e("EXAMPLE", "Failed to log in: ${it.error.errorMessage}")
    }
}

Listar todos os usuários no dispositivo

Você pode acessar uma lista de todas as contas de usuário armazenadas no dispositivo. Essa lista inclui todos os usuários que fizeram logon no aplicativo cliente em um determinado dispositivo, independentemente de estarem autenticados no momento.

Map<String, User> users = app.allUsers();
for (Map.Entry<String, User> user : users.entrySet()) {
    Log.v("EXAMPLE", "User: " + user.getKey());
}
val users = app.allUsers()
for ((key) in users) {
    Log.v("EXAMPLE", "User: $key")
}

Remover um usuário do dispositivo

Para remover todas as informações sobre um usuário de um dispositivo, use user.remove() ou user.removeAsync():

app.loginAsync(credentials, it -> {
    if (it.isSuccess()) {
        User user = it.get();
        user.removeAsync(result -> {
            if (result.isSuccess()) {
                Log.v("EXAMPLE", "Successfully removed user from device.");
            } else {
                Log.e("EXAMPLE", "Failed to remove user from device.");
            }
        });
    } else {
        Log.e("EXAMPLE", "Failed to log in: " + it.getError().getErrorMessage());
    }
});
app.loginAsync(credentials) {
    if (it.isSuccess) {
        val user = it.get()
        user.removeAsync { result: App.Result<User?> ->
            if (result.isSuccess) {
                Log.v("EXAMPLE",
                    "Successfully removed user from device.")
            } else {
                Log.e("EXAMPLE", "Failed to remove user from device.")
            }
        }
    } else {
        Log.e("EXAMPLE", "Failed to log in: ${it.error.errorMessage}")
    }
}

Alterar o usuário ativo

Você pode trocar rapidamente o usuário ativo de um aplicativo por outro usuário conectado a qualquer momento.

// Joe is already logged in and is the currently active user
User joe = app.currentUser();
// Log in as Emma
Credentials emmaCredentials = Credentials.emailPassword(secondUserEmail, secondUserPassword);
app.loginAsync(emmaCredentials, result -> {
    if (result.isSuccess()) {
        // The active user is now Emma
        User emma = result.get();
        assert emma == app.currentUser();
        // Switch active user back to Joe
        app.switchUser(joe);
        assert joe == app.currentUser();
    } else {
        Log.e("EXAMPLE", "Failed to log in: " + result.getError().getErrorMessage());
    }
});
// Joe is already logged in and is the currently active user
val joe = app.currentUser()
// Log in as Emma
val emmaCredentials = Credentials.emailPassword(
    secondUserEmail,
    secondUserPassword
)
app.loginAsync(emmaCredentials) { result ->
    if (result.isSuccess) {
        // The active user is now Emma
        val emma = result.get()
        assert(emma === app.currentUser())
        // Switch active user back to Joe
        app.switchUser(joe)
        assert(joe === app.currentUser())
    } else {
        Log.e("EXAMPLE", "Failed to log in: ${result.error.errorMessage}")
    }
}

Voltar

Gerenciar usuários de e-mail/senha

Próximo

Vincular identidades do usuário