Creating a Firebase-Based Chat Application

Course: Android App Development

Topic: Creating a Firebase-Based Chat Application

Course Link: Android App Development Course

Demo Link: Register for a Free Course Demo

Website: JustAcademy

1. Introduction to Firebase-Based Chat Applications

A Firebase-based chat application is an Android application that allows users to exchange messages in real time using Firebase services. It can support individual conversations, user authentication, message synchronization, online status, and push notifications.

Firebase provides cloud-based backend services that reduce the need to create and maintain a custom messaging server. Android developers can integrate these services to build responsive, scalable, and secure communication applications.

A typical chat application includes a login screen, user list, conversation screen, message input field, and a cloud database that synchronizes messages between participants.

Key Features

• User registration and login.
• Real-time sending and receiving of messages.
• Conversation history and message timestamps.
• User profiles and contact lists.
• Message delivery and read status, when implemented.
• Push notifications for incoming messages.
• Secure access to conversations and user data.

2. Learning Objectives

After completing this topic, learners should be able to:

• Understand Firebase services used in Android chat applications.
• Configure a Firebase project and connect it to Android Studio.
• Implement user registration and authentication.
• Store and retrieve messages using a Firebase database.
• Display messages in a RecyclerView.
• Implement real-time message listeners.
• Apply Firebase security rules and basic error handling.
• Test and improve a chat application's performance and reliability.

3. Technologies Required

Important: Cloud Firestore and Realtime Database are alternatives for storing chat messages. You do not need both. This tutorial uses Cloud Firestore as the primary message database.

4. Understanding Firebase Services

4.1 Firebase Authentication

Firebase Authentication provides identity management for application users. Email and password authentication is a common choice for a beginner chat application.

Authentication provides a unique user ID, commonly accessed through the authenticated user's UID. The UID can be used to associate messages and conversations with the correct users.

4.2 Cloud Firestore

Cloud Firestore is a NoSQL document database. Data is stored in collections and documents rather than traditional relational tables.

A chat application can use Firestore to store user profiles, conversation metadata, and individual messages. Snapshot listeners allow the application to react to database changes without repeatedly refreshing the screen.

4.3 Firebase Cloud Messaging

Firebase Cloud Messaging allows a backend service to send notifications to devices. A production chat application generally uses a trusted backend or Cloud Functions to determine when a notification should be sent.

Never place Firebase Admin SDK credentials or server secrets inside the Android application.

4.4 Firebase Security Rules

Security rules determine which authenticated users can read or write particular documents. They are essential because an Android application cannot be trusted to enforce access restrictions on its own.

5. Application Architecture

A simple Firebase chat application can be divided into the following layers:

1. Presentation layer: Login, registration, user list, and chat screens.
2. Application logic: Validates input, manages navigation, and coordinates messaging actions.
3. Authentication layer: Identifies the currently signed-in user.
4. Data layer: Reads and writes user, conversation, and message documents.
5. Notification layer: Sends incoming-message notifications through a trusted backend.

Basic Message Flow

Sender opens a conversation
          |
          v
Types and sends a message
          |
          v
Android app validates the input
          |
          v
Message is written to Cloud Firestore
          |
          v
Firestore updates active listeners
          |
          v
Recipient's chat screen displays the message
          |
          v
Optional push notification is delivered

The recipient's device does not need to poll the database continuously. A Firestore snapshot listener can receive updates while the relevant screen is active and connected.

6. Setting Up the Firebase Project

Step 1: Create a Firebase Project

1. Open the Firebase Console.
2. Create a new project and provide a suitable project name.
3. Follow the setup instructions and enable Google Analytics if required.
4. Open the project dashboard after setup is complete.

Step 2: Register the Android Application

1. Open your Android project in Android Studio.
2. Find the application's package name or application ID in the Gradle configuration.
3. Register an Android app in the Firebase project using the exact application ID.
4. Download the google-services.json configuration file.
5. Place the file in the Android app module directory, normally app/.

