Diese Seite wurde von der Cloud Translation API übersetzt.

Android-Anmeldung mit FirebaseUI

Dieses Codelab ist Teil des Kurses „Advanced Android in Kotlin“. Sie können den größten Nutzen aus diesem Kurs ziehen, wenn Sie die Codelabs der Reihe nach durcharbeiten. Das ist jedoch nicht zwingend erforderlich. Alle Codelabs des Kurses sind auf der Landingpage für Codelabs zu „Android für Fortgeschrittene mit Kotlin“ aufgeführt.

Einführung

Wenn Sie eine Android-App entwickeln, bietet die Unterstützung der Anmeldung für Ihre Nutzer viele Vorteile. Wenn Sie Nutzern die Möglichkeit geben, eine Identität in Ihrer App zu erstellen, können Sie ihnen mehr Möglichkeiten zur Interaktion mit der App bieten.

Mit personalisierten Konten können Nutzer ihre In-App-Erfahrung anpassen, mit anderen Nutzern interagieren und ihre Daten speichern und übertragen lassen, wenn sie die App auf einem anderen Gerät (z. B. im Web oder auf einem neuen Smartphone) verwenden.

In diesem Codelab lernen Sie die Grundlagen der Unterstützung der Anmeldung für Ihre App mithilfe der FirebaseUI-Bibliothek kennen. Die FirebaseUI-Bibliothek erleichtert Entwicklern, die einen Anmeldevorgang erstellen möchten, die Arbeit und übernimmt die Verwaltung von Nutzerkonten für Sie.

Was Sie bereits wissen sollten

Grundlagen der Entwicklung von Android-Apps
LiveData und ViewModel

Lerninhalte

Firebase Ihrem Projekt hinzufügen
Anmeldung für Ihre Android-App unterstützen
Aktuellen Authentifizierungsstatus Ihrer App beobachten
Nutzer abmelden

Aufgaben

Verwenden Sie die Firebase Console, um Firebase in Ihre App zu integrieren.
Implementieren Sie die Anmeldefunktion.
Fügen Sie in der App Personalisierungen für angemeldete Nutzer hinzu.
Nutzer abmelden

Weitere Informationen zu LiveData und ViewModel

Für die App in diesem Codelab benötigen Sie grundlegende Kenntnisse von LiveData und ViewModel. Wenn Sie einen kurzen Überblick über diese Konzepte erhalten möchten, lesen Sie die Übersichten zu LiveData und ViewModel.

Sie können auch den Kurs „Android-Apps mit Kotlin entwickeln“ durcharbeiten, um mehr über grundlegende Android-Themen zu erfahren, die in diesem Codelab behandelt werden. Dieser Kurs ist sowohl als Udacity-Kurs als auch als Codelab-Kurs verfügbar.

In diesem Codelab entwickeln Sie eine App, in der interessante Android-Fakten angezeigt werden. Noch wichtiger ist, dass die App eine Schaltfläche zum Anmelden/Abmelden hat. Wenn der Nutzer in der App angemeldet ist, wird in jeder angezeigten Android-Faktenkarte eine Begrüßung für den Nutzer angezeigt, um die Karte zu personalisieren.

Sie haben folgende Möglichkeiten, die Beispiel-App herunterzuladen:

Zip herunterladen

… oder klonen Sie das GitHub-Repository über die Befehlszeile mit dem folgenden Befehl und wechseln Sie zum Zweig start des Repositorys:

$  git clone https://github.com/googlecodelabs/android-kotlin-login

Wichtig:Da Sie die App für die Verwendung von Firebase einbinden, muss die Starter-App eingerichtet werden, damit sie erstellt und ausgeführt werden kann. Das machen Sie im nächsten Schritt des Codelabs.

Schritt 1: Firebase-Projekt erstellen

Bevor Sie Firebase zu Ihrer Android-App hinzufügen können, müssen Sie ein Firebase-Projekt erstellen, das mit Ihrer Android-App verbunden wird.

Klicken Sie in der Firebase Console auf Projekt hinzufügen.
Wählen Sie einen Projektnamen aus oder geben Sie einen ein. Sie können Ihrem Projekt einen beliebigen Namen geben, sollten aber einen Namen wählen, der für die App, die Sie entwickeln, relevant ist.
Klicken Sie auf Weiter.
Sie können die Einrichtung von Google Analytics überspringen und die Option Nicht jetzt auswählen.
Klicken Sie auf Projekt erstellen, um die Einrichtung des Firebase-Projekts abzuschließen.

