Build a Real-Time Chat App with Firebase Integration in Kotlin: Complete Android Tutorial

Firebase integration has become an essential skill for Android developers who want to build scalable, real-time applications without managing backend infrastructure. In this comprehensive tutorial, we'll build a fully functional real-time chat application that demonstrates Firebase Authentication, Cloud Firestore, and proper Firebase integration patterns in Kotlin.

WHAT YOU'LL BUILD

Our chat application will feature user authentication, real-time message synchronization, and a clean Material Design interface. By the end of this project, you'll understand how to structure Firebase integration in production-ready Android apps and handle common challenges like offline persistence and security rules.

SETTING UP FIREBASE IN YOUR ANDROID PROJECT

First, create a new Android project in Android Studio with an Empty Activity. Navigate to the Firebase Console and create a new project. Add your Android app by registering your package name, then download the google-services.json file and place it in your app directory.

Add the following dependencies to your project-level build.gradle:

classpath 'com.google.gms:google-services:4.4.0'

In your app-level build.gradle, add:

plugins {
    id 'com.google.gms.google-services'
}

dependencies {
    implementation platform('com.google.firebase:firebase-bom:32.7.0')
    implementation 'com.google.firebase:firebase-auth-ktx'
    implementation 'com.google.firebase:firebase-firestore-ktx'
}

IMPLEMENTING FIREBASE AUTHENTICATION

Create a FirebaseAuthManager class to handle authentication logic. This separation of concerns makes your code more testable and maintainable:

class FirebaseAuthManager {
    private val auth = Firebase.auth
    
    suspend fun signUp(email: String, password: String): Result {
        return try {
            val result = auth.createUserWithEmailAndPassword(email, password).await()
            Result.success(result.user)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
    
    suspend fun signIn(email: String, password: String): Result {
        return try {
            val result = auth.signInWithEmailAndPassword(email, password).await()
            Result.success(result.user)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
    
    fun getCurrentUser() = auth.currentUser
    fun signOut() = auth.signOut()
}

CREATING THE FIRESTORE DATA MODEL

Design your chat message structure with proper timestamp handling and user information. Create a data class that maps cleanly to Firestore documents:

data class ChatMessage(
    val messageId: String = "",
    val senderId: String = "",
    val senderName: String = "",
    val text: String = "",
    val timestamp: Long = System.currentTimeMillis()
)

IMPLEMENTING REAL-TIME MESSAGE LISTENING

Create a repository class to manage Firestore operations. Use Flow to emit real-time updates to your UI layer:

class ChatRepository {
    private val db = Firebase.firestore
    private val messagesCollection = db.collection("messages")
    
    fun getMessages(): Flow> = callbackFlow {
        val listener = messagesCollection
            .orderBy("timestamp", Query.Direction.ASCENDING)
            .addSnapshotListener { snapshot, error ->
                if (error != null) {
                    close(error)
                    return@addSnapshotListener
                }
                val messages = snapshot?.documents?.mapNotNull {
                    it.toObject(ChatMessage::class.java)
                } ?: emptyList()
                trySend(messages)
            }
        awaitClose { listener.remove() }
    }
    
    suspend fun sendMessage(message: ChatMessage) {
        messagesCollection.document().set(message).await()
    }
}

BUILDING THE UI WITH RECYCLERVIEW

Create a RecyclerView adapter to display messages with different view types for sent and received messages. Implement proper ViewHolder patterns and use DiffUtil for efficient updates when new messages arrive in real-time.

HANDLING OFFLINE PERSISTENCE

Enable offline persistence in your Application class to allow users to read and write data even without network connectivity. Firebase will automatically synchronize changes when connectivity is restored:

Firebase.firestore.firestoreSettings = firestoreSettings {
    isPersistenceEnabled = true
}

SECURITY RULES AND BEST PRACTICES

Never leave your Firestore database open to public access. Implement proper security rules in the Firebase Console to ensure users can only read and write their own messages. Always validate user authentication before performing database operations.

Ready to master Firebase integration and build production-ready Android apps? Android Dev (Kotlin) by Benjamin Koikoi provides in-depth coverage of Firebase, architecture patterns, and modern Android development practices. Get your copy for just $1 on Gumroad and Amazon KDP and accelerate your Android development journey today!