Menu Docs
Página inicial do Docs
/ /
Atlas Device SDKs
/ /

Autenticar usuários - Swift SDK

Nesta página

  • Conecte-se
  • Utilizador anónimo
  • Usuário de e-mail/senha
  • Usuário da chave de API
  • Usuário de função personalizada
  • Usuário JWT personalizado
  • Usuário do Facebook
  • Usuário do Google
  • Usuário da Apple
  • Login Assíncrono/Aguardar
  • Login off-line
  • Obtenha um token de acesso do usuário
  • Atualize a expiração do token
  • Desconecte

If you have enabled Anonymous authentication in the App Services UI, users can immediately log into your app without providing any identifying information. The following code shows how to do this:

let anonymousCredentials = Credentials.anonymous
app.login(credentials: anonymousCredentials) { (result) in
switch result {
case .failure(let error):
print("Login failed: \(error.localizedDescription)")
case .success(let user):
print("Successfully logged in as user \(user)")
// Now logged in, do something with user
// Remember to dispatch to main if you are doing anything on the UI thread
}
}

Se tiver activado a autenticação de Correio Electrónico/Palavra-passe, pode iniciar sessão utilizando o seguinte código:

let email = "skroob@example.com"
let password = "12345"
app.login(credentials: Credentials.emailPassword(email: email, password: password)) { (result) in
switch result {
case .failure(let error):
print("Login failed: \(error.localizedDescription)")
case .success(let user):
print("Successfully logged in as user \(user)")
// Now logged in, do something with user
// Remember to dispatch to main if you are doing anything on the UI thread
}
}

Se você tiver ativado a autenticação da chave de API, poderá fazer login usando o seguinte código:

let credentials = Credentials.userAPIKey("<api-key>")
app.login(credentials: credentials) { (result) in
switch result {
case .failure(let error):
print("Login failed: \(error.localizedDescription)")
case .success(let user):
print("Successfully logged in as user \(user)")
// Now logged in, do something with user
// Remember to dispatch to main if you are doing anything on the UI thread
}
}

Se você tiver ativado o provedor de autenticação Custom Function, poderá fazer login usando o seguinte código:

let params: Document = ["username": "bob"]
app.login(credentials: Credentials.function(payload: params)) { (result) in
switch result {
case .failure(let error):
print("Login failed: \(error.localizedDescription)")
case .success(let user):
print("Successfully logged in as user \(user)")
// Now logged in, do something with user
// Remember to dispatch to main if you are doing anything on the UI thread
}
}

Se você tiver ativado o provedor de autenticação Custom JWT, poderá fazer login usando o seguinte código:

let credentials = Credentials.jwt(token: "<jwt>")
app.login(credentials: credentials) { (result) in
switch result {
case .failure(let error):
print("Login failed: \(error.localizedDescription)")
case .success(let user):
print("Successfully logged in as user \(user)")
// Now logged in, do something with user
// Remember to dispatch to main if you are doing anything on the UI thread
}
}

O provedor de autenticação do Facebook permite que você autentique usuários por meio de um aplicativo do Facebook usando sua conta existente do Facebook.

Importante

Habilite o provedor de autenticação do Facebook

Para conectar um usuário com uma conta do Facebook existente, você deve configurar e habilitar o provedor de autenticação do Facebook para seu aplicativo.

Importante

Não armazene URLs de fotos de perfil do Facebook

Os URLs da imagem de perfil do Facebook incluem o token de acesso do usuário para conceder permissão à imagem. Para garantir a segurança, não armazene um URL que inclua um token de acesso do usuário. Em vez disso, acesse o URL diretamente dos campos de metadados do usuário quando precisar buscar a imagem.

Siga o início rápido oficial de login do Facebook para iOS para configurar o fluxo de autenticação do seu aplicativo. No gerenciador de conclusão de login, crie uma credencial do Facebook do App Services com a string do token de acesso do usuário conectado e faça o login do usuário em seu aplicativo App Services.