Schritt 2: App bei Firebase registrieren

Nachdem Sie ein Firebase-Projekt haben, können Sie Ihre Android-App hinzufügen.

Klicken Sie in der Mitte der Projektübersicht in der Firebase Console auf das Android, um den Einrichtungsworkflow zu starten.
Geben Sie die Anwendungs-ID Ihrer App in das Feld Android-Paketname ein. Achten Sie darauf, dass Sie die ID eingeben, die von Ihrer App verwendet wird, da Sie diesen Wert nicht mehr hinzufügen oder ändern können, nachdem Sie Ihre App in Ihrem Firebase-Projekt registriert haben.

Eine Anwendungs-ID wird manchmal auch als Paketname bezeichnet.
Sie finden diese Anwendungs-ID in der Gradle-Datei Ihres Moduls (auf App-Ebene), in der Regel app/build.gradle (Beispiel-ID: com.yourcompany.yourproject).
Geben Sie den SHA-1-Wert des Signaturzertifikats für die Fehlerbehebung ein. Sie können diesen Schlüssel generieren, indem Sie den folgenden Befehl in Ihr Befehlszeilenterminal eingeben.

keytool -alias androiddebugkey -keystore ~/.android/debug.keystore -list -v -storepass android

Klicken Sie auf App registrieren.

Schritt 3: Firebase-Konfigurationsdatei zum Projekt hinzufügen

Fügen Sie Ihrer App die Firebase-Konfigurationsdatei für Android hinzu:

Klicken Sie auf google-services.json herunterladen, um Ihre Firebase-Android-Konfigurationsdatei (google-services.json) zu erhalten.

Sie können Ihre Firebase-Konfigurationsdatei für Android jederzeit wieder herunterladen.
Achten Sie darauf, dass der Name der Konfigurationsdatei keine zusätzlichen Zeichen enthält und nur google-services.json lautet.

Verschieben Sie die Konfigurationsdatei in das Modulverzeichnis (auf App-Ebene) Ihrer App.

Schritt 4: Android-Projekt für Firebase-Produkte konfigurieren

Wenn Sie Firebase-Produkte in Ihrer App aktivieren möchten, fügen Sie das google-services-Plug-in zu Ihren Gradle-Dateien hinzu.

Fügen Sie in Ihrer Gradle-Datei auf Stammebene (Projektebene) (build.gradle) Regeln hinzu, um das Google-Dienste-Plug-in einzuschließen. Prüfen Sie, ob Sie auch das Maven-Repository von Google haben.

build.gradle

buildscript {

  repositories {
    // Check that you have the following line (if not, add it):
    google()  // Google's Maven repository
  }

  dependencies {
    // ...

    // Add the following line:
    classpath 'com.google.gms:google-services:4.3.0'  // Google Services plugin
  }
}

allprojects {
  // ...

  repositories {
    // Check that you have the following line (if not, add it):
    google()  // Google's Maven repository
    // ...
  }
}

Fügen Sie in der Gradle-Datei des Moduls (auf App-Ebene, in der Regel app/build.gradle) eine Zeile am Ende der Datei hinzu.

app/build.gradle

apply plugin: 'com.android.application'

android {
  // ...
}

// Add the following line to the bottom of the file:
apply plugin: 'com.google.gms.google-services'  // Google Play services Gradle plugin

Schritt 4: Firebase-Abhängigkeit hinzufügen

In diesem Codelab ist der Hauptgrund für die Integration von Firebase, Nutzer erstellen und verwalten zu können. Dazu müssen Sie eine Firebase-Bibliothek hinzufügen, mit der Sie die Anmeldung implementieren können.

Fügen Sie der Datei build.gradle (Module:app) die folgende Abhängigkeit hinzu, damit Sie das SDK in Ihrer App verwenden können. Mit dem firebase-auth SDK können authentifizierte Nutzer Ihrer Anwendung verwaltet werden.

app/build.gradle:

implementation 'com.firebaseui:firebase-ui-auth:5.0.0'

Synchronisieren Sie Ihr Projekt mit Gradle-Dateien, damit alle Abhängigkeiten für Ihre App verfügbar sind. Wenn Sie nicht dazu aufgefordert werden, wählen Sie in Android Studio File > Sync Project with Gradle Files oder in der Symbolleiste aus.

Schritt 5: App ausführen und Code prüfen

Führen Sie die App auf einem Emulator oder physischen Gerät aus, um sicherzustellen, dass Ihre Umgebung für den Beginn der Entwicklung eingerichtet ist.