The registered application ID must match the Android application's configured ID. If the ID changes, update the Firebase registration as needed.

Step 3: Add Firebase Dependencies

Use the Firebase Android setup instructions to configure the Google Services Gradle plugin and Firebase dependencies. Prefer the Firebase Android BoM so compatible Firebase library versions are managed together.

A Kotlin DSL dependency example for the app module is shown below. Ensure that the Google Services plugin has also been configured in the project.

dependencies {
    implementation(platform("com.google.firebase:firebase-bom:YOUR_BOM_VERSION"))
    implementation("com.google.firebase:firebase-auth")
    implementation("com.google.firebase:firebase-firestore")
}

Replace YOUR_BOM_VERSION with the current version recommended by the official Firebase setup documentation. Do not copy a placeholder as a real dependency version.

Official reference: Firebase setup for Android.

Step 4: Enable Authentication

1. Open Authentication in the Firebase Console.
2. Select the sign-in providers section.
3. Enable Email/Password if that is the method used by your application.
4. Save the configuration.

Step 5: Create a Firestore Database

1. Open Firestore Database in the Firebase Console.
2. Create a database in the appropriate mode and region.
3. Choose a region suitable for your expected users and latency requirements.
4. Configure security rules before releasing the application.

7. Designing the Application Screens

A basic chat application can contain the following screens:

Example Chat Screen Layout

----------------------------------
|          Chat with Alex        |
----------------------------------
| Alex: Hi!                      |
| You: Hello!                    |
| Alex: How are you?             |
|                                |
|                                |
----------------------------------
| Type a message...     [Send]   |
----------------------------------

Use separate message item layouts for sent and received messages. This makes conversations easier to read and helps users identify who sent each message.

8. Designing the Firestore Data Structure

A simple and scalable data structure separates user profiles, conversation metadata, and message documents.

users
  └── USER_UID
       ├── displayName
       ├── email
       └── photoUrl

conversations
  └── CONVERSATION_ID
       ├── participantIds
       ├── lastMessage
       ├── lastMessageAt
       └── messages
            └── MESSAGE_ID
                 ├── senderId
                 ├── text
                 ├── sentAt
                 └── type

In Firestore, the messages collection shown above can be a subcollection inside each conversation document.

Suggested Message Fields

For a direct conversation between two users, derive a stable conversation ID from both UIDs by sorting them consistently and combining them safely. This prevents the two participants from accidentally creating separate conversation IDs for the same pair.

Do not use email addresses or other easily guessable user information as a substitute for proper authorization. The database must verify that the signed-in user is a participant in the conversation.

9. Implementing User Registration

Firebase Authentication can create an account using an email address and password. After account creation, the application can store a public profile document in Firestore.

The following Kotlin example demonstrates the main authentication operation. Add suitable imports and connect the function to your registration screen.

import com.google.firebase.auth.FirebaseAuth

private val auth: FirebaseAuth by lazy {
    FirebaseAuth.getInstance()
}

fun registerUser(
    email: String,
    password: String,
    onResult: (Boolean, String?) -> Unit
) {
    val cleanEmail = email.trim()

    if (cleanEmail.isEmpty() || password.isEmpty()) {
        onResult(false, "Enter an email and password.")
        return
    }

    auth.createUserWithEmailAndPassword(
        cleanEmail,
        password
    ).addOnCompleteListener { task ->
        if (task.isSuccessful) {
            onResult(true, null)
        } else {
            onResult(
                false,
                task.exception?.localizedMessage
                    ?: "Registration failed."
            )
        }
    }
}

After registration, obtain the current user's UID and create the associated profile document. Validate the display name and handle profile-write failures separately so the interface can report incomplete setup accurately.

10. Implementing User Login

Existing users can sign in using Firebase Authentication. A successful sign-in provides the identity needed to read authorized conversations.

