Autenticación en Firebase y Parse

En la Parte 1 y la Parte 2 de esta serie, comparamos el proceso de creación de una App y la integración de frameworks a tu proyecto XCode y cómo las bases de datos Firebase y Parse tienen características similares y distintas que podrían encajar mejor en tu caso de uso.

En esta tercera parte, empezaremos a codificar y evaluaremos cuánto código es necesario para conseguir que un proceso de Registro / Entrada funcione en ambas plataformas.

Qué vamos a construir

Como ambas plataformas realizarán esencialmente las mismas tareas, utilizaremos exactamente el mismo diseño de View Controllers con todos los controles creados de forma similar:

El View Controller principal realizará segues a los View Controllers Sign-Up y Sign In, que realizarán las acciones respectivas.

El código Firebase

Después de instalar el SDK Firebase como se describe en la Parte 1, tenemos que inicializarlo en nuestro archivo AppDelegate.swift:

import Firebase

Después, dentro de nuestro método application:didFinishLaunchingWithOptions, tenemos que inicializar el objeto FirebaseApp, poniendo la siguiente línea encima de la sentencia return true:

FirebaseApp.configure()

Ahora, debemos añadir código a todas nuestras vistas que necesiten información privada del usuario que ha iniciado sesión para escuchar al objeto FIRAuth, que será llamado cada vez que cambie el estado de inicio de sesión.

Un buen lugar para poner este código es en el método viewWillAppear, para que la vista ni siquiera cargue datos si no está autorizada:

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

También es necesario separar el listener antes de abandonar dicha View, por lo que en el método viewWillDisappear, podemos añadir este código:

Auth.auth().removeStateDidChangeListener(handle!)

El registro de nuevos usuarios se hará en nuestro SignUpViewController, así que vamos a añadir este código en el método que se llama cuando el usuario pulsa el botón Singn-Up:

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

Un buen tratamiento de errores para el método anterior se parece a esto:

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

El registro de usuarios se realizará en nuestro SignInViewController, cuando el usuario haga clic en el botón Sign In. El código para registrar a un usuario es el siguiente:

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
}

Finalmente podemos recuperar los detalles del usuario después de iniciar sesión usando este código:

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

El proceso de Cierre de Sesión se realiza mediante:

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

Esto es bastante sencillo y directo.
Echemos un vistazo al enfoque de Parse:

El código Parse

De forma similar a Firebase, comenzaremos instalando Parse IOS SDK, como se describe en la Parte 1, entonces, necesitamos inicializarlo en nuestro archivo AppDelegate.swift:

import Parse

Como Parse se puede alojar prácticamente en cualquier lugar, es obligatorio configurar también el Id de la aplicación, la clave y la URL del host de Parse que esté utilizando:

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)

En nuestro método viewDidAppear, podemos comprobar si el usuario ya ha iniciado sesión, para poder mostrar los datos:

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

En nuestro SignUpViewController, vamos a añadir algo de código para crear el usuario cuando se haga clic en el botón Sign-Up:

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.
        }
    }
}

El inicio de sesión se realiza en nuestro SignInViewController, cuando el usuario hace clic en el botón 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 es interpretado por:

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

Conclusión

El registro e inicio de sesión en Firebase necesita unas pocas líneas de código menos que Parse, pero Parse puede alojarse prácticamente en cualquier lugar, lo que supone una gran ventaja, ya que no hay dependencia de ningún proveedor.

Ambos ofrecen procesos de registro, entrada y salida con tratamiento de errores y gestión sencilla del código.

Como tal, no consideraré 3 o 4 líneas de código como una ventaja.
Voy a llamar a esto un empate.