top of page
  • Writer's pictureRobin Alex Panicker

How to Integrate Firebase Firestore with Kotlin and Use it in Android Apps


How to Integrate Firebase Firestore with Kotlin and Use it in Android Apps

Firestore is a NoSQL document database provided by Firebase, which is a platform developed by Google. It offers seamless integration with Android applications, enabling developers to store and synchronize data in real-time.


In this tutorial, we will explore how to integrate Firestore with Kotlin and leverage its capabilities to perform CRUD (Create, Read, Update, Delete) operations in an Android app.


Prerequisites


Before we begin, make sure you have the following set up:

  1. Android Studio: Download and install the latest version of Android Studio from the official website.

  2. Firebase Account: Create a Firebase account and set up a new project.

  3. Firestore: Enable Firestore in your Firebase project.


1. Set up Firebase Project in Android Studio


  1. Open Android Studio and create a new project or open an existing one.

  2. Navigate to the Firebase console (https://console.firebase.google.com/) and select your project.

  3. Click on "Add app" and follow the instructions to add your Android app to the project. Provide the package name of your app when prompted.

  4. Download the google-services.json file and place it in the app directory of your Android project.


2. Add Firestore Dependency

  1. Open the build.gradle file for your app module.

  2. Add the following dependency to the dependencies block:

implementation 'com.google.firebase:firebase-firestore-ktx:23.0.3'


3. Initialize Firestore

  1. Open your app's main activity or the class where you want to use Firestore.

  2. Add the following code to initialize Firestore within the onCreate method:

import com.google.firebase.firestore.FirebaseFirestore

// ...
val db = FirebaseFirestore.getInstance()


4. Create Data


To create a new document in Firestore, use the set() method. Let's assume we have a User data class with name and age properties:

data class User(val name: String = "", val age: Int = 0)

// ...
val user = User("John Doe", 25)

db.collection("users")
    .document("user1")
    .set(user)
    .addOnSuccessListener {
        // Document created successfully
    }
    .addOnFailureListener { e ->
        // Handle any errors
    }


5. Read Data


To retrieve a document from Firestore, use the get() method:

db.collection("users")
    .document("user1")
    .get()
    .addOnSuccessListener { document ->
        if (document != null && document.exists()) {
            val user = document.toObject(User::class.java)
            // Use the user object
        } else {
            // Document doesn't exist
        }
    }
    .addOnFailureListener { e ->
        // Handle any errors
    }


6. Update Data


To update a document in Firestore, use the update() method:

val newData = mapOf(
    "name" to "Jane Smith",
    "age" to 30
)

db.collection("users")
    .document("user1")
    .update(newData)
    .addOnSuccessListener {
        // Document updated successfully
    }
    .addOnFailureListener { e ->
        // Handle any errors
    }


7. Delete Data


To delete a document in Firestore, use the delete() method:

db.collection("users")
    .document("user1")
    .delete()
    .addOnSuccessListener {
        // Document deleted successfully
    }
    .addOnFailureListener { e ->
        // Handle any errors
    }


Conclusion


Integrating Firestore with Kotlin in your Android app allows you to leverage the power of a NoSQL document database for efficient data storage and real-time synchronization. In this tutorial, we covered the essential steps to integrate Firestore, including initialization, creating, reading, updating, and deleting data. Firestore's simplicity and scalability make it an excellent choice for building robust Android applications with offline support and real-time data synchronization.


Remember to handle exceptions, implement proper security rules, and consider Firestore's pricing model for larger-scale projects. Firestore provides a powerful API that you can further explore to enhance your app's functionality.


Happy coding!

Blog for Mobile App Developers, Testers and App Owners

 

This blog is from Finotes Team. Finotes is a lightweight mobile APM and bug detection tool for iOS and Android apps.

In this blog we talk about iOS and Android app development technologies, languages and frameworks like Java, Kotlin, Swift, Objective-C, Dart and Flutter that are used to build mobile apps. Read articles from Finotes team about good programming and software engineering practices, testing and QA practices, performance issues and bugs, concepts and techniques. 

bottom of page