// This example demonstrates login logic for FBSDK version 13.x. If you're using
// a different version of FBSDK, you'll need to adapt this example for your version.
let loginManager = LoginManager()
loginManager.logIn(permissions: [ .email ]) { loginResult in
switch loginResult {
case .success(let grantedPermissions, let declinedPermissions, let accessToken):
let credentials = Credentials.facebook(accessToken: accessToken!.tokenString)
app.login(credentials: credentials) { result in
DispatchQueue.main.async {
switch result {
case .failure(let error):
print("Failed to log in to MongoDB Realm: \(error)")
case .success(let user):
print("Successfully logged in to MongoDB Realm using Facebook OAuth.")
// Now logged in, do something with user
// Remember to dispatch to main if you are doing anything on the UI thread
}
}
}
case .failed(let error):
print("Facebook login failed: \(error)")
case .cancelled:
print("The user cancelled the login flow.")
}
}

Importante

Para fazer login de um usuário com sua Conta do Google existente, você deve configurar e ativar o provedor de autenticação do Google para seu aplicativo.

Siga o Guia de Integração oficial do Google Sign-In para iOS para configurar o fluxo de autenticação do seu aplicativo. No manipulador de conclusão de login, crie uma credencial do Google do App Services e faça login do usuário em seu aplicativo do App Services.

O valor que você passa para a credencial depende se você habilitou ou não o OpenID Connect para o provedor:

  • Se o OpenID Connect estiver ativado, passe o id_token incluído na resposta do Google OAuth para Credentials.googleId(token:).

  • Se o OpenID Connect não estiver ativado, passe o código de autenticação do servidor do usuário para Credentials.google(serverAuthCode:).

func sign(_ signIn: GIDSignIn!, didSignInFor googleUser: GIDGoogleUser!, withError error: Error!) {
if let error = error {
print("\(error.localizedDescription)")
return
}
// Get the ID token for the authenticated user so you can pass it to Realm
let idToken = googleUser.authentication.idToken!
let credentials = Credentials.googleId(token: idToken)
app.login(credentials: credentials) { result in
DispatchQueue.main.async {
switch result {
case .failure(let error):
print("Failed to log in to MongoDB Realm: \(error)")
case .success(let user):
print("Successfully logged in to MongoDB Realm using Google OAuth.")
// Now logged in, do something with user
// Remember to dispatch to main if you are doing anything on the UI thread
}
}
}
}
func sign(_ signIn: GIDSignIn!, didSignInFor googleUser: GIDGoogleUser!, withError error: Error!) {
if let error = error {
print("\(error.localizedDescription)")
return
}
// Upon first successful sign-in, forward serverAuthCode credentials to MongoDB Realm.
// Upon subsequent sign-ins, this returns nil.
let credentials = Credentials.google(serverAuthCode: googleUser.serverAuthCode!)
app.login(credentials: credentials) { result in
DispatchQueue.main.async {
switch result {
case .failure(let error):
print("Failed to log in to MongoDB Realm: \(error)")
case .success(let user):
print("Successfully logged in to MongoDB Realm using Google OAuth.")
// Now logged in, do something with user
// Remember to dispatch to main if you are doing anything on the UI thread
}
}
}
}

Se tiver ativado o Iniciar sessão com autenticação Apple, pode iniciar sessão utilizando o seguinte código:

// Fetch IDToken via the Apple SDK
let credentials = Credentials.apple(idToken: "<token>")
app.login(credentials: credentials) { (result) in
switch result {
case .failure(let error):
print("Login failed: \(error.localizedDescription)")
case .success(let user):
print("Successfully logged in as user \(user)")
// Now logged in, do something with user
// Remember to dispatch to main if you are doing anything on the UI thread
}
}

Dica

Se você receber uma mensagem de erro Login failed dizendo que o token contains an invalid number of segments, verifique se está passando uma versão de string codificada em UTF-8 do JWT.

Novidades na versão 10.15.0.

A versão async/await do método App.login retorna de forma assíncrona um usuário ou erro.

func login() async {
do {
let app = App(id: YOUR_APP_SERVICES_APP_ID)
// Authenticate with the instance of the app that points
// to your backend. Here, we're using anonymous login.
let user = try await app.login(credentials: Credentials.anonymous)
print("Successfully logged in user: \(user)")
} catch {
print("Failed to log in user: \(error.localizedDescription)")
}
}