Wenn der Vorgang erfolgreich war, sollte auf dem Startbildschirm ein interessanter Android-Fakt und links oben eine Anmeldeschaltfläche angezeigt werden. Wenn Sie auf die Schaltfläche „Anmelden“ tippen, passiert noch nichts.

Auf übergeordneter Ebene ist dies eine App mit einer einzigen Aktivität und mehreren Fragmenten. MainFragment enthält die gesamte Benutzeroberfläche, die Sie auf dem Bildschirm unten sehen. (In einem nachfolgenden Codelab arbeiten Sie mit LoginFragment und SettingsFragment.)

Machen Sie sich mit dem Code vertraut. Beachten Sie insbesondere Folgendes:

FirebaseUserLiveData ist die Klasse, die Sie implementieren, um den aktuellen Firebase-Nutzer zu beobachten, der mit der App verknüpft ist. Sie verwenden die FirebaseAuth-Instanz als Einstiegspunkt, um diese Nutzerinformationen in einem späteren Schritt abzurufen.
Das MainFragment ist an das LoginViewModel gebunden. LoginViewModel ist die Klasse, die Sie implementieren, um FirebaseUserLiveData zum Erstellen einer authenticationState-Variablen zu verwenden. Mit dieser authenticationState-Variablen kann MainFragment dann den Wert beobachten, um die Benutzeroberfläche entsprechend zu aktualisieren.

In diesem Schritt richten Sie in der Firebase Console die Authentifizierungsmethoden ein, die Ihre App unterstützen soll. In diesem Codelab konzentrieren Sie sich darauf, Nutzern die Anmeldung mit einer von ihnen angegebenen E-Mail-Adresse oder mit ihrem Google-Konto zu ermöglichen.

Rufen Sie die Firebase Console auf. Hinweis: Wenn Sie sich noch im Workflow zum Hinzufügen von Firebase befinden, klicken Sie links oben auf das X, um zur Console zurückzukehren.
Wählen Sie Ihr Projekt aus, falls Sie sich noch nicht darin befinden.
Öffnen Sie die Navigation auf der linken Seite und wählen Sie Entwickeln > Authentifizierung aus.

Wählen Sie in der oberen Navigationsleiste den Tab Anmeldemethode aus.

Klicke auf die Zeile E-Mail/Passwort.
Aktivieren Sie im Pop‑up-Fenster den Schalter Aktiviert und klicken Sie auf Speichern.
Klicken Sie auf die Zeile Google.
Stellen Sie den Schalter Aktiviert auf „Ein“, geben Sie eine Support-E‑Mail-Adresse für Projekt ein und klicken Sie auf Speichern.

In dieser Aufgabe implementieren Sie die Anmeldefunktion für Ihre Nutzer.

Öffnen Sie MainFragment.kt.
Beachten Sie im Layout von MainFragment die auth_button. Derzeit ist sie nicht für die Verarbeitung von Nutzereingaben eingerichtet.
Fügen Sie in onViewCreated(), ein onClickListener zu auth_button hinzu, um launchSignInFlow() aufzurufen.

MainFragment.kt

binding.authButton.setOnClickListener { launchSignInFlow() }

Suchen Sie in MainFragment.kt nach der Methode launchSignInFlow(). Sie enthält derzeit ein TODO.
Vervollständigen Sie die Funktion launchSignInFlow() wie unten gezeigt.

MainFragment.kt

private fun launchSignInFlow() {
   // Give users the option to sign in / register with their email or Google account.
   // If users choose to register with their email,
   // they will need to create a password as well.
   val providers = arrayListOf(
       AuthUI.IdpConfig.EmailBuilder().build(), AuthUI.IdpConfig.GoogleBuilder().build()

       // This is where you can provide more ways for users to register and 
       // sign in.
   )

   // Create and launch sign-in intent.
   // We listen to the response of this activity with the
   // SIGN_IN_REQUEST_CODE 
   startActivityForResult(
       AuthUI.getInstance()
           .createSignInIntentBuilder()
           .setAvailableProviders(providers)
           .build(),
       MainFragment.SIGN_IN_REQUEST_CODE
   )
}

So können sich Nutzer mit ihrer E-Mail-Adresse oder ihrem Google-Konto registrieren und anmelden. Wenn sich der Nutzer mit seiner E‑Mail-Adresse registriert, ist die von ihm erstellte Kombination aus E‑Mail-Adresse und Passwort eindeutig für Ihre App. Das bedeutet, dass er sich mit dieser Kombination in Ihrer App anmelden kann, aber nicht in anderen von Firebase unterstützten Apps.

