Android Academy · Lektion

Grundlagen von Cloud Firestore

Echtzeitdaten lesen und schreiben

Grundlagen von Cloud Firestore ist eine kostenlose Android Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Android Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Android Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Cloud Firestore?

Cloud Firestore ist die flexible, skalierbare NoSQL-Datenbank von Firebase. Sie speichert Daten als Dokumente, die in Collections gruppiert sind.

Ein Dokument besteht aus Schlüssel-Wert-Feldern (ähnlich einem JSON-Objekt).
Eine Collection ist ein Container für Dokumente.
Dokumente können Subcollections enthalten und so einen Baum bilden.

Firestore bietet außerdem Echtzeitaktualisierungen und funktioniert standardmäßig offline.

Die Firestore-Instanz abrufen

Greifen Sie über Firebase.firestore auf die Datenbank zu. Von dort aus erreichen Sie eine Collection mit collection("name") und ein bestimmtes Dokument mit document("id").

Referenzen lassen sich kostengünstig erstellen — sie beschreiben einen Ort, nicht die Daten selbst.

import com.google.firebase.Firebase
import com.google.firebase.firestore.firestore

val db = Firebase.firestore

val usersRef = db.collection("users")
val oneUser = db.collection("users").document("abc123")

Daten modellieren

Firestore lässt sich direkt auf Kotlin-Data-Classes abbilden. Jede Eigenschaft wird zu einem Feld im Dokument.

Stellen Sie einen Konstruktor ohne Argumente bereit (Standardwerte erledigen das), damit Firestore Dokumente wieder in Objekte deserialisieren kann.

data class Note(
    val title: String = "",
    val body: String = "",
    val done: Boolean = false,
    val createdAt: Long = 0L
)

Ein Dokument schreiben

Verwenden Sie set, um ein Dokument zu erstellen oder zu überschreiben. Lassen Sie Firestore mit add eine ID erzeugen oder wählen Sie mit document(id).set(...) Ihre eigene ID.

Diese Aufrufe geben Tasks zurück; mit Coroutines können Sie sie mit await() abwarten.

import com.google.firebase.Firebase
import com.google.firebase.firestore.firestore
import kotlinx.coroutines.tasks.await

suspend fun addNote(note: Note): String {
    val ref = Firebase.firestore
        .collection("notes")
        .add(note)          // auto-generated ID
        .await()
    return ref.id
}

Ein Dokument lesen

get() ruft ein Dokument einmalig ab. Wandeln Sie es mit toObject(Note::class.java) in Ihre Data-Class um.

Prüfen Sie immer exists() — eine Referenz auf ein nicht vorhandenes Dokument gibt einen Snapshot zurück, der schlicht nicht existiert.

import com.google.firebase.Firebase
import com.google.firebase.firestore.firestore
import kotlinx.coroutines.tasks.await

suspend fun loadNote(id: String): Note? {
    val snapshot = Firebase.firestore
        .collection("notes")
        .document(id)
        .get()
        .await()
    return if (snapshot.exists()) snapshot.toObject(Note::class.java) else null
}

Aktualisieren und löschen

update ändert bestimmte Felder, ohne den restlichen Inhalt des Dokuments anzutasten. delete entfernt das Dokument vollständig.

Verwenden Sie set(..., SetOptions.merge()), wenn Sie teilweise schreiben und das Dokument bei fehlendem Dokument gleichzeitig erstellen möchten.

import com.google.firebase.Firebase
import com.google.firebase.firestore.firestore
import kotlinx.coroutines.tasks.await

suspend fun markDone(id: String) {
    Firebase.firestore.collection("notes").document(id)
        .update("done", true)
        .await()
}

suspend fun removeNote(id: String) {
    Firebase.firestore.collection("notes").document(id)
        .delete()
        .await()
}

Eine Collection abfragen

Erstellen Sie Abfragen, indem Sie Filter verketten: whereEqualTo, whereGreaterThan, orderBy, limit und weitere.

Eine Abfrage gibt einen QuerySnapshot zurück. Durchlaufen Sie dessen Dokumente, um jedes in Ihr Modell umzuwandeln.

import com.google.firebase.Firebase
import com.google.firebase.firestore.firestore
import kotlinx.coroutines.tasks.await

suspend fun pendingNotes(): List<Note> {
    val snap = Firebase.firestore.collection("notes")
        .whereEqualTo("done", false)
        .orderBy("createdAt")
        .limit(20)
        .get()
        .await()
    return snap.documents.mapNotNull { it.toObject(Note::class.java) }
}

