Auth sur Firebase & Parse

Dans les parties 1 et 2 de cette série, nous avons comparé le processus de création d’une application et d’intégration de frameworks à votre projet XCode et comment les bases de données Firebase et Parse ont des caractéristiques similaires et distinctes qui pourraient mieux correspondre à votre cas d’utilisation.

Dans cette troisième partie, nous allons commencer à coder et évaluer la quantité de code nécessaire pour faire fonctionner un processus d’inscription / de connexion sur les deux plateformes.

Ce que nous allons construire

Comme les deux plates-formes effectueront essentiellement les mêmes tâches, nous utiliserons exactement la même conception de contrôleurs de vue et tous les contrôles seront créés de la même manière :

Le contrôleur de vue principal effectuera des séquences vers les contrôleurs de vue Sign-Up et Sign In, qui effectueront les actions respectives.

Le code Firebase

Après avoir installé le SDK Firebase comme décrit dans la partie 1, nous devons l’initialiser dans notre fichier AppDelegate.swift :

import Firebase

Ensuite, dans notre méthode application:didFinishLaunchingWithOptions, nous devons initialiser l’objet FirebaseApp, en plaçant la ligne suivante au-dessus de la déclaration return true :

FirebaseApp.configure()

Nous devons maintenant ajouter du code à toutes nos vues qui ont besoin d’informations privées pour l’utilisateur connecté afin d’écouter l’objet FIRAuth, qui sera appelé chaque fois qu’un état de connexion change.

Un bon endroit pour placer ce code est la méthode viewWillAppear, de sorte que la vue ne chargera même pas de données si elle n’est pas autorisée :

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

Il est également nécessaire de détacher l’écouteur avant de quitter cette vue, donc dans la méthode viewWillDisappear, nous pouvons ajouter ce code :

Auth.auth().removeStateDidChangeListener(handle!)

L’inscription des nouveaux utilisateurs se fera dans notre SignUpViewController. Ajoutons donc ce code dans la méthode qui sera appelée lorsque l’utilisateur appuiera sur le bouton d’inscription :

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

Une bonne gestion des erreurs pour la méthode ci-dessus ressemble à ceci :

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

L’inscription des utilisateurs se fera dans notre contrôleur SignInView, lorsque l’utilisateur cliquera sur le bouton Sign In. Le code de connexion d’un utilisateur ressemble à ceci :

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
}

Nous pouvons ensuite récupérer les détails de l’utilisateur après l’avoir connecté en utilisant ce code :

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

Le processus de déconnexion s’effectue de la manière suivante :

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

C’est assez simple et direct.
Jetons un coup d’œil à l’approche de Parse :

Le code Parse

Comme pour Firebase, nous allons commencer par installer le SDK Parse IOS, comme décrit dans la partie 1, puis nous devons l’initialiser dans notre fichier AppDelegate.swift :

import Parse

Comme Parse peut être hébergé pratiquement n’importe où, il est obligatoire de configurer votre App Id, votre clé et l’URL de l’hébergeur Parse que vous utilisez :

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)

Dans notre méthode viewDidAppear, nous pouvons vérifier si l’utilisateur est déjà connecté, afin d’afficher les données :

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

Dans notre SignUpViewController, ajoutons du code pour créer l’utilisateur lorsque l’on clique sur le bouton 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 connexion est effectuée dans notre contrôleur SignInView, lorsque l’utilisateur clique sur le bouton 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 est interprété par :

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

Conclusion

L’inscription et la connexion à Firebase nécessitent quelques lignes de code de moins que Parse, mais Parse peut être hébergé pratiquement n’importe où, ce qui est un énorme avantage car il n’y a pas de verrouillage du fournisseur.

Tous deux proposent des processus d’inscription, de connexion et de déconnexion avec une gestion des erreurs et une gestion aisée du code.

Je ne considérerai donc pas 3 ou 4 lignes de code comme un avantage.
Je dirai que c’est un match nul.