fun loginUser(
    email: String,
    password: String,
    onResult: (Boolean, String?) -> Unit
) {
    val cleanEmail = email.trim()

    if (cleanEmail.isEmpty() || password.isEmpty()) {
        onResult(false, "Enter your email and password.")
        return
    }

    auth.signInWithEmailAndPassword(
        cleanEmail,
        password
    ).addOnCompleteListener { task ->
        if (task.isSuccessful) {
            onResult(true, null)
        } else {
            onResult(
                false,
                task.exception?.localizedMessage
                    ?: "Login failed."
            )
        }
    }
}

After login, navigate to the user list or conversation list. Check authentication state when the app starts so that signed-in users do not need to log in again unnecessarily.

11. Saving User Profiles

User profile documents provide the information needed to display names and optional profile images. Store the UID as the document ID and allow users to update only permitted profile fields.

import com.google.firebase.firestore.FirebaseFirestore

val db = FirebaseFirestore.getInstance()

fun saveUserProfile(
    uid: String,
    displayName: String,
    email: String
) {
    val profile = mapOf(
        "displayName" to displayName.trim(),
        "email" to email.trim()
    )

    db.collection("users")
        .document(uid)
        .set(profile)
}

For production code, attach a completion listener, show meaningful errors, and ensure the rules prevent users from modifying another user's profile. Do not treat the email field stored in Firestore as verified merely because it exists.

12. Sending a Message to Firestore

When a user presses the Send button, the app should validate the message, identify the current user, and write a message document to the selected conversation's messages subcollection.

import com.google.firebase.Timestamp
import com.google.firebase.firestore.FieldValue

fun sendMessage(
    conversationId: String,
    messageText: String,
    onResult: (Boolean, String?) -> Unit
) {
    val currentUser = auth.currentUser
    val cleanText = messageText.trim()

    if (currentUser == null) {
        onResult(false, "Please sign in first.")
        return
    }

    if (cleanText.isEmpty()) {
        onResult(false, "Message cannot be empty.")
        return
    }

    val message = hashMapOf(
        "senderId" to currentUser.uid,
        "text" to cleanText,
        "sentAt" to FieldValue.serverTimestamp(),
        "type" to "text"
    )

    db.collection("conversations")
        .document(conversationId)
        .collection("messages")
        .add(message)
        .addOnSuccessListener {
            onResult(true, null)
        }
        .addOnFailureListener { error ->
            onResult(
                false,
                error.localizedMessage ?: "Message could not be sent."
            )
        }
}

The server timestamp provides a consistent time reference. A newly written message may initially contain an unresolved timestamp locally until the server confirms the write.

This example assumes the conversation document already exists and its security rules verify membership. A complete implementation should also update conversation metadata such as the latest message and activity time in a controlled, consistent way.

13. Receiving Messages in Real Time

A snapshot listener listens for database changes and allows the chat screen to update when new messages arrive. Query messages in ascending timestamp order so they appear in conversation order.

import com.google.firebase.firestore.ListenerRegistration
import com.google.firebase.firestore.Query

fun listenForMessages(
    conversationId: String,
    onMessagesChanged: (List<Map<String, Any>>) -> Unit,
    onError: (String) -> Unit
): ListenerRegistration {
    return db.collection("conversations")
        .document(conversationId)
        .collection("messages")
        .orderBy("sentAt", Query.Direction.ASCENDING)
        .addSnapshotListener { snapshot, error ->
            if (error != null) {
                onError(
                    error.localizedMessage ?: "Unable to load messages."
                )
                return@addSnapshotListener
            }

            val messages = snapshot?.documents?.mapNotNull {
                it.data
            } ?: emptyList()

            onMessagesChanged(messages)
        }
}

Keep a reference to the returned listener registration and remove the listener when it is no longer needed. In a lifecycle-aware application, use a ViewModel and an appropriate lifecycle-aware collection mechanism to avoid unnecessary listeners and memory leaks.

