Build a Real-Time In-App Chat in Android Using PubNub (Kotlin + MVVM) – Complete Tutorial Series

 


Want to add real-time chat to your Android app without building an entire backend?

In this tutorial series, you'll learn how to create a modern, scalable real-time in-app chat using Kotlin, the MVVM architecture, and PubNub — a robust platform built specifically for real-time communication.

This post is your go-to index for the entire series. I’ll update it with links as each part goes live. Bookmark it now!

Why PubNub?

PubNub is a real-time communication platform that removes the complexity of building low-latency messaging and presence systems. Here’s what it offers out of the box:

🔧 Core Features for Android (Kotlin)

  • Real-Time Messaging – Send and receive messages across any number of devices instantly.
  • Message Persistence – Store and retrieve message history.
  • User Presence – Detect when users come online or go offline.
  • Typing Indicators – Show “User is typing…” live updates.
  • Channel Groups – Organize multiple chatrooms or group threads.
  • Push Notifications – Integrate with FCM to alert users of new messages.
  • Access Manager (PAM) – Control who can publish/subscribe to channels.
  • File & Media Sharing – Send files or images directly within chat.
  • Message Reactions & Metadata – Add context to any message.
  • Low-Latency & Scalability – Designed to support millions of messages per second.

Tutorial Series Index

✅ = Live  🔄 = Coming Soon (links will be added as they're published)

✅ 1. Introduction

What we’re building,why real-time chat matters, and why PubNub is a solid choice.
Read Part 1

🔄 2. Project Setup (Kotlin + MVVM + PubNub SDK)

Create a new Android project, add MVVM structure, and connect to PubNub.

🔄 3. PubNub Initialization & Basic Messaging

Set up PubNub in the repository layer, and start sending/receiving basic text messages in real time.

🔄 4. Designing the Chat UI

Build a clean chat screen using RecyclerView, message bubbles, and input fields.

🔄 5. Implementing Message Sending

Capture user input, structure message payloads, and publish them through PubNub.

🔄 6. Subscribing & Receiving Messages

Listen for messages in real time and update the UI reactively using LiveData.

🔄 7. Chat History & Persistence

Fetch previous messages using PubNub’s history API and support pagination.

🔄 8. Presence & Typing Indicators

Show when users are online/offline and when they’re actively typing.

🔄 9. Reconnection & Error Handling

Handle network issues gracefully and ensure a reliable chat experience even under bad connectivity.

🔄 10. File & Image Sharing

Upload files, share image URLs in messages, and preview them in the chat window.

🔄 11. Push Notifications with FCM

Set up Firebase Cloud Messaging to alert users when messages arrive in the background.

🔄 12. Group Chat & Multi-Channel Support

Use PubNub’s channel and channel group system to manage multiple chat threads and rooms.

🔄 13. Security with Access Manager (PAM)

Implement user-level access control and protect your keys from unauthorized use.

🔄 14. Reactions, Metadata & Message Enrichment

Use PubNub’s objects and metadata features to add reactions, timestamps, and user info to messages.

🔄 15. Testing, Debugging & Wrapping Up

Final tweaks, testing best practices, and extending the app beyond chat (voice, bots, analytics).

Tech Stack

  • Language: Kotlin

  • Architecture: MVVM

  • Platform: Android

  • Libraries: PubNub SDK, LiveData, ViewModel, RecyclerView, FCM (optional)

  • Extras: Firebase (optional), Glide, Retrofit (for media handling)

Stay Updated

Follow me on Medium or bookmark this series to stay updated as each part is released.

Questions or Ideas?

Got a use case in mind? Want to see a certain feature added?
Drop a comment below, or connect with me on X (formerly Twitter) @revansiddappa1. Let’s build this together — one feature at a time.

Are you ready to bring your Android app to life with chat? Let’s get started! 


Comments

Post a Comment

Popular posts from this blog

Kotlin Some important unsorted interview questions and answers

Image
  What is inline class in Kotlin and when do we need one? Provide an example.  What is inline class in Kotlin and when do we need one? Provide an example. Senior Answer Sometimes it is necessary for business logic to create a wrapper around some type. However, it introduces runtime overhead due to additional heap allocations. Moreover, if the wrapped type is primitive, the performance hit is terrible, because primitive types are usually heavily optimized by the runtime. Inline classes  provide us with a way to wrap a type, thus adding functionality and creating a new type by itself. As opposed to regular (non-inlined) wrappers, they will benefit from improved performance. This happens because the data is inlined into its usages, and object instantiation is skipped in the resulting compiled code. inline class Name ( val s : String ) { val length : Int get ( ) = s . length fun greet ( ) { println ( "Hello, $s " ) } } fun ma...
Read more

A Reusable MVVM API Call Pattern in Jetpack Compose

Image
Building scalable Android apps requires clean architecture—and one of the best ways to manage your UI and logic is by combining MVVM with Jetpack Compose . However, API calls can get messy when not structured properly. In this post, I’ll show you how to build a reusable, clean API call structure using MVVM that works for any screen in your app. We'll use: ViewModel to manage UI-related data Repository for business logic and network State management using mutableStateOf Retrofit for networking This is not tied to any specific screen (like sliders, onboarding, etc.)—you can plug in your own model and API. Why a Reusable Pattern? Apps often repeat the same logic: Show loader Fetch data Handle errors Update UI Instead of repeating it everywhere, we'll abstract it once and just extend or plug in what’s needed per screen. 1. Define a Generic API Result Wrapper This wrapper lets us handle success, loading, and error states in a consisten...
Read more

Most Developers Build Offline-First Apps Wrong — Here's What They Miss with Room

Image
  When you say your app works offline… does it really? A surprising number of Android developers proudly add “offline-first” to their app descriptions. And sure, the app opens without internet. Maybe it even loads a few screens. But dig a little deeper and it becomes clear: most offline-first implementations fall apart fast. Why? Because building an offline-first experience isn’t about just storing data locally. It’s about doing it intentionally , with the right structure, cleanup, and flow. And the culprit behind most of the silent issues? Room Database. Not because Room is bad — but because it's misunderstood. Let’s walk through some of the most common mistakes developers make when using Room in offline-first apps — and what to do instead. Mistake 1: Saving the Entire API Response into Room Many devs take the raw JSON response from their API and store it directly into Room entities — every field, every nested object, even things the app never uses. Why it’s a probl...
Read more