Autorizzazione su Firebase e Parse

Nella prima e nella seconda parte di questa serie, abbiamo confrontato il processo di creazione di un’app e l’integrazione dei framework nel progetto XCode e come i database Firebase e Parse abbiano caratteristiche simili e distinte che potrebbero adattarsi meglio al vostro caso d’uso.

In questa terza parte, inizieremo la codifica e valuteremo quanto codice è necessario per ottenere un processo di iscrizione/registrazione funzionante su entrambe le piattaforme.

Cosa costruiremo

Poiché entrambe le piattaforme svolgeranno essenzialmente gli stessi compiti, utilizzeremo lo stesso design dei controller di visualizzazione con tutti i controlli creati in modo simile:

Il controllore di visualizzazione principale eseguirà dei passaggi ai controllori di visualizzazione Sign-Up e Sign In, che eseguiranno le rispettive azioni.

Il codice di Firebase

Dopo aver installato l’SDK Firebase come descritto nella Parte 1, dobbiamo inizializzarlo nel nostro file AppDelegate.swift:

import Firebase

Quindi, all’interno del metodo application:didFinishLaunchingWithOptions, dobbiamo inizializzare l’oggetto FirebaseApp, inserendo la seguente riga sopra la dichiarazione return true:

FirebaseApp.configure()

Ora, dobbiamo aggiungere del codice a tutte le nostre viste che necessitano di informazioni private dell’utente che ha effettuato l’accesso, per ascoltare l’oggetto FIRAuth, che verrà richiamato ogni volta che cambia lo stato di accesso.

Un buon posto per inserire questo codice è il metodo viewWillAppear, in modo che la vista non carichi nemmeno i dati se non è autorizzata:

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

È inoltre necessario staccare l’ascoltatore prima di lasciare la vista, quindi nel metodo viewWillDisappear si può aggiungere questo codice:

Auth.auth().removeStateDidChangeListener(handle!)

La registrazione di nuovi utenti avverrà nel nostro SignUpViewController, quindi aggiungiamo questo codice nel metodo che viene richiamato quando l’utente preme il pulsante Singn-Up:

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

Una buona gestione degli errori per il metodo di cui sopra è simile a questa:

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

La registrazione degli utenti avverrà nel nostro SignInViewController, quando l’utente fa clic sul pulsante Sign In. Il codice per l’accesso di un utente si presenta come segue:

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
}

Quindi possiamo recuperare i dati dell’utente dopo il login, utilizzando questo codice:

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

Il processo di disconnessione si ottiene con:

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

Si tratta di un’operazione piuttosto semplice e lineare.
Vediamo l’approccio di Parse:

Il codice Parse

Analogamente a Firebase, inizieremo installando l’SDK Parse IOS, come descritto nella Parte 1, quindi dovremo inizializzarlo nel nostro file AppDelegate.swift:

import Parse

Poiché Parse può essere ospitato praticamente ovunque, è obbligatorio impostare anche l’Id dell’app, la chiave e l’URL dell’host di Parse che si sta utilizzando:

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)

Nel nostro metodo viewDidAppear, possiamo verificare se l’utente è già loggato, in modo da poter visualizzare i dati:

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

Nel nostro SignUpViewController, aggiungiamo del codice per creare l’utente quando viene cliccato il pulsante 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.
        }
    }
}

La registrazione avviene nel nostro SignInViewController, quando l’utente fa clic sul pulsante 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 è eseguito da:

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

Conclusione

La registrazione e l’accesso a Firebase richiedono alcune righe di codice in meno rispetto a Parse, ma Parse può essere ospitato praticamente ovunque, il che rappresenta un enorme vantaggio in quanto non vi è alcun vincolo con il fornitore.

Entrambi offrono processi di iscrizione, registrazione e cancellazione con gestione degli errori e facile gestione del codice.

Pertanto, non considererò 3 o 4 linee di codice come un vantaggio.
Per me questo è un pareggio.