In MainFragment.kt können Sie das Ergebnis des Anmeldevorgangs abrufen, indem Sie die Methode onActivityResult() implementieren, wie unten gezeigt. Da Sie den Anmeldevorgang mit SIGN_IN_REQUEST_CODE gestartet haben, können Sie auch auf das Ergebnis des Anmeldevorgangs warten, indem Sie filtern, wann SIGN_IN_REQUEST_CODE an onActivityResult() zurückgegeben wird. Fügen Sie zuerst einige Log-Anweisungen hinzu, um zu prüfen, ob sich der Nutzer erfolgreich angemeldet hat.

MainFragment.kt

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
   super.onActivityResult(requestCode, resultCode, data)
   if (requestCode == SIGN_IN_REQUEST_CODE) {
       val response = IdpResponse.fromResultIntent(data)
       if (resultCode == Activity.RESULT_OK) {
           // User successfully signed in
           Log.i(TAG, "Successfully signed in user ${FirebaseAuth.getInstance().currentUser?.displayName}!")
       } else {
           // Sign in failed. If response is null the user canceled the
           // sign-in flow using the back button. Otherwise check
           // response.getError().getErrorCode() and handle the error.
           Log.i(TAG, "Sign in unsuccessful ${response?.error?.errorCode}")
       }
   }
}

Ihre App sollte jetzt in der Lage sein, Nutzer zu registrieren und anzumelden.

Führen Sie die App aus und prüfen Sie, ob durch Tippen auf die Schaltfläche Anmelden der Anmeldebildschirm aufgerufen wird.
Sie können sich jetzt mit Ihrer E‑Mail-Adresse und einem Passwort oder mit Ihrem Google-Konto anmelden.
Nach der Anmeldung ändert sich die Benutzeroberfläche nicht. Die Aktualisierung der Benutzeroberfläche erfolgt im nächsten Schritt. Wenn alles richtig funktioniert, sollte nach der Registrierung die Log-Meldung Successfully signed in user ${your name}! angezeigt werden.
Sie können auch in der Firebase Console unter Entwickeln > Authentifizierung > Nutzer nachsehen, ob die App jetzt einen registrierten Nutzer hat.
Wenn Nutzer ein Konto für Ihre App erstellen, ist dieses Konto nur mit Ihrer App verknüpft und nicht mit einer anderen App, die Firebase für die Anmeldefunktion verwendet.

In dieser Aufgabe implementieren Sie die Aktualisierung der Benutzeroberfläche basierend auf dem Authentifizierungsstatus. Wenn der Nutzer angemeldet ist, können Sie seinen Startbildschirm personalisieren, indem Sie seinen Namen anzeigen. Außerdem aktualisieren Sie die Schaltfläche Anmelden in eine Schaltfläche Abmelden, wenn der Nutzer angemeldet ist.

Öffnen Sie die Klasse FirebaseUserLiveData.kt, die bereits für Sie erstellt wurde. Zuerst müssen Sie dafür sorgen, dass andere Klassen in der App wissen, wann sich ein Nutzer an- oder abgemeldet hat. Die Klasse führt jedoch noch keine Aktionen aus, da der Wert von LiveData nicht aktualisiert wird.
Da Sie die FirebaseAuth-Bibliothek verwenden, können Sie mit dem FirebaseUser.AuthStateListener-Callback, der als Teil der FirebaseUI-Bibliothek für Sie implementiert wurde, auf Änderungen am angemeldeten Nutzer reagieren. Dieser Callback wird immer dann ausgelöst, wenn sich ein Nutzer in Ihrer App an- oder abmeldet.
Beachten Sie, dass mit FirebaseUserLiveData.kt die Variable authStateListener definiert wird. In dieser Variablen wird der Wert von LiveData gespeichert. Die Variable authStateListener wurde erstellt, damit Sie das Abhören von Änderungen am Authentifizierungsstatus basierend auf dem Status Ihrer Anwendung richtig starten und beenden können. Wenn der Nutzer die App beispielsweise in den Hintergrund verschiebt, sollte die App nicht mehr auf Änderungen des Authentifizierungsstatus achten, um potenzielle Speicherlecks zu vermeiden.
Aktualisieren Sie authStateListener so, dass der Wert von FirebaseUserLiveData dem aktuellen Firebase-Nutzer entspricht.

