Firebase Cloud Firestore

# CHAPTER 24

Firebase Cloud Firestore #

1. Introduction #

2. Learning Objectives #

• Contrast Relational SQL databases (Room) with Document NoSQL databases (Firestore).

• Configure Firestore dependencies within the Android project.

• Write (Create/Update) Document data to specific Collections.

• Read (Fetch) Documents utilizing asynchronous Tasks.

• Implement Real-Time Snapshot Listeners to automatically update the UI upon cloud changes.

• Secure data utilizing Firebase Security Rules.

3. Understanding NoSQL Architecture #

• Collection: A folder (e.g., users, messages, posts).

• Document: A specific file inside that folder containing data in a JSON-like format (e.g., user_john_doe).

*Path Example:* users (Collection) -> user_id_123 (Document) -> { name: "John", age: 30 } (Data) A Document can even contain *more* Collections (Subcollections), allowing for deep, hierarchical data structuring.

4. Setup and Configuration #

1. 1. Go to the Firebase Console -> Firestore Database -> Click Create Database.

1. 2. Start in Test Mode (This allows reading/writing without security rules for 30 days while developing).

1. 3. Choose a location close to you.

1. 4. In your Android Studio build.gradle.kts (Module :app), add the dependency:

implementation("com.google.firebase:firebase-firestore")

5. Writing Data (Create / Update) #

import android.util.Log
import com.google.firebase.firestore.FirebaseFirestore

val db = FirebaseFirestore.getInstance()

fun saveUserProfile(userId: String, name: String, age: Int) {
    // 1. Package the data into a Map
    val userMap = hashMapOf(
        "fullName" to name,
        "age" to age,
        "premiumMember" to false
    )

    // 2. Target the Collection ("users") and the specific Document (the userId)
    // .set() creates the document if it doesn't exist, or OVERWRITES it if it does!
    db.collection("users").document(userId)
        .set(userMap)
        .addOnSuccessListener {
            Log.d("Firestore", "Document successfully written!")
        }
        .addOnFailureListener { e ->
            Log.w("Firestore", "Error writing document", e)
        }
}

6. Reading Data (Fetch Once) #

fun fetchUserProfile(userId: String) {
    db.collection("users").document(userId)
        .get() // .get() fetches the data exactly ONCE
        .addOnSuccessListener { document ->
            if (document != null && document.exists()) {
                // Extract the data using the Keys we defined!
                val name = document.getString("fullName")
                val age = document.getLong("age") // Firestore stores ints as Longs!
                
                println("User Found: $name, Age: $age")
            } else {
                println("No such document!")
            }
        }
        .addOnFailureListener { exception ->
            println("Fetch failed: $exception")
        }
}

7. Real-Time Snapshot Listeners (The Magic) #

fun listenForNewMessages() {
    // Attach listener to the "messages" collection
    db.collection("messages")
        .addSnapshotListener { snapshots, e ->
            if (e != null) {
                Log.w("Firestore", "Listen failed.", e)
                return@addSnapshotListener
            }

            // This block executes IMMEDIATELY when any data in the collection changes!
            for (doc in snapshots!!.documentChanges) {
                println("New Message Arrived: ${doc.document.getString("text")}")
            }
        }
}

8. Custom Kotlin Objects (POJOs) #

// Must have default values for Firestore mapping to work!
data class UserProfile(
    val fullName: String = "",
    val age: Int = 0,
    val premiumMember: Boolean = false
)

// Fetching directly into the Object:
db.collection("users").document(userId).get().addOnSuccessListener { doc ->
    val profile = doc.toObject(UserProfile::class.java)
    println(profile?.fullName) // Boom! Automatic parsing!
}

9. Common Mistakes #

• Security Rules in Production: "Test Mode" allows anyone with your project ID to delete your entire database. Before launching to the Google Play Store, you MUST write Firestore Security Rules to lock down the database (e.g., allow read, write: if request.auth != null;).

• Ignoring Indexes: If you write a complex query like db.collection("users").whereEqualTo("age", 25).orderBy("name"), Firestore will crash your app with an error containing a URL. You must click that URL to automatically build an Index in the Firebase Console, otherwise, the query cannot execute.

10. Best Practices #

• Cost Optimization: Firestore charges money per *Document Read*. If you have a collection of 10,000 messages, and you accidentally query the entire collection every time the screen rotates, you will rack up a massive bill. Always use .limit(20) to paginate data, and rely on local caching where possible.

11. Exercises #

1. 1. Setup Firestore in the Console. Write a function that creates a new document in a products collection with name and price fields.

1. 2. Verify the document appeared instantly in the web-based Firebase Console.

12. Coding Challenges #

13. MCQ Quiz with Answers #

14. Interview Questions #

• Q: Explain the structural mechanics of mapping a Firestore Document directly to a custom Kotlin Data Class via .toObject(). Why is it imperative that the Data Class constructor contains default values?

• Q: Contrast the operational definitions of .set(), .add(), and .update() within the Firestore API. Under what conditions would an .update() call purposefully fail?

• Q: Detail the financial implications of poor NoSQL query design. How does structuring data hierarchically (Subcollections) mitigate runaway "Document Read" billing issues?

15. FAQs #

16. Summary #

17. Next Chapter Recommendation #