For a production chat screen, map Firestore documents into a typed Message data class containing the document ID, sender ID, text, and timestamp. Typed models make UI rendering and testing easier.

14. Displaying Messages with RecyclerView

RecyclerView efficiently displays large or changing lists of messages. A typical implementation uses a message model, an XML item layout, a RecyclerView adapter, and a layout manager.

Steps to Implement

1. Create a Message data class with sender, text, timestamp, and document ID.
2. Create a layout for each message bubble.
3. Implement a RecyclerView adapter to bind message data to each item.
4. Use different layouts or view types for sent and received messages.
5. Update the adapter when the listener provides new messages.
6. Scroll to the newest message when appropriate, without interrupting users reading older messages.

For better performance, use ListAdapter with DiffUtil instead of rebuilding the entire list after each update.

Example Message Model

data class Message(
    val id: String = "",
    val senderId: String = "",
    val text: String = "",
    val sentAt: Long? = null
)

When reading Firestore data, convert its timestamp field to milliseconds only after checking that the value is a valid Firestore Timestamp. Handle missing or pending timestamps gracefully.

15. Distinguishing Sent and Received Messages

Compare each message's sender ID with the current authenticated user's UID. This determines which bubble style should be displayed.

val isSentByCurrentUser =
    message.senderId == auth.currentUser?.uid

For messages sent by the current user, align the bubble to the right. For messages received from another participant, align it to the left. Use readable text, sufficient spacing, and accessible contrast.

16. Managing Conversation Lists

The conversation list screen allows users to return to existing chats. Each conversation document can contain participant IDs, a latest-message preview, and a server timestamp for sorting.

Useful conversation-list fields include:

• Conversation ID.
• Participant UIDs.
• Last message preview.
• Last activity timestamp.
• Optional unread-message count for each participant.

Query only conversations in which the current user is a participant. Firestore may require a composite index for certain combinations of filters and ordering. Follow the index creation link provided by Firebase when a legitimate query requires one.

17. Adding Message Read Status

Read status indicates whether a recipient has opened or read a message. It can be implemented using a readBy map, a separate per-user read-state document, or another suitable schema.

A simple design may track the last-read message or timestamp for each participant rather than writing a separate read update to every message. This can reduce the number of database writes in large conversations.

Read status must be updated only by an authorized participant. If the interface shows delivery and read indicators, define exactly what each status means and avoid presenting an unconfirmed state as a guarantee.

18. Adding Push Notifications

Real-time database listeners work when the relevant application components are active, but they are not a substitute for background push notifications. Firebase Cloud Messaging can notify a recipient about a new message when the app is not open.

Implementation Overview

1. Add Firebase Cloud Messaging to the Android project.
2. Implement a Firebase messaging service or the appropriate notification handling mechanism.
3. Obtain and securely manage the device's FCM registration token.
4. Store the token through an authenticated, controlled backend workflow.
5. Trigger notification delivery from a trusted server or Cloud Function when a message is created.
6. Handle notification taps by opening the correct conversation after validating access.

On Android 13 and later, apps generally need to request the POST_NOTIFICATIONS runtime permission before displaying ordinary notifications. Ask at an appropriate point in the user experience and handle denial gracefully.

Do not send push notifications directly using privileged server credentials embedded in the app. Notification payloads should avoid exposing sensitive message content unnecessarily.

Official reference: Firebase Cloud Messaging for Android.

19. Implementing Firebase Security Rules

Security rules are a critical part of chat application development. Authentication alone does not guarantee that a user can access only their own conversations.

A conceptual Firestore rule for a conversation checks that the authenticated user's UID is included in the conversation's participant list. The same membership condition should protect its messages.

rules_version = '2';

service cloud.firestore {
  match /databases/{database}/documents {

    function signedIn() {
      return request.auth != null;
    }

    function isParticipant(conversationId) {
      return signedIn()
        && request.auth.uid in
          get(/databases/$(database)/documents/conversations/$(conversationId))
          .data.participantIds;
    }

    match /conversations/{conversationId} {
      allow read: if isParticipant(conversationId);

      match /messages/{messageId} {
        allow read: if isParticipant(conversationId);
      }
    }
  }
}