FirebaseUserLiveData.kt

private val authStateListener = FirebaseAuth.AuthStateListener { firebaseAuth ->
   value = firebaseAuth.currentUser
}

Öffnen Sie LoginViewModel.kt.
Erstellen Sie in LoginViewModel.kt eine authenticationState-Variable basierend auf dem FirebaseUserLiveData-Objekt, das Sie gerade implementiert haben. Durch das Erstellen dieser authenticationState-Variablen können andere Klassen jetzt über LoginViewModel abfragen, ob der Nutzer angemeldet ist oder nicht.

LoginViewModel.kt

val authenticationState = FirebaseUserLiveData().map { user ->
   if (user != null) {
       AuthenticationState.AUTHENTICATED
   } else {
       AuthenticationState.UNAUTHENTICATED
   }
}

MainFragment.kt. öffnen
Im observeAuthenticationState() von MainFragment.kt können Sie die Variable authenticationState verwenden, die Sie gerade in LoginViewModel hinzugefügt haben, und die Benutzeroberfläche entsprechend ändern. Wenn ein Nutzer angemeldet ist, sollte in authButton die Option Abmelden angezeigt werden.

MainFragment.kt

private fun observeAuthenticationState() {
   val factToDisplay = viewModel.getFactToDisplay(requireContext())

   viewModel.authenticationState.observe(viewLifecycleOwner, Observer { authenticationState ->
       when (authenticationState) {
           LoginViewModel.AuthenticationState.AUTHENTICATED -> {
               binding.authButton.text = getString(R.string.logout_button_text)
               binding.authButton.setOnClickListener {
                   // TODO implement logging out user in next step
               }

                // TODO 2. If the user is logged in, 
                 // you can customize the welcome message they see by
                 // utilizing the getFactWithPersonalization() function provided

           }
           else -> {
               // TODO 3. Lastly, if there is no logged-in user, 
                // auth_button should display Login and
                //  launch the sign in screen when clicked.
           }
       }
   })
}

Wenn der Nutzer angemeldet ist, können Sie die Willkommensnachricht, die er sieht, auch mit der Funktion getFactWithPersonalization() anpassen, die in MainFragment
bereitgestellt wird.

MainFragment.kt

binding.welcomeText.text = getFactWithPersonalization(factToDisplay)

Wenn kein Nutzer angemeldet ist (wenn authenticationState etwas anderes als LoginViewModel.AuthenticationState.AUTHENTICATED ist), sollte in auth_button die Schaltfläche Anmelden angezeigt werden. Wenn der Nutzer darauf klickt, sollte der Anmeldebildschirm geöffnet werden. Die angezeigte Mitteilung sollte auch nicht personalisiert sein.

MainFragment.kt

binding.authButton.text = getString(R.string.login_button_text)
binding.authButton.setOnClickListener { launchSignInFlow() }
binding.welcomeText.text = factToDisplay

Nachdem Sie alle Schritte ausgeführt haben, sollte Ihre endgültige observeAuthenticationState()-Methode in etwa so aussehen:

MainFragment.kt

private fun observeAuthenticationState() {
   val factToDisplay = viewModel.getFactToDisplay(requireContext())

   viewModel.authenticationState.observe(viewLifecycleOwner, Observer { authenticationState ->
        // TODO 1. Use the authenticationState variable you just added 
         // in LoginViewModel and change the UI accordingly.
       when (authenticationState) {
            // TODO 2.  If the user is logged in, 
             // you can customize the welcome message they see by
             // utilizing the getFactWithPersonalization() function provided
           LoginViewModel.AuthenticationState.AUTHENTICATED -> {
               binding.welcomeText.text = getFactWithPersonalization(factToDisplay)
               binding.authButton.text = getString(R.string.logout_button_text)
               binding.authButton.setOnClickListener {
                   // TODO implement logging out user in next step
               }
           }
           else -> {
                // TODO 3. Lastly, if there is no logged-in user, 
                 // auth_button should display Login and
                 // launch the sign in screen when clicked.
               binding.welcomeText.text = factToDisplay

               binding.authButton.text = getString(R.string.login_button_text)
               binding.authButton.setOnClickListener {
                   launchSignInFlow()
               }
           }
       }
   })
}