A partir das versões 10.15.0 e 10.16.0 do SDK do Realm Swift, muitas das APIs do Realm suportam a sintaxe async/await do Swift. Os projetos devem atender a estes requisitos:

Versão do Swift SDK
Requisito de versão do Swift
Sistema operacional compatível
10.25.0
Swift 5.6
iOS 13.x
10.15.0 ou 10.16.0
Swift 5.5
iOS 15.x

Se a sua aplicação acessar Realm em um contexto do async/await, marque o código com @MainActor para evitar falhas relacionadas a threading.

Quando seu aplicativo Realm autentica um usuário, armazena em cache as credenciais do usuário. Você pode verificar as credenciais de usuário existentes para ignorar o fluxo de login e acessar o usuário em cache. Use isto para abrir um realm offline.

Observação

O login inicial exige uma conexão de rede

Quando um usuário se inscreve em seu aplicativo ou faz login pela primeira vez com uma conta existente em um cliente, o cliente deve ter uma conexão de rede. A verificação de credenciais de usuário em cache permite que você abra um domínio offline, mas somente se o usuário já tiver feito login enquanto estiver online.

// Log the user into the backend app.
// The first time you login, the user must have a network connection.
func getUser() async throws -> User {
// Check for an existing user.
// If the user is offline but credentials are
// cached, this returns the existing user.
if let user = app.currentUser {
return user
} else {
// If the device has no cached user
// credentials, log them in.
let app = App(id: YOUR_APP_SERVICES_APP_ID)
let loggedInUser = try await app.login(credentials: Credentials.anonymous)
return loggedInUser
}
}
let user = try await getUser()
var configuration = user.configuration(partitionValue: "Some Partition Value")
// Open a Realm with this configuration.
// If you do not require the app to download updates
// before opening the realm, the realm just opens, even if
// offline.
let realm = try await Realm(configuration: configuration)
print("Successfully opened realm: \(realm)")

O Realm SDK gerencia automaticamente os tokens de acesso, atualiza-os quando expiram e inclui um token de acesso válido para o usuário atual em cada solicitação.

Se você enviar solicitações fora do SDK, deverá incluir o token de acesso do usuário em cada solicitação. Neste cenário, você deve atualizar manualmente o token quando ele expirar. Os tokens de acesso expiram após 30 minutos.

Você pode ligar para .refreshCustomData() em um usuário conectado para atualizar a sessão de autenticação do usuário. Em seguida, devolva o .accessToken como uma string que você pode usar em seu código. Você pode usar uma função semelhante a esta para buscar um token de acesso:

func getValidAccessToken(user: User) async throws -> String {
// An already logged in user's access token might be stale. To
// guarantee that the token is valid, refresh it if necessary.
try await user.refreshCustomData()
return user.accessToken!
}

O que exige um usuário conectado:

let app = App(id: YOUR_APP_SERVICES_APP_ID)
let user = try await app.login(credentials: Credentials.anonymous)
let accessToken = try await getValidAccessToken(user: user)

A atualização dos tokens expira após um período de tempo definido. Quando o token de atualização expira, o token de acesso não pode mais ser atualizado e o usuário deve se conectar novamente.

Se o token de atualização expirar após a abertura do realm, o dispositivo não poderá sincronizar até que o usuário faça login novamente. Seu manipulador de erros de sincronização deve implementar uma lógica que capture um erro de token expirado ao tentar sincronizar e, em seguida, redirecionar os usuários para um fluxo de login.

Para obter informações sobre como configurar a expiração do token de atualização, consulte Gerencie sessões de usuário na documentação do App Services.

Uma vez logado, você pode sair:

Aviso

Se o usuário se desconectar, você não poderá mais ler ou gravar dados em nenhum domínio sincronizado que o usuário tenha aberto. Consequentemente, qualquer operação que ainda não tenha sido concluída antes de o usuário iniciar o logout não poderá ser concluída com êxito e provavelmente resultará em erro. Todos os dados de uma operação de gravação que falhar dessa forma serão perdidos.

app.currentUser?.logOut { (error) in
// user is logged out or there was an error
}

Voltar

Criar e excluir usuários

Próximo

Usuário de dados personalizado