Security note: This is an illustrative starting point, not a complete production ruleset. It does not grant message writes, validate message contents, or secure user profiles. Add carefully tested rules for creating conversations, sending messages, updating metadata, and managing membership. Validate that clients cannot change participant lists to gain access or overwrite protected fields.

For example, a message-write rule should check that the sender ID matches request.auth.uid, the text is valid and within a defined length limit, and the parent conversation exists with the authenticated user as a participant. Validate permitted fields and types as well.

Never use open production rules that allow unrestricted reads and writes. Test rules with the Firebase Emulator Suite before deploying them.

Official reference: Get started with Cloud Firestore Security Rules.

20. Handling Errors and Network Conditions

Messaging applications must handle temporary connectivity problems and rejected database operations without confusing the user.

Provide loading indicators, empty states, retry actions, and clear error messages. Avoid exposing raw stack traces, authentication tokens, or private database details to end users.

21. Improving Performance and Scalability

• Use paginated queries to load older messages instead of loading the entire conversation.
• Order messages by timestamp and use document cursors for pagination.
• Remove snapshot listeners when screens are no longer active.
• Use RecyclerView with efficient list-diffing strategies.
• Keep documents reasonably small and avoid unnecessary duplicate fields.
• Use transactions or batched writes where appropriate for related updates.
• Monitor Firestore reads, writes, storage usage, and billing.
• Use Firebase App Check where appropriate to help protect backend resources from unauthorized clients.
• Test slow networks, offline conditions, and rapid message sending.

Cloud Firestore supports offline persistence on Android, but the UI must still handle pending writes, synchronization conflicts, and failures when connectivity returns.

22. Testing the Firebase Chat Application

Testing should cover both normal conversation behavior and security boundaries.

Functional Test Cases

Recommended Testing Tools

• Android Emulator and physical Android devices.
• Firebase Console for checking authentication and database records.
• Firebase Emulator Suite for local development and rules testing.
• JUnit for unit tests.
• Espresso for Android UI tests.
• Crash reporting and analytics tools for production diagnostics, configured with appropriate privacy controls.

23. Common Development Mistakes

• Incorrect application ID: Ensure it matches the Firebase app registration.
• Missing configuration file: Verify that google-services.json is in the correct module directory.
• Missing dependencies: Check the Firebase BoM, plugins, and Gradle synchronization.
• Open database rules: Restrict reads and writes using authenticated identity and conversation membership.
• Wrong conversation ID: Use a consistent deterministic ID strategy for direct conversations.
• Unmanaged listeners: Remove listeners when they are no longer needed.
• Unordered message queries: Use a timestamp field and appropriate ordering.
• Missing error handling: Handle task failures and permission errors explicitly.
• Client-trusted notifications: Trigger privileged notification operations from a trusted backend.

24. Mini Project: Firebase-Based Real-Time Chat Application

Project objective: Build an Android messaging application that allows registered users to sign in, find another user, exchange text messages, and retrieve conversation history.

Core Requirements

• Registration and login using Firebase Authentication.
• User profile creation and display.
• A user list or conversation list.
• One-to-one messaging through Cloud Firestore.
• Real-time message updates.
• Message timestamps and sent/received bubble layouts.
• Secure conversation access using Firestore rules.
• Loading, empty, and error states.

Optional Advanced Features

• Profile photos using Firebase Storage.
• Typing indicators and online presence.
• Read receipts and unread-message counts.
• Push notifications using Firebase Cloud Messaging.
• Image and document attachments.
• Group conversations.
• Message search, deletion, and moderation controls.

Suggested Development Plan

