Autorisierung auf Firebase & Parse

In Teil 1 und Teil 2 dieser Serie haben wir den Prozess der App-Erstellung und der Integration von Frameworks in Ihr XCode-Projekt verglichen und gezeigt, wie Firebase und Parse Datenbanken ähnliche und unterschiedliche Funktionen haben, die besser zu Ihrem Anwendungsfall passen könnten.

In diesem dritten Teil werden wir mit der Codierung beginnen und bewerten, wie viel Code notwendig ist, um einen Anmeldeprozess auf beiden Plattformen zum Laufen zu bringen.

Was wir bauen werden

Da beide Plattformen im Wesentlichen dieselben Aufgaben erfüllen, werden wir genau dasselbe Design für die View Controller verwenden und alle Steuerelemente auf ähnliche Weise erstellen:

Der Haupt-View-Controller führt Übergänge zu den View-Controllern “Sign-Up” und “Sign-In” durch, die die jeweiligen Aktionen ausführen.

Der Firebase-Code

Nachdem wir das Firebase SDK wie in Teil 1 beschrieben installiert haben, müssen wir es in unserer AppDelegate.swift-Datei initialisieren:

import Firebase

Dann müssen wir innerhalb unserer application:didFinishLaunchingWithOptions-Methode das FirebaseApp-Objekt initialisieren, indem wir die folgende Zeile über die return true-Anweisung setzen:

FirebaseApp.configure()

Jetzt müssen wir Code zu allen unseren Ansichten hinzufügen, die Informationen benötigen, die für den angemeldeten Benutzer privat sind, um auf das FIRAuth-Objekt zu hören, das jedes Mal aufgerufen wird, wenn sich ein Anmeldestatus ändert.

Ein guter Platz für diesen Code ist die viewWillAppear-Methode, so dass die Ansicht nicht einmal Daten lädt, wenn sie nicht autorisiert ist:

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

Es ist auch notwendig, den Listener zu lösen, bevor wir eine solche Ansicht verlassen, also können wir in der viewWillDisappear-Methode diesen Code hinzufügen:

Auth.auth().removeStateDidChangeListener(handle!)

Die Anmeldung neuer Benutzer wird in unserem SignUpViewController durchgeführt, also fügen wir diesen Code in die Methode ein, die aufgerufen wird, wenn der Benutzer die Schaltfläche “Anmelden” drückt:

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

Eine gute Fehlerbehandlung für die obige Methode sieht folgendermaßen aus:

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

Die Anmeldung von Benutzern erfolgt in unserem SignInViewController, wenn der Benutzer auf die Schaltfläche Sign In klickt. Der Code für die Anmeldung eines Benutzers sieht wie folgt aus:

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
}

Mit diesem Code können wir dann schließlich die Daten des angemeldeten Benutzers abrufen:

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

Der Abmeldevorgang erfolgt durch:

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

Nun, das ist recht einfach und unkompliziert.
Werfen wir einen Blick auf den Ansatz von Parse:

Der Parse-Code

Ähnlich wie bei Firebase beginnen wir mit der Installation des Parse IOS SDK, wie in Teil 1 beschrieben, und müssen es dann in unserer AppDelegate.swift-Datei initialisieren:

import Parse

Da Parse praktisch überall gehostet werden kann, ist es zwingend erforderlich, auch die App-ID, den Schlüssel und die URL für den von Ihnen verwendeten Parse-Host einzurichten:

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)

In unserer viewDidAppear-Methode können wir prüfen, ob der Benutzer bereits eingeloggt ist, damit wir Daten anzeigen können:

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

In unserem SignUpViewController fügen wir etwas Code hinzu, um den Benutzer zu erstellen, wenn die Schaltfläche Sign-Up angeklickt wird:

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

Die Anmeldung erfolgt in unserem SignInViewController, wenn der Benutzer auf die Schaltfläche “Anmelden” klickt:

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

Die Abmeldung wird durchgeführt von:

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

Schlussfolgerung

Firebase-Anmeldung und -Anmeldung benötigen ein paar Codezeilen weniger als Parse, aber Parse kann praktisch überall gehostet werden, was ein großer Vorteil ist, da es keine Herstellerbindung gibt.

Beide bieten Anmelde-, An- und Abmeldeprozesse mit Fehlerbehandlung und einfacher Codeverwaltung.

Daher werde ich 3 oder 4 Zeilen Code nicht als Vorteil betrachten.
Ich nenne dies ein Unentschieden.