Echtzeit-Listener

Die besondere Stärke von Firestore ist die Echtzeitfähigkeit. addSnapshotListener liefert sofort die aktuellen Daten und übermittelt anschließend automatisch jede Änderung.

Die Methode gibt eine ListenerRegistration zurück. Rufen Sie remove() auf, wenn Sie fertig sind, um keine weiteren Aktualisierungen zu empfangen.

import com.google.firebase.Firebase
import com.google.firebase.firestore.firestore

val registration = Firebase.firestore.collection("notes")
    .whereEqualTo("done", false)
    .addSnapshotListener { snapshot, error ->
        if (error != null || snapshot == null) return@addSnapshotListener
        val notes = snapshot.toObjects(Note::class.java)
        println("Now have ${notes.size} pending notes")
    }

// Later: registration.remove()

Echtzeitdaten als Flow

In Compose ist es üblich, Firestore als Kotlin-Flow bereitzustellen. callbackFlow überträgt den Listener-Callback in einen Flow, und awaitClose entfernt den Listener, wenn die Sammlung beendet wird.

import com.google.firebase.Firebase
import com.google.firebase.firestore.firestore
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.callbackFlow

fun notesFlow(): Flow<List<Note>> = callbackFlow {
    val reg = Firebase.firestore.collection("notes")
        .addSnapshotListener { snap, err ->
            if (err == null && snap != null) {
                trySend(snap.toObjects(Note::class.java))
            }
        }
    awaitClose { reg.remove() }
}

Daten in Compose anzeigen

Sammeln Sie den Flow mit collectAsStateWithLifecycle() und stellen Sie ihn in einer LazyColumn dar. Die Liste aktualisiert sich bei jeder Änderung in Firestore selbst — eine manuelle Aktualisierung ist nicht erforderlich.

@Composable
fun NotesScreen(viewModel: NotesViewModel) {
    val notes by viewModel.notes.collectAsStateWithLifecycle()

    LazyColumn {
        items(notes) { note ->
            ListItem(
                headlineContent = { Text(note.title) },
                supportingContent = { Text(note.body) }
            )
        }
    }
}

Sicherheitsregeln sind wichtig

Standardmäßig ist Firestore gesperrt. Sicherheitsregeln legen fest, wer jeden Pfad lesen oder schreiben darf — sie werden auf dem Server ausgeführt und können vom Client nicht umgangen werden.

Eine häufige Regel lautet: Ein Benutzer darf nur auf seine eigenen Daten zugreifen, die über seine Authentifizierungs-uid bestimmt werden.

// firestore.rules
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /users/{userId}/{document=**} {
      allow read, write: if request.auth != null
                         && request.auth.uid == userId;
    }
  }
}

Kurze Überprüfung

Sie möchten eine Compose-Liste erstellen, die sich sofort aktualisiert, sobald sich die zugrunde liegenden Firestore-Daten ändern, ohne manuelle Aktualisierung. Welche API verwenden Sie?

Zusammenfassung: Firestore

Sie können Daten jetzt mit Cloud Firestore speichern und synchronisieren:

Daten liegen als Dokumente in Collections vor; modellieren Sie sie mit Kotlin-Data-Classes.
Schreiben Sie mit add/set, lesen Sie mit get und ändern oder löschen Sie mit update/delete.
Führen Sie Abfragen mit whereEqualTo, orderBy und limit aus.
Verwenden Sie addSnapshotListener (oder einen callbackFlow) für eine Echtzeit-Benutzeroberfläche.
Schützen Sie Daten mit Sicherheitsregeln, die auf request.auth.uid basieren.

Als Nächstes erreichen Sie Benutzer auch dann, wenn die App geschlossen ist, mit Cloud Messaging.

Häufig gestellte Fragen

Ist die Lektion „Grundlagen von Cloud Firestore“ kostenlos?

Ja — der vollständige Text von „Grundlagen von Cloud Firestore“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Android Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Android Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Grundlagen von Cloud Firestore“?

Echtzeitdaten lesen und schreiben Du übst Android Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Android Academy zu starten?

Keine Vorkenntnisse erforderlich. Android Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Grundlagen von Cloud Firestore“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Android Academy-Lektion Code schreiben und ausführen?

Ja. Jede Android Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Firebase einrichten
Firebase Authentication
Grundlagen von Cloud Firestore
Push-Benachrichtigungen mit Cloud Messaging

← Zurück zu Android Academy