Autenticação no Firebase e no Parse

Na Parte 1 e na Parte 2 desta série, comparamos o processo de criação de um aplicativo e a integração de estruturas ao seu projeto XCode e como os bancos de dados Firebase e Parse têm recursos semelhantes e distintos que podem se adequar melhor ao seu caso de uso.

Nesta terceira parte, começaremos a codificar e avaliaremos quanto código é necessário para que um processo de inscrição/entrada funcione em ambas as plataformas.

O que estaremos construindo

Como as duas plataformas realizarão essencialmente as mesmas tarefas, usaremos exatamente o mesmo design de View Controllers, com todos os controles criados de forma semelhante:

O View Controller principal executará seguimentos para os View Controllers Sign-Up e Sign In, que executarão as respectivas ações.

O código do Firebase

Depois de instalar o Firebase SDK, conforme descrito na Parte 1, precisamos inicializá-lo em nosso arquivo AppDelegate.swift:

import Firebase

Em seguida, dentro do método application:didFinishLaunchingWithOptions, precisamos inicializar o objeto FirebaseApp, colocando a seguinte linha acima da instrução return true:

FirebaseApp.configure()

Agora, devemos adicionar código a todas as nossas visualizações que precisam de informações privadas do usuário conectado para ouvir o objeto FIRAuth, que será chamado sempre que um estado de login for alterado.

Um bom lugar para colocar esse código é no método viewWillAppear, para que a exibição não carregue dados se não for autorizada:

handle = Auth.auth().addStateDidChangeListener { (auth, user) in
  // Any other actions that happen upon state change can be written here
}

Também é necessário desanexar o ouvinte antes de sairmos dessa visualização, portanto, no método viewWillDisappear, podemos adicionar este código:

Auth.auth().removeStateDidChangeListener(handle!)

A inscrição de novos usuários será feita em nosso SignUpViewController, portanto, vamos adicionar esse código no método que é chamado quando o usuário pressiona o botão SignUp:

Auth.auth().createUser(withEmail: email, password: password) { authResult, error in
  // Code for error handling and other actions can be put here
}

Um bom tratamento de erros para o método acima é o seguinte:

guard let user = authResult?.user, error == nil else {
    print("ERROR CREATING USER \(user.email!).")
    print(error!.localizedDescription)
    return
}
print("\(user.email!) successfuly created.")

O login dos usuários será feito em nosso SignInViewController, quando o usuário clicar no botão Sign In. O código para fazer login em um usuário tem a seguinte aparência:

Auth.auth().signIn(withEmail: email, password: password) { [weak self] authResult, error in
  guard let strongSelf = self else { return }
  // Aditional code for error handling and other actions can be put here
}

Em seguida, podemos finalmente recuperar os detalhes do usuário após o login usando este código:

if let user = user {
  let uid = user.uid
  let email = user.email
  // Aditional properties can be retrieved here 
}

O processo de saída é realizado por meio de:

firebase.auth().signOut().then(function() {
  // Sign-out successful.
}).catch(function(error) {
  // An error happened.
});

Isso é bastante simples e direto.
Vamos dar uma olhada na abordagem do Parse:

O código Parse

Da mesma forma que o Firebase, começaremos instalando o Parse IOS SDK, conforme descrito na Parte 1. Em seguida, precisaremos inicializá-lo em nosso arquivo AppDelegate.swift:

import Parse

Como o Parse pode ser hospedado em praticamente qualquer lugar, é obrigatório configurar também o App Id, a chave e o URL do host do Parse que você está usando:

let configuration = ParseClientConfiguration {
    $0.applicationId = "PASTE_YOUR_APPLICATION_ID_HERE"
    $0.clientKey = "PASTE_YOUR_CLIENT_ID_HERE"
    $0.server = "https://parseapi.back4app.com"
}
Parse.initialize(with: configuration)

Em nosso método viewDidAppear, podemos verificar se o usuário já está conectado, para que possamos exibir os dados:

let currentUser = PFUser.current()
if currentUser != nil {
    // User is NOT logged in. Do not display data.
}

Em nosso SignUpViewController, vamos adicionar algum código para criar o usuário quando o botão Sign-Up for clicado:

let user = PFUser()
user.username = signUpUsernameField.text
user.password = signUpPasswordField.text
user.signUpInBackground { (success, error) in
    UIViewController.removeSpinner(spinner: sv)
    if success{
        // Success signing up. Display data for this user.
    }else{
        if let descrip = error?.localizedDescription{
            // Error signing up. Do not display data and show error message.
        }
    }
}

O login é feito em nosso SignInViewController, quando o usuário clica no botão Sign In:

PFUser.logInWithUsername(inBackground: signInUsernameField.text!, password: signInPasswordField.text!) { (user, error) in
    if user != nil {
        // User signed In. Display data.
    }else{
        if let descrip = error?.localizedDescription{
            // User not signed in. Do not display data and show error message
        }
    }
}

Signing Out é apresentado por:

PFUser.logOutInBackground { (error: Error?) in
    if (error == nil){
        // Success logging out
    }else{
        // Error logging out. Display error message.
    }
}

Conclusão

O registro e o login do Firebase precisam de algumas linhas de código a menos do que o Parse, mas o Parse pode ser hospedado praticamente em qualquer lugar, o que é uma grande vantagem, pois não há dependência de fornecedor.

Ambos oferecem processos de registro, entrada e saída com tratamento de erros e fácil gerenciamento de código.

Portanto, não considerarei 3 ou 4 linhas de código como uma vantagem.
Vou considerar este um empate.