Führen Sie Ihre App aus. Die Benutzeroberfläche sollte sich entsprechend dem Anmeldestatus des Nutzers aktualisieren. Wenn alles richtig funktioniert und Sie angemeldet sind, sollten Sie auf dem Startbildschirm jetzt mit Ihrem Namen begrüßt werden und zusätzlich einen Android-Fakt sehen. Auf der Schaltfläche Anmelden sollte jetzt auch Abmelden angezeigt werden.

In dieser Aufgabe implementieren Sie die Abmeldefunktion.

Da Nutzer sich in der App anmelden können, muss es auch eine Möglichkeit geben, sich wieder abzumelden. Hier ist ein Beispiel dafür, wie Sie einen Nutzer mit nur einer Codezeile abmelden:

AuthUI.getInstance().signOut(requireContext())

Öffnen Sie MainFragment.kt.
Fügen Sie in MainFragment.kt → observeAuthenticationState() die Abmeldelogik hinzu, damit die auth_button-Funktionen bei angemeldeten Nutzern korrekt ausgeführt werden. Das Endergebnis der Methode sieht so aus:

MainFragment.kt

private fun observeAuthenticationState() {
   val factToDisplay = viewModel.getFactToDisplay(requireContext())

   viewModel.authenticationState.observe(viewLifecycleOwner, Observer { authenticationState ->
       when (authenticationState) {
           LoginViewModel.AuthenticationState.AUTHENTICATED -> {
               binding.welcomeText.text = getFactWithPersonalization(factToDisplay)

               binding.authButton.text = getString(R.string.logout_button_text)
               binding.authButton.setOnClickListener {
                   AuthUI.getInstance().signOut(requireContext())
               }
           }
           else -> {
               binding.welcomeText.text = factToDisplay

               binding.authButton.text = getString(R.string.login_button_text)
               binding.authButton.setOnClickListener {
                   launchSignInFlow()
               }
           }
       }
   })
}

Starten Sie die App.
Tippen Sie auf die Schaltfläche Abmelden und prüfen Sie, ob der Nutzer abgemeldet ist und sich der Status der Schaltfläche in Anmelden ändert.

Die endgültige Version der fertigen App finden Sie unter https://github.com/googlecodelabs/android-kotlin-login.

In diesem Codelab haben Sie Folgendes gelernt:

So fügen Sie Ihrem Projekt Firebase hinzu, indem Sie die erforderlichen Abhängigkeiten in Ihrer Gradle-Datei hinzufügen und das Projekt in der Firebase Console einrichten.
Hier erfahren Sie, wie Sie die Anmeldung für Ihre App mithilfe der FirebaseUI-Bibliothek implementieren und festlegen, wie sich Nutzer anmelden dürfen. Beachten Sie, dass jedes Konto, das ein Nutzer in Ihrer App erstellt, nur für Ihre App gilt und nicht für alle Apps freigegeben wird, die Firebase für die Anmeldefunktion verwenden.
So beobachten Sie den aktuellen Authentifizierungsstatus Ihrer App mit LiveData.
Nutzer abmelden

In diesem Codelab wurden die Grundlagen für die Unterstützung der Anmeldung für eine Android-App behandelt.

In diesem Codelab haben Sie Nutzern ermöglicht, sich mit ihrer E-Mail-Adresse zu registrieren und anzumelden. Mit der FirebaseUI-Bibliothek können Sie jedoch auch andere Authentifizierungsmethoden wie die Anmeldung mit einer Telefonnummer unterstützen. Weitere Informationen zu den Funktionen der FirebaseUI-Bibliothek und zur Nutzung anderer Funktionen finden Sie in den folgenden Ressourcen:

Weitere Informationen zu Best Practices für die Anmeldung finden Sie in den folgenden Ressourcen:

Codelabs:

Android-Entwicklerdokumentation:

Videos:

Nutzerflüsse über die Anmeldung optimieren

Links zu anderen Codelabs in diesem Kurs finden Sie auf der Landingpage für Codelabs zum Thema „Android für Fortgeschrittene mit Kotlin“.

Android-Anmeldung mit FirebaseUI Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Einführung

Was Sie bereits wissen sollten

Lerninhalte

Aufgaben

Weitere Informationen zu LiveData und ViewModel

Schritt 1: Firebase-Projekt erstellen

Schritt 2: App bei Firebase registrieren

Schritt 3: Firebase-Konfigurationsdatei zum Projekt hinzufügen

Schritt 4: Android-Projekt für Firebase-Produkte konfigurieren

Schritt 4: Firebase-Abhängigkeit hinzufügen

Schritt 5: App ausführen und Code prüfen

Android-Anmeldung mit FirebaseUI