If you’ve been eyeing the concept of building a chat application, you’re in for a treat! In this blog, we’re diving into the joys and nuances of implementing a one-to-one chat system using Firebase. The best part? You can create a working version within a single day. Let’s take a closer look at why Firebase might be the right choice for your chat app.

Why Implement Chat with Firebase?

Firebase offers an array of features that can make your development process smoother.

Pros of Using Firebase:

• Real-time Database: Simply add appropriate listeners in your app, and voila—you’ll be notified whenever there’s an update in the database.
• User-Friendly JSON Format: Firebase uses a JSON format (key-value pairs), making it straightforward for anyone familiar with JSON data.
• Fast and Efficient: With automatic offline state management, you don’t need to worry about connectivity issues.
• Built-in Authentication: Firebase provides an authentication system for easy login/signup functionalities.

Cons of Using Firebase:

• No Built-in Push Notifications: Firebase doesn’t offer a straightforward API for sending push notifications without a separate backend.
• Lack of Encryption: You’ll need to implement your own encryption for secure chatting.

Setting Up Firebase Dependencies

Before diving into the coding, we need to add the necessary dependencies to your project. Follow these steps:

1. Project Level build.gradle:

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

2. App Level build.gradle:

Add the following Firebase dependencies in the dependencies section:

implementation 'com.google.firebase:firebase-database:9.6.1'

implementation 'com.google.firebase:firebase-messaging:9.6.1'

implementation 'com.google.firebase:firebase-auth:9.6.1'

Finally, don’t forget to apply the Google services plugin at the end of your app level build.gradle file:

apply plugin: 'com.google.gms.google-services'

And, ensure you add google-services.json to your app module.

Understanding Firebase Database Structure

Before we start coding in Android Studio, it’s essential to understand how the Firebase database is structured. Firebase organizes data in a JSON format, allowing for easy access and modification. Think of it like a digital filing cabinet where each drawer is labeled and contains files (data) organized within it.

Creating Model Classes for Our Chat Application

To create an efficient chat system, we need to establish proper model classes.

User.java

public class User {
    public String uid;
    public String email;
    public String firebaseToken;

    public User() {} // Empty constructor required by Firebase

    public User(String uid, String email, String firebaseToken) {
        this.uid = uid;
        this.email = email;
        this.firebaseToken = firebaseToken;
    }
}

Chat.java

public class Chat {
    public String sender;
    public String receiver;
    public String senderUid;
    public String receiverUid;
    public String message;
    public long timestamp;

    public Chat() {} // Empty constructor required by Firebase

    public Chat(String sender, String receiver, String senderUid, String receiverUid, String message, long timestamp) {
        this.sender = sender;
        this.receiver = receiver;
        this.senderUid = senderUid;
        this.receiverUid = receiverUid;
        this.message = message;
        this.timestamp = timestamp;
    }
}

Do remember to include an empty constructor; this is crucial as it prevents crashes in Firebase.

Adding Users to the Database

The process of adding users can be streamlined through FirebaseAuth. Here’s how:

public void addUserToDatabase(Context context, FirebaseUser firebaseUser) {
    User user = new User(firebaseUser.getUid(), firebaseUser.getEmail(), new SharedPrefUtil(context).getString(Constants.ARG_FIREBASE_TOKEN));
    FirebaseDatabase.getInstance()
        .getReference()
        .child(Constants.ARG_USERS)
        .child(firebaseUser.getUid())
        .setValue(user)
        .addOnCompleteListener(new OnCompleteListener() {
            @Override
            public void onComplete(@NonNull Task task) {
                if (task.isSuccessful()) {
                    // Successfully added user
                } else {
                    // Failed to add user
                }
            }
        });
}

Getting the List of Users

To facilitate chatting, it’s essential to show the list of available users:

public void getAllUsersFromFirebase() {
    FirebaseDatabase.getInstance()
        .getReference()
        .child(Constants.ARG_USERS)
        .addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                Iterator dataSnapshots = dataSnapshot.getChildren().iterator();
                List users = new ArrayList<>();
                while (dataSnapshots.hasNext()) {
                    DataSnapshot dataSnapshotChild = dataSnapshots.next();
                    User user = dataSnapshotChild.getValue(User.class);
                    if (!TextUtils.equals(user.uid, FirebaseAuth.getInstance().getCurrentUser().getUid())) {
                        users.add(user);
                    }
                }
            }
            @Override
            public void onCancelled(DatabaseError databaseError) {
                // Unable to retrieve the users.
            }
        });
}

Creating Chat Rooms

A chat room consists of two users—the currently logged-in user and the user they want to chat with. Think of a chat room as a snug space where only two friends can connect privately.

public void sendMessageToFirebaseUser(final Context context, final Chat chat, final String receiverFirebaseToken) {
    final String room_type_1 = chat.senderUid + "_" + chat.receiverUid; 
    final String room_type_2 = chat.receiverUid + "_" + chat.senderUid; 
    
    final DatabaseReference databaseReference = FirebaseDatabase.getInstance().getReference();
    databaseReference.child(Constants.ARG_CHAT_ROOMS).getRef()
        .addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                if (dataSnapshot.hasChild(room_type_1)) {
                    databaseReference.child(Constants.ARG_CHAT_ROOMS)
                        .child(room_type_1)
                        .child(String.valueOf(chat.timestamp))
                        .setValue(chat);
                } else {
                    databaseReference.child(Constants.ARG_CHAT_ROOMS)
                        .child(room_type_2)
                        .child(String.valueOf(chat.timestamp))
                        .setValue(chat);
                }
            }
            @Override
            public void onCancelled(DatabaseError databaseError) {
                // Unable to send message.
            }
        });
}

Using this method allows you to seamlessly send messages between users, creating an interactive chat experience.

Troubleshooting

If you encounter issues while implementing Firebase chat, here are some troubleshooting tips:

• Ensure your database rules are correctly configured in your Firebase console.
• Check if the required dependencies are correctly added to your build.gradle files.
• Make sure your Firebase project settings match the app configuration.
• For push notifications, ensure that each user has a generated Firebase token.
• If problems persist, consult the Firebase documentation for detailed explanations and examples.

For more insights, updates, or to collaborate on AI development projects, stay connected with fxis.ai.

At fxis.ai, we believe that such advancements are crucial for the future of AI, as they enable more comprehensive and effective solutions. Our team is continually exploring new methodologies to push the envelope in artificial intelligence, ensuring that our clients benefit from the latest technological innovations.

Conclusion

With the configuration steps and code snippets provided, you should now be adept at creating a one-to-one chat system with Firebase. No additional backend is needed, just pure efficiency and the power of Firebase working in your favor! Happy coding!