0Pricing
Android Academy · Lezione

Nozioni di base su Cloud Firestore

Legga e scriva dati in tempo reale

Nozioni di base su Cloud Firestore è una lezione Android Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Android Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Android Academy include 4 lezioni in totale.

Che cos'è Cloud Firestore?

Cloud Firestore è il database NoSQL flessibile e scalabile di Firebase. Salva i dati come documenti raggruppati in raccolte.

  • Un documento è un insieme di campi chiave/valore (come un oggetto JSON).
  • Una raccolta è un contenitore di documenti.
  • I documenti possono contenere sottoraccolte, formando una struttura ad albero.

Firestore offre anche aggiornamenti in tempo reale e funziona offline senza configurazioni aggiuntive.

Ottenere l'istanza di Firestore

Acceda al database tramite Firebase.firestore. Da lì può raggiungere una raccolta con collection("name") e un documento specifico con document("id").

Creare riferimenti è un'operazione leggera: descrivono una posizione, non i dati in sé.

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

Modellare i dati

Firestore si integra in modo naturale con le data class di Kotlin. Ogni proprietà diventa un campo del documento.

Fornisca un costruttore senza argomenti (i valori predefiniti sono sufficienti) affinché Firestore possa deserializzare nuovamente i documenti in oggetti.

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

Scrivere un documento

Usi set per creare o sovrascrivere un documento. Lasci che Firestore generi un ID con add, oppure scelga personalmente l'ID con document(id).set(...).

Queste chiamate restituiscono dei Task; con le coroutine può usare 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
}

Leggere un documento

get() recupera un documento una sola volta. Lo converta nella propria data class con toObject(Note::class.java).

Controlli sempre exists(): un riferimento a un documento inesistente restituisce uno snapshot che semplicemente non esiste.

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
}

Aggiornare ed eliminare

update modifica campi specifici senza alterare il resto del documento. delete rimuove interamente il documento.

Usi set(..., SetOptions.merge()) se desidera una scrittura parziale che crei anche il documento quando non esiste.

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

Interrogare una raccolta

Costruisca le query concatenando i filtri: whereEqualTo, whereGreaterThan, orderBy, limit e altri.

Una query restituisce un QuerySnapshot; scorra i documenti per trasformare ciascuno di essi nel proprio modello.

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

Listener in tempo reale

Il punto di forza di Firestore è il funzionamento in tempo reale. addSnapshotListener fornisce immediatamente i dati correnti e poi invia automaticamente ogni modifica.

Restituisce un ListenerRegistration: chiami remove() quando ha terminato, per interrompere la ricezione degli aggiornamenti.

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

Dati in tempo reale come Flow

In Compose, è idiomatico esporre Firestore come un Flow Kotlin. callbackFlow collega il callback del listener a un flow, mentre awaitClose rimuove il listener quando la raccolta si interrompe.

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

Mostrare i dati in Compose

Raccolga il flow con collectAsStateWithLifecycle() e lo visualizzi in una LazyColumn. L'elenco si aggiorna da solo ogni volta che Firestore cambia: non è necessario alcun aggiornamento manuale.

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

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

Le regole di sicurezza sono importanti

Per impostazione predefinita, Firestore è protetto. Le regole di sicurezza stabiliscono chi può leggere o scrivere in ogni percorso: vengono eseguite sul server e il client non può aggirarle.

Una regola comune è consentire a un utente di accedere esclusivamente ai propri dati, identificati dal proprio uid di autenticazione.

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

Verifica rapida

Desidera creare in Compose un elenco che si aggiorni immediatamente ogni volta che cambiano i dati sottostanti di Firestore, senza aggiornamenti manuali. Quale API deve usare?

Riepilogo: Firestore

Ora può salvare e sincronizzare i dati con Cloud Firestore:

  • I dati sono organizzati in documenti all'interno di raccolte; li modelli con le data class di Kotlin.
  • Scriva con add/set, legga con get, modifichi con update/delete.
  • Esegua query con whereEqualTo, orderBy, limit.
  • Usi addSnapshotListener (o un callbackFlow) per un'interfaccia utente in tempo reale.
  • Protegga i dati con regole di sicurezza basate su request.auth.uid.

Avanti: raggiungere gli utenti quando l'app è chiusa con Cloud Messaging.

Domande Frequenti

La lezione «Nozioni di base su Cloud Firestore» è gratuita?

Sì — il testo completo di «Nozioni di base su Cloud Firestore» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Android Academy, passa a CoddyKit PRO. Il corso Android Academy include 4 lezioni in totale.

Cosa imparerò in «Nozioni di base su Cloud Firestore»?

Legga e scriva dati in tempo reale Eserciti Android Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Android Academy?

Non è richiesta alcuna esperienza precedente. Android Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Nozioni di base su Cloud Firestore»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Android Academy?

Sì. Ogni lezione Android Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Configurare Firebase
  2. Autenticazione Firebase
  3. Nozioni di base su Cloud Firestore
  4. Inviare notifiche con Cloud Messaging
← Torna a Android Academy