1. Create the Android project and connect Firebase.
2. Implement registration, login, and sign-out.
3. Create user profile documents and the user list.
4. Build conversation creation and membership validation.
5. Implement message sending and real-time retrieval.
6. Build message bubbles and conversation history.
7. Write and test Firestore security rules.
8. Test network failures, multiple users, and application lifecycle behavior.
9. Add optional notifications and prepare a project demonstration.

25. Best Practices

• Use a clear separation between UI, business logic, and database operations.
• Keep Firebase configuration and dependency versions consistent with official documentation.
• Use Firebase Authentication UIDs for user identity.
• Validate inputs before attempting database writes.
• Enforce authorization in Firebase Security Rules and trusted backend code.
• Do not store passwords directly in Firestore.
• Do not embed service-account credentials or privileged secrets in the Android application.
• Use server timestamps for consistent message ordering.
• Provide retry behavior for failed writes without generating duplicate messages.
• Use lifecycle-aware listeners and test for memory leaks.
• Review data retention, user privacy, and deletion requirements before release.

26. Interview Questions and Answers

Q1. What is Firebase?

Firebase is a development platform that offers services such as authentication, cloud databases, messaging, analytics, and crash reporting.

Q2. Why is Firebase useful for chat applications?

It provides managed authentication and data services, real-time synchronization, and integrations that reduce the amount of backend infrastructure developers must build themselves.

Q3. What is Firebase Authentication?

It is a service that verifies user identity and manages supported sign-in methods and authentication sessions.

Q4. What is Cloud Firestore?

Cloud Firestore is a NoSQL document database that stores data in collections and documents and supports real-time listeners.

Q5. What is the difference between Firestore and Realtime Database?

Firestore uses collections and documents and provides flexible queries. Realtime Database uses a JSON tree and can be useful for low-latency synchronized data and certain presence use cases. The right choice depends on application requirements.

Q6. How are messages updated in real time?

A Firestore snapshot listener observes a query and reports changes so the UI can update without repeatedly polling the database.

Q7. What is a Firebase UID?

It is the unique identifier associated with a Firebase Authentication user and can be used to associate profile and conversation records with that user.

Q8. Why are Firestore Security Rules important?

They enforce access control and validation at the database boundary, preventing unauthorized users from reading or modifying protected records.

Q9. What is Firebase Cloud Messaging?

FCM is a service for delivering push notifications and data messages to supported client applications.

Q10. How can duplicate messages be prevented?

Use stable message IDs or carefully designed idempotent write operations, and ensure retries do not create a new document for the same logical message.

Q11. Why should snapshot listeners be removed?

Removing listeners when they are no longer needed prevents unnecessary reads, duplicate callbacks, and resource leaks.

Q12. How can a chat application be tested securely?

Test both valid participant access and unauthorized access, use the Firebase Emulator Suite for rules tests, and verify that users cannot read or modify another conversation.

27. Quick Revision Checklist

• Firebase project created and Android app registered.
• Firebase dependencies and configuration installed.
• Authentication provider enabled.
• User registration, login, and sign-out implemented.
• User profiles stored securely.
• Conversation and message schema designed.
• Message sending and receiving implemented.
• RecyclerView displays messages in the correct order.
• Snapshot listeners are managed according to the app lifecycle.
• Firestore rules restrict access to authorized participants.
• Errors, network interruptions, and pending writes are handled.
• Tests cover messaging, authentication, and security.

28. Conclusion

Creating a Firebase-based chat application is a practical way to learn Android development, cloud databases, authentication, and real-time communication. By combining Firebase Authentication with Cloud Firestore, developers can build a messaging foundation without maintaining a custom messaging server.

A complete application requires more than sending and displaying messages. Secure database rules, reliable error handling, lifecycle-aware listeners, appropriate notification handling, and thorough testing are essential for a dependable user experience.

Continue learning through the JustAcademy Android App Development Course, explore the course demo registration page, and visit the JustAcademy website for additional learning resources.

End of Notes: Creating a Firebase-Based Chat Application