Android Academy · Leçon

Principes de Cloud Firestore

Lisez et écrivez des données en temps réel.

Principes de Cloud Firestore est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 4 leçons au total.

Qu'est-ce que Cloud Firestore ?

Cloud Firestore est la base de données NoSQL flexible et évolutive de Firebase. Elle stocke les données sous forme de documents regroupés en collections.

Un document est un ensemble de champs clé/valeur (comme un objet JSON).
Une collection est un conteneur de documents.
Les documents peuvent contenir des sous-collections, formant ainsi un arbre.

Firestore propose également des mises à jour en temps réel et fonctionne hors connexion dès le départ.

Obtenir l'instance Firestore

Accédez à la base de données via Firebase.firestore. Vous pouvez ensuite accéder à une collection avec collection("name") et à un document précis avec document("id").

Les références sont peu coûteuses à créer — elles décrivent un emplacement, et non les données elles-mêmes.

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")

Modéliser les données

Firestore s'adapte naturellement aux classes de données Kotlin. Chaque propriété devient un champ du document.

Fournissez-lui un constructeur sans argument (les valeurs par défaut suffisent) afin que Firestore puisse désérialiser les documents pour les reconvertir en objets.

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

Écrire un document

Utilisez set pour créer ou écraser un document. Laissez Firestore générer un identifiant avec add, ou choisissez votre propre identifiant avec document(id).set(...).

Ces appels renvoient des tâches ; avec des coroutines, vous pouvez les utiliser avec await().

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
}

Lire un document

get() récupère un document une seule fois. Convertissez-le en instance de votre classe de données avec toObject(Note::class.java).

Vérifiez toujours exists() — une référence vers un document manquant renvoie un instantané qui n'existe tout simplement pas.

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
}

Mettre à jour et supprimer

update modifie certains champs sans toucher au reste du document. delete supprime entièrement le document.

Utilisez set(..., SetOptions.merge()) si vous voulez effectuer une écriture partielle qui crée également le document lorsqu'il est absent.

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

Interroger une collection

Construisez vos requêtes en enchaînant des filtres : whereEqualTo, whereGreaterThan, orderBy, limit, et bien d'autres.

Une requête renvoie un QuerySnapshot ; parcourez ses documents pour convertir chacun d'eux dans votre modèle.

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

Écouteurs en temps réel

La fonctionnalité phare de Firestore est le temps réel. addSnapshotListener fournit immédiatement les données actuelles, puis transmet automatiquement chaque modification.

Cette fonction renvoie un ListenerRegistration — appelez remove() lorsque vous avez terminé pour arrêter de recevoir les mises à jour.

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()

Les données en temps réel sous forme de Flow

Dans Compose, il est idiomatique d'exposer Firestore sous forme de Flow Kotlin. callbackFlow relie le rappel de l'écouteur à un flux, et awaitClose supprime l'écouteur lorsque la collecte s'arrête.

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

Afficher les données dans Compose

Collectez le flux avec collectAsStateWithLifecycle() et affichez-le dans une LazyColumn. La liste se met à jour automatiquement chaque fois que Firestore change — aucun actualisation manuelle n'est nécessaire.

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

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

L'importance des règles de sécurité

Par défaut, Firestore est verrouillé. Les règles de sécurité déterminent qui peut lire ou écrire sur chaque chemin — elles s'exécutent sur le serveur et le client ne peut pas les contourner.

Une règle courante consiste à n'autoriser un utilisateur à accéder qu'à ses propres données, identifiées par son uid d'authentification.

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

Vérification rapide

Vous voulez une liste Compose qui se mette instantanément à jour chaque fois que les données Firestore sous-jacentes changent, sans actualisation manuelle. Quelle API utilisez-vous ?

Récapitulatif : Firestore

Vous savez maintenant stocker et synchroniser des données avec Cloud Firestore :

Les données sont stockées sous forme de documents dans des collections ; modélisez-les avec des classes de données Kotlin.
Écrivez avec add/set, lisez avec get, modifiez avec update/delete.
Effectuez des requêtes avec whereEqualTo, orderBy et limit.
Utilisez addSnapshotListener (ou un callbackFlow) pour une interface utilisateur en temps réel.
Protégez les données avec des règles de sécurité basées sur request.auth.uid.

Ensuite : atteindre les utilisateurs lorsque l'application est fermée avec Cloud Messaging.

Questions Fréquemment Posées

La leçon « Principes de Cloud Firestore » est-elle gratuite ?

Oui — le texte complet de « Principes de Cloud Firestore » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Principes de Cloud Firestore » ?

Lisez et écrivez des données en temps réel. Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Principes de Cloud Firestore » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy