diff --git a/docs.json b/docs.json
index 172825868..ac2e4a6b4 100644
--- a/docs.json
+++ b/docs.json
@@ -1590,7 +1590,8 @@
"ui-kit/android/v6/ai-features"
]
},
- "ui-kit/android/v6/call-features"
+ "ui-kit/android/v6/call-features",
+ "ui-kit/android/v6/campaigns"
]
},
{
@@ -1636,7 +1637,8 @@
"ui-kit/android/v6/call-buttons",
"ui-kit/android/v6/call-logs",
"ui-kit/android/v6/search",
- "ui-kit/android/v6/ai-assistant-chat-history"
+ "ui-kit/android/v6/ai-assistant-chat-history",
+ "ui-kit/android/v6/notification-feed"
]
},
{
@@ -3979,6 +3981,12 @@
"sdk/android/v5/reactions"
]
},
+ {
+ "group": "Campaigns",
+ "pages": [
+ "sdk/android/v5/campaigns"
+ ]
+ },
"sdk/android/v5/calling-overview",
{
"group": "Users",
@@ -9683,4 +9691,4 @@
"redirect": true
}
}
-}
+}
\ No newline at end of file
diff --git a/sdk/android/v5/campaigns.mdx b/sdk/android/v5/campaigns.mdx
new file mode 100644
index 000000000..5028fc574
--- /dev/null
+++ b/sdk/android/v5/campaigns.mdx
@@ -0,0 +1,600 @@
+---
+title: "Campaigns"
+---
+
+CometChat Campaigns lets you deliver targeted, rich notifications to users via an in-app notification feed. Each notification is a **Card Schema JSON** — a structured layout rendered natively by the CometChat Cards library.
+
+The SDK provides APIs to fetch feed items, listen for real-time delivery, mark items as read/delivered, report engagement, and retrieve unread counts.
+
+---
+
+## Key Concepts
+
+| Concept | Description |
+| --- | --- |
+| **NotificationFeedItem** | A single notification in the feed. Contains Card Schema JSON in its `content` field, a `category` for filtering, timestamps, and metadata. |
+| **NotificationCategory** | A category label used for filter chips (e.g., "Promotions", "Updates"). |
+| **Card Schema JSON** | The fully rendered card layout (images, text, buttons) inside `NotificationFeedItem.getContent()`. Passed directly to the CometChat Cards renderer. |
+| **PushNotification** | Represents a campaign push notification payload received via FCM. |
+
+---
+
+## How Cards Render in the Notification Feed
+
+Each `NotificationFeedItem` has a `content` field containing a `JSONObject` — this is the **Card Schema JSON**. This JSON is passed directly to the **CometChat Cards** renderer library (`com.cometchat:cards-android`).
+
+The rendering flow:
+
+1. Fetch feed items via `NotificationFeedRequest`
+2. For each item, extract `item.getContent()` — this is the Card Schema JSON
+3. Convert to string: `item.getContent().toString()`
+4. Pass to the Cards renderer (`CometChatCardView` or `CometChatCardComposable`)
+5. The renderer produces a native Android view from the JSON
+
+### Card Schema JSON Structure
+
+```json
+{
+ "version": "1.0",
+ "body": [
+ { "type": "image", "id": "img_1", "url": "https://...", "height": 200 },
+ { "type": "text", "id": "txt_1", "content": "Flash Sale!", "variant": "heading2" },
+ { "type": "button", "id": "btn_1", "label": "Shop Now", "action": { "type": "openUrl", "url": "https://..." } }
+ ],
+ "style": { "background": {"light": "#FFFFFF", "dark": "#1E1E1E"}, "borderRadius": 12, "padding": 16 },
+ "fallbackText": "Flash Sale! Shop Now: https://..."
+}
+```
+
+The `body` array contains elements (text, image, button, row, column, etc.) rendered top-to-bottom. Interactive elements like buttons emit actions via a callback — the consumer handles navigation, deep links, or API calls.
+
+---
+
+## Retrieve Notification Feed Items
+
+Use `NotificationFeedRequest` to fetch a paginated list of feed items. Uses cursor-based pagination internally.
+
+### Build the Request
+
+
+
+```java
+NotificationFeedRequest request = new NotificationFeedRequest.NotificationFeedRequestBuilder()
+ .setLimit(20)
+ .build();
+```
+
+
+```kotlin
+val request = NotificationFeedRequest.NotificationFeedRequestBuilder()
+ .setLimit(20)
+ .build()
+```
+
+
+
+### Builder Parameters
+
+| Method | Type | Default | Description |
+| --- | --- | --- | --- |
+| `setLimit(int)` | int | 20 | Items per page (max 100) |
+| `setReadState(FeedReadState)` | enum | `ALL` | Filter by `READ`, `UNREAD`, or `ALL` |
+| `setCategory(String)` | String | null | Filter by category ID |
+| `setChannelId(String)` | String | null | Filter by channel |
+| `setTags(List)` | List | null | Filter by tags |
+| `setDateFrom(String)` | String | null | ISO 8601 date — items sent on or after |
+| `setDateTo(String)` | String | null | ISO 8601 date — items sent on or before |
+
+### Fetch Items
+
+
+
+```java
+request.fetchNext(new CometChat.CallbackListener>() {
+ @Override
+ public void onSuccess(List items) {
+ for (NotificationFeedItem item : items) {
+ String cardJson = item.getContent().toString();
+ // Pass cardJson to CometChatCardView or CometChatCardComposable
+ }
+ }
+
+ @Override
+ public void onError(CometChatException e) {
+ Log.e("Feed", "Error: " + e.getMessage());
+ }
+});
+```
+
+
+```kotlin
+request.fetchNext(object : CometChat.CallbackListener>() {
+ override fun onSuccess(items: List) {
+ items.forEach { item ->
+ val cardJson = item.content.toString()
+ // Pass cardJson to CometChatCardView or CometChatCardComposable
+ }
+ }
+
+ override fun onError(e: CometChatException) {
+ Log.e("Feed", "Error: ${e.message}")
+ }
+})
+```
+
+
+
+Call `fetchNext()` repeatedly for pagination. When the server has no more items, subsequent calls return an empty list.
+
+### NotificationFeedItem Fields
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `id` | String | Unique item identifier |
+| `category` | String | Notification category (e.g., "promotions") |
+| `content` | JSONObject | Card Schema JSON — pass to CometChat Cards renderer |
+| `readAt` | Long? | Unix timestamp when read, or null if unread |
+| `deliveredAt` | Long? | Unix timestamp when delivered, or null |
+| `sentAt` | long | Unix timestamp when sent |
+| `metadata` | HashMap | Custom key-value metadata |
+| `tags` | List\ | Tags for filtering |
+| `sender` | String | Sender identifier |
+| `receiver` | String | Receiver identifier |
+| `receiverType` | String | Receiver type |
+
+---
+
+## Retrieve Notification Categories
+
+Use `NotificationCategoriesRequest` to fetch available categories for filter chips.
+
+
+
+```java
+NotificationCategoriesRequest categoriesRequest = new NotificationCategoriesRequest
+ .NotificationCategoriesRequestBuilder()
+ .setLimit(50)
+ .build();
+
+categoriesRequest.fetchNext(new CometChat.CallbackListener>() {
+ @Override
+ public void onSuccess(List categories) {
+ for (NotificationCategory category : categories) {
+ Log.d("Feed", "Category: " + category.getName());
+ }
+ }
+
+ @Override
+ public void onError(CometChatException e) {
+ Log.e("Feed", "Error: " + e.getMessage());
+ }
+});
+```
+
+
+```kotlin
+val categoriesRequest = NotificationCategoriesRequest.NotificationCategoriesRequestBuilder()
+ .setLimit(50)
+ .build()
+
+categoriesRequest.fetchNext(object : CometChat.CallbackListener>() {
+ override fun onSuccess(categories: List) {
+ categories.forEach { category ->
+ Log.d("Feed", "Category: ${category.name}")
+ }
+ }
+
+ override fun onError(e: CometChatException) {
+ Log.e("Feed", "Error: ${e.message}")
+ }
+})
+```
+
+
+
+### NotificationCategory Fields
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `id` | String | Category identifier |
+| `name` | String | Display name for filter UI |
+| `description` | String | Category description |
+| `appId` | String | Associated app ID |
+
+---
+
+## Real-Time Notification Feed Listener
+
+Listen for new feed items arriving via WebSocket. This listener is independent from `MessageListener`, `GroupListener`, and `CallListener`.
+
+
+
+```java
+CometChat.addNotificationFeedListener("feedListener", new NotificationFeedListener() {
+ @Override
+ public void onFeedItemReceived(NotificationFeedItem feedItem) {
+ Log.d("Feed", "New item: " + feedItem.getId());
+ String cardJson = feedItem.getContent().toString();
+ // Insert at top of feed and render
+ }
+});
+```
+
+
+```kotlin
+CometChat.addNotificationFeedListener("feedListener", object : NotificationFeedListener() {
+ override fun onFeedItemReceived(feedItem: NotificationFeedItem) {
+ Log.d("Feed", "New item: ${feedItem.id}")
+ val cardJson = feedItem.content.toString()
+ // Insert at top of feed and render
+ }
+})
+```
+
+
+
+Remove the listener when no longer needed:
+
+
+
+```java
+CometChat.removeNotificationFeedListener("feedListener");
+```
+
+
+```kotlin
+CometChat.removeNotificationFeedListener("feedListener")
+```
+
+
+
+---
+
+## Mark Feed Item as Read
+
+Mark a single item as read. Idempotent — safe to call multiple times.
+
+
+
+```java
+CometChat.markFeedItemAsRead(feedItem, new CometChat.CallbackListener() {
+ @Override
+ public void onSuccess(Void unused) {
+ Log.d("Feed", "Marked as read");
+ }
+
+ @Override
+ public void onError(CometChatException e) {
+ Log.e("Feed", "Error: " + e.getMessage());
+ }
+});
+```
+
+
+```kotlin
+CometChat.markFeedItemAsRead(feedItem, object : CometChat.CallbackListener() {
+ override fun onSuccess(result: Void?) {
+ Log.d("Feed", "Marked as read")
+ }
+
+ override fun onError(e: CometChatException) {
+ Log.e("Feed", "Error: ${e.message}")
+ }
+})
+```
+
+
+
+---
+
+## Mark Feed Item as Delivered
+
+Mark a single item as delivered. Idempotent.
+
+
+
+```java
+CometChat.markFeedItemAsDelivered(feedItem, new CometChat.CallbackListener() {
+ @Override
+ public void onSuccess(Void unused) {
+ // Success
+ }
+
+ @Override
+ public void onError(CometChatException e) {
+ Log.e("Feed", "Error: " + e.getMessage());
+ }
+});
+```
+
+
+```kotlin
+CometChat.markFeedItemAsDelivered(feedItem, object : CometChat.CallbackListener() {
+ override fun onSuccess(result: Void?) { /* Success */ }
+ override fun onError(e: CometChatException) {
+ Log.e("Feed", "Error: ${e.message}")
+ }
+})
+```
+
+
+
+---
+
+## Report Engagement
+
+Report that a user engaged with a feed item (e.g., viewed, clicked, interacted). Idempotent.
+
+
+
+```java
+CometChat.reportFeedEngagement(feedItem, "clicked", new CometChat.CallbackListener() {
+ @Override
+ public void onSuccess(Void unused) { }
+
+ @Override
+ public void onError(CometChatException e) { }
+});
+```
+
+
+```kotlin
+CometChat.reportFeedEngagement(feedItem, "clicked", object : CometChat.CallbackListener() {
+ override fun onSuccess(result: Void?) { }
+ override fun onError(e: CometChatException) { }
+})
+```
+
+
+
+The `interactionString` parameter is a free-form string describing the engagement (e.g., `"viewed"`, `"clicked"`, `"interacted"`).
+
+---
+
+## Get Unread Count
+
+Fetch the total number of unread notification feed items.
+
+
+
+```java
+CometChat.getNotificationFeedUnreadCount(new CometChat.CallbackListener() {
+ @Override
+ public void onSuccess(Integer count) {
+ Log.d("Feed", "Unread: " + count);
+ }
+
+ @Override
+ public void onError(CometChatException e) {
+ Log.e("Feed", "Error: " + e.getMessage());
+ }
+});
+```
+
+
+```kotlin
+CometChat.getNotificationFeedUnreadCount(object : CometChat.CallbackListener() {
+ override fun onSuccess(count: Int) {
+ Log.d("Feed", "Unread: $count")
+ }
+
+ override fun onError(e: CometChatException) {
+ Log.e("Feed", "Error: ${e.message}")
+ }
+})
+```
+
+
+
+---
+
+## Fetch Single Feed Item
+
+Fetch a specific item by ID — useful for deep linking from push notifications.
+
+
+
+```java
+CometChat.getNotificationFeedItem("item-id-123", new CometChat.CallbackListener() {
+ @Override
+ public void onSuccess(NotificationFeedItem item) {
+ String cardJson = item.getContent().toString();
+ // Render the card
+ }
+
+ @Override
+ public void onError(CometChatException e) {
+ Log.e("Feed", "Error: " + e.getMessage());
+ }
+});
+```
+
+
+```kotlin
+CometChat.getNotificationFeedItem("item-id-123", object : CometChat.CallbackListener() {
+ override fun onSuccess(item: NotificationFeedItem) {
+ val cardJson = item.content.toString()
+ // Render the card
+ }
+
+ override fun onError(e: CometChatException) {
+ Log.e("Feed", "Error: ${e.message}")
+ }
+})
+```
+
+
+
+---
+
+## Push Notification Tracking
+
+When a campaign push notification arrives via FCM, use these methods to report delivery and click engagement.
+
+### Mark Push Notification as Delivered
+
+Call this in your `FirebaseMessagingService.onMessageReceived()`:
+
+
+
+```java
+PushNotification pushNotification = PushNotification.fromJson(pushPayloadJson);
+
+CometChat.markPushNotificationDelivered(pushNotification, new CometChat.CallbackListener() {
+ @Override
+ public void onSuccess(Void unused) { }
+
+ @Override
+ public void onError(CometChatException e) { }
+});
+```
+
+
+```kotlin
+val pushNotification = PushNotification.fromJson(pushPayloadJson)
+
+CometChat.markPushNotificationDelivered(pushNotification, object : CometChat.CallbackListener() {
+ override fun onSuccess(result: Void?) { }
+ override fun onError(e: CometChatException) { }
+})
+```
+
+
+
+### Mark Push Notification as Clicked
+
+Call this when the user taps the push notification:
+
+
+
+```java
+CometChat.markPushNotificationClicked(pushNotification, new CometChat.CallbackListener() {
+ @Override
+ public void onSuccess(Void unused) { }
+
+ @Override
+ public void onError(CometChatException e) { }
+});
+```
+
+
+```kotlin
+CometChat.markPushNotificationClicked(pushNotification, object : CometChat.CallbackListener() {
+ override fun onSuccess(result: Void?) { }
+ override fun onError(e: CometChatException) { }
+})
+```
+
+
+
+### PushNotification Fields
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `id` | String | Announcement ID from the push payload |
+| `announcementId` | String | Same as id (for clarity) |
+| `campaignId` | String? | Campaign ID if from a campaign |
+| `source` | String | Always `"campaign"` for notification feed pushes |
+
+---
+
+## FeedReadState Enum
+
+| Value | Description |
+| --- | --- |
+| `READ` | Only read items |
+| `UNREAD` | Only unread items |
+| `ALL` | All items (default) |
+
+---
+
+## Rendering Cards
+
+The `content` field of each `NotificationFeedItem` is a Card Schema JSON object. To render it natively, use the CometChat Cards library.
+
+### Add the Cards Dependency
+
+Add the Cloudsmith repository and the cards library to your project:
+
+```groovy
+// settings.gradle or project-level build.gradle
+repositories {
+ maven { url "https://dl.cloudsmith.io/public/cometchat/cometchat/maven/" }
+}
+```
+
+```groovy
+// app/build.gradle
+dependencies {
+ implementation "com.cometchat:cards-android:1.0.0"
+}
+```
+
+
+Requires `minSdk 24`, Kotlin, and internet permission in your AndroidManifest.xml.
+
+
+### Render a Card from a Feed Item
+
+
+
+```kotlin
+import com.cometchat.cards.CometChatCardComposable
+import com.cometchat.cards.core.CometChatCardThemeMode
+
+@Composable
+fun NotificationCard(item: NotificationFeedItem) {
+ CometChatCardComposable(
+ cardJson = item.content.toString(),
+ themeMode = CometChatCardThemeMode.AUTO,
+ onAction = { event ->
+ when (event.action) {
+ is CometChatCardOpenUrlAction -> {
+ // Open URL in browser
+ }
+ is CometChatCardChatWithUserAction -> {
+ // Navigate to chat
+ }
+ }
+ }
+ )
+}
+```
+
+
+```kotlin
+import com.cometchat.cards.CometChatCardView
+import com.cometchat.cards.core.CometChatCardThemeMode
+
+val cardView = CometChatCardView(context)
+cardView.setCardSchema(item.content.toString())
+cardView.setThemeMode(CometChatCardThemeMode.AUTO)
+cardView.setActionCallback { event ->
+ // Handle action: event.action, event.elementId
+}
+parentLayout.addView(cardView)
+```
+
+
+
+
+The Cards library is a pure renderer — it does not execute actions. Your code must handle action callbacks (opening URLs, navigating to chats, making API calls, etc.).
+
+
+---
+
+## Supported Card Actions
+
+When a user taps a button or link inside a card, the action callback receives one of these action types:
+
+| Action Type | Parameters | Description |
+| --- | --- | --- |
+| `openUrl` | url, openIn | Open a URL in browser or webview |
+| `chatWithUser` | uid | Navigate to 1:1 chat |
+| `chatWithGroup` | guid | Navigate to group chat |
+| `sendMessage` | text, receiverUid, receiverGuid | Send a text message |
+| `copyToClipboard` | value | Copy text to clipboard |
+| `downloadFile` | url, filename | Download a file |
+| `initiateCall` | callType (audio/video), uid, guid | Start a call |
+| `apiCall` | url, method, headers, body | Make an HTTP request |
+| `customCallback` | callbackId, payload | App-specific logic |
diff --git a/ui-kit/android/v6/campaigns.mdx b/ui-kit/android/v6/campaigns.mdx
new file mode 100644
index 000000000..66d71665a
--- /dev/null
+++ b/ui-kit/android/v6/campaigns.mdx
@@ -0,0 +1,166 @@
+---
+title: "Campaigns"
+description: "Deliver targeted, rich notifications to users via an in-app notification feed powered by the CometChat Cards renderer."
+---
+
+CometChat Campaigns enables you to send rich, interactive notifications to users through an in-app notification feed. Each notification is rendered as a native card using the **CometChat Cards** library — supporting images, text, buttons, layouts, and interactive actions.
+
+
+ 
+
+
+---
+
+## Overview
+
+Campaigns delivers notifications as **Card Schema JSON** — a structured format that defines the visual layout of each notification card. The system consists of three layers:
+
+1. **CometChat Chat SDK** — Fetches feed items, manages read/delivered state, provides real-time listeners, handles push notification tracking
+2. **CometChat Cards Library** — Renders Card Schema JSON into native Android views (Jetpack Compose and XML Views)
+3. **CometChat UI Kit** — Provides the ready-to-use `CometChatNotificationFeed` component that wires everything together
+
+### Architecture Flow
+
+```
+Dashboard / API → Campaign Created → Push + WebSocket Delivery
+ ↓
+ SDK: NotificationFeedRequest.fetchNext()
+ ↓
+ NotificationFeedItem.getContent() → Card Schema JSON
+ ↓
+ Cards Library: CometChatCardView / CometChatCardComposable
+ ↓
+ Native Rendered Card (images, text, buttons, layouts)
+ ↓
+ User taps button → ActionCallback → Your code handles it
+```
+
+---
+
+## How Cards Work
+
+Each `NotificationFeedItem` from the SDK contains a `content` field — a `JSONObject` holding the Card Schema JSON. This JSON is passed directly to the CometChat Cards renderer which produces a native view.
+
+The Cards library is a **pure renderer**:
+- **Input**: Card Schema JSON string + theme mode + optional action callback
+- **Output**: Native Android view hierarchy
+
+It does not execute actions, manage message state, or call any SDK methods. When users tap interactive elements (buttons, links), the library emits the action to your callback. You decide what happens — open a URL, navigate to a chat, make an API call, etc.
+
+### Card Schema JSON Example
+
+```json
+{
+ "version": "1.0",
+ "body": [
+ { "type": "image", "id": "img_1", "url": "https://cdn.example.com/sale.jpg", "height": 180, "fit": "cover", "borderRadius": 8 },
+ { "type": "text", "id": "txt_1", "content": "🎉 Flash Sale — 40% Off!", "variant": "heading2" },
+ { "type": "text", "id": "txt_2", "content": "Limited time offer on all premium plans.", "variant": "body" },
+ { "type": "button", "id": "btn_1", "label": "Claim Offer", "action": { "type": "openUrl", "url": "https://example.com/offer" }, "fullWidth": true }
+ ],
+ "style": { "background": {"light": "#FFFFFF", "dark": "#1E1E1E"}, "borderRadius": 12, "padding": 16 },
+ "fallbackText": "Flash Sale — 40% Off! Claim your offer: https://example.com/offer"
+}
+```
+
+The schema supports **20 element types** (text, image, icon, avatar, badge, divider, spacer, chip, progressBar, codeBlock, markdown, row, column, grid, accordion, tabs, button, iconButton, link, table) and **9 action types** (openUrl, chatWithUser, chatWithGroup, sendMessage, copyToClipboard, downloadFile, initiateCall, apiCall, customCallback).
+
+---
+
+## How Cards Work in the UI Kit
+
+The `CometChatNotificationFeed` component uses the **CometChat Cards** library internally to render each notification. Here's what happens under the hood:
+
+1. The component fetches `NotificationFeedItem` objects from the SDK
+2. For each item, it extracts the `content` field (Card Schema JSON)
+3. It passes the JSON to `CometChatCardComposable` (Compose) or `CometChatCardView` (XML) from the Cards library
+4. The Cards renderer produces native UI — text, images, buttons, layouts — directly from the JSON
+5. When users tap buttons/links inside a card, the action is emitted back to the component which handles navigation (open URL, navigate to chat, etc.)
+
+You don't need to interact with the Cards library directly when using `CometChatNotificationFeed` — it's all wired up. But if you want to render cards outside the feed (e.g., a standalone card in a dialog), you can use the Cards library directly. See the [SDK Campaigns documentation](/sdk/android/v5/campaigns#rendering-cards) for standalone usage.
+
+---
+
+## Handling Push Notifications for Campaigns
+
+When a campaign push notification arrives via FCM, you should:
+
+1. **Report delivery** — Call `CometChat.markPushNotificationDelivered()` in your `FirebaseMessagingService`
+2. **Report click** — Call `CometChat.markPushNotificationClicked()` when the user taps the notification
+3. **Deep link** — Use the announcement ID from the push payload to fetch the full item via `CometChat.getNotificationFeedItem(id)` and display it
+
+```kotlin
+// In FirebaseMessagingService.onMessageReceived()
+val pushNotification = PushNotification.fromJson(data)
+CometChat.markPushNotificationDelivered(pushNotification, ...)
+
+// When user taps the notification
+CometChat.markPushNotificationClicked(pushNotification, ...)
+
+// Navigate to feed or show specific item
+CometChat.getNotificationFeedItem(pushNotification.id, ...)
+```
+
+See the [SDK Campaigns documentation](/sdk/android/v5/campaigns) for the complete push notification tracking API.
+
+---
+
+## Sending Campaigns
+
+Campaigns are created and managed from the **CometChat Dashboard** or via the **REST API**. The SDK and UI Kit are consumer-side — they display and interact with campaigns, not create them.
+
+To send campaigns:
+- **Dashboard**: Navigate to Campaigns → Create Campaign → Define audience, content (Card Schema), and delivery channel
+- **REST API**: Use the Campaigns API to programmatically create and schedule campaigns
+
+---
+
+## Using the UI Kit Component
+
+The easiest way to add a notification feed to your app is the `CometChatNotificationFeed` component. It handles fetching, rendering, pagination, filtering, real-time updates, and engagement reporting out of the box.
+
+
+
+```kotlin
+@Composable
+fun NotificationsScreen() {
+ CometChatNotificationFeed(
+ modifier = Modifier.fillMaxSize(),
+ onItemClick = { item ->
+ // Handle item tap
+ },
+ onBackPress = { /* navigate back */ }
+ )
+}
+```
+
+
+```xml
+
+```
+
+```kotlin
+val feed = findViewById(R.id.notificationFeed)
+feed.init(this) // Pass ViewModelStoreOwner
+feed.onItemClick = { item -> /* handle tap */ }
+```
+
+
+
+See the full [CometChatNotificationFeed component documentation](/ui-kit/android/v6/notification-feed) for all configuration options, styling, and customization.
+
+---
+
+## Next Steps
+
+
+
+ Full API reference for feed items, categories, engagement, and push tracking
+
+
+ Ready-to-use component with filtering, real-time updates, and styling
+
+
diff --git a/ui-kit/android/v6/notification-feed.mdx b/ui-kit/android/v6/notification-feed.mdx
new file mode 100644
index 000000000..54f962efc
--- /dev/null
+++ b/ui-kit/android/v6/notification-feed.mdx
@@ -0,0 +1,478 @@
+---
+title: "Notification Feed"
+description: "Full-screen notification feed component with category filtering, card rendering, real-time updates, and engagement reporting."
+---
+
+`CometChatNotificationFeed` displays a scrollable notification feed where each item is rendered as a native card using the CometChat Cards library. It handles fetching, pagination, category filtering, timestamp grouping, real-time updates, and read/delivered/engagement reporting automatically.
+
+
+
+
+
+---
+
+## Where It Fits
+
+`CometChatNotificationFeed` is a full-screen component. Drop it into an Activity, Fragment, or navigation destination. It manages its own data fetching, state, and real-time listeners — you just handle navigation callbacks.
+
+
+
+```kotlin
+@Composable
+fun NotificationsScreen(onBack: () -> Unit) {
+ CometChatNotificationFeed(
+ modifier = Modifier.fillMaxSize(),
+ showBackButton = true,
+ onBackPress = onBack,
+ onItemClick = { item ->
+ // Handle item tap (e.g., open detail or deep link)
+ }
+ )
+}
+```
+
+
+```xml
+
+```
+
+```kotlin
+val feed = findViewById(R.id.notificationFeed)
+feed.init(this) // Pass Activity or Fragment — needed to create the ViewModel
+feed.onItemClick = { item -> /* navigate */ }
+feed.onBackPress = { finish() }
+```
+
+
+
+---
+
+## Quick Start
+
+
+
+```kotlin
+@Composable
+fun NotificationsScreen() {
+ CometChatNotificationFeed(
+ modifier = Modifier.fillMaxSize()
+ )
+}
+```
+
+
+```kotlin
+override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ val feed = CometChatNotificationFeed(this)
+ setContentView(feed)
+ feed.init(this) // Required — binds the ViewModel to this Activity's lifecycle
+}
+```
+
+
+
+Prerequisites: CometChat SDK initialized with `CometChatUIKit.init()` and a user logged in.
+
+---
+
+## Filtering Feed Items
+
+Control what loads using custom request builders:
+
+
+
+```kotlin
+CometChatNotificationFeed(
+ feedRequestBuilder = NotificationFeedRequest.NotificationFeedRequestBuilder()
+ .setLimit(30)
+ .setReadState(FeedReadState.UNREAD)
+ .setCategory("promotions")
+)
+```
+
+
+```kotlin
+feed.setFeedRequestBuilder(
+ NotificationFeedRequest.NotificationFeedRequestBuilder()
+ .setLimit(30)
+ .setReadState(FeedReadState.UNREAD)
+ .setCategory("promotions")
+)
+feed.init(this)
+```
+
+
+
+### Filter Options
+
+| Builder Method | Description |
+| --- | --- |
+| `.setLimit(int)` | Items per page (default 20, max 100) |
+| `.setReadState(FeedReadState)` | `READ`, `UNREAD`, or `ALL` |
+| `.setCategory(String)` | Filter by category ID |
+| `.setChannelId(String)` | Filter by channel |
+| `.setTags(List)` | Filter by tags |
+| `.setDateFrom(String)` | ISO 8601 date lower bound |
+| `.setDateTo(String)` | ISO 8601 date upper bound |
+
+
+Pass the builder object, not the result of `.build()`. The component calls `.build()` internally.
+
+
+---
+
+## Actions and Events
+
+### Callback Methods
+
+#### `onItemClick`
+
+Fires when a feed item card is tapped.
+
+
+
+```kotlin
+CometChatNotificationFeed(
+ onItemClick = { item ->
+ // item.id, item.content (Card JSON), item.category
+ }
+)
+```
+
+
+```kotlin
+feed.onItemClick = { item ->
+ // Handle item tap
+}
+```
+
+
+
+#### `onActionClick`
+
+Fires when an interactive element (button, link) inside a card is tapped.
+
+
+
+```kotlin
+CometChatNotificationFeed(
+ onActionClick = { item, actionMap ->
+ // actionMap contains action type and parameters
+ val actionType = actionMap["type"] as? String
+ when (actionType) {
+ "openUrl" -> openBrowser(actionMap["url"] as String)
+ "chatWithUser" -> navigateToChat(actionMap["uid"] as String)
+ }
+ }
+)
+```
+
+
+```kotlin
+feed.onActionClick = { item, actionMap ->
+ val actionType = actionMap["type"] as? String
+ // Handle action
+}
+```
+
+
+
+#### `onError`
+
+Fires when an internal error occurs (network failure, SDK exception).
+
+
+
+```kotlin
+CometChatNotificationFeed(
+ onError = { exception ->
+ Log.e("Feed", "Error: ${exception.message}")
+ }
+)
+```
+
+
+```kotlin
+feed.onError = { exception ->
+ Log.e("Feed", "Error: ${exception.message}")
+}
+```
+
+
+
+#### `onBackPress`
+
+Fires when the back button in the header is tapped.
+
+
+
+```kotlin
+CometChatNotificationFeed(
+ showBackButton = true,
+ onBackPress = { /* navigate back */ }
+)
+```
+
+
+```kotlin
+feed.setShowBackButton(true)
+feed.onBackPress = { finish() }
+```
+
+
+
+### Automatic Behaviors
+
+The component handles these automatically — no manual setup needed:
+
+| Behavior | Description |
+| --- | --- |
+| Real-time updates | New items appear at the top via WebSocket listener |
+| Delivery reporting | Items are reported as delivered when fetched |
+| Read reporting | Items are reported as read after 1 second of visibility |
+| Unread count polling | Polls unread count every 30 seconds to update badges |
+| Infinite scroll | Fetches next page when scrolling near the bottom |
+| Pull-to-refresh | Resets and fetches fresh data on pull |
+| Timestamp grouping | Groups items as "Today", "Yesterday", day name, or date |
+| Category filtering | Filter chips row for category-based filtering |
+
+---
+
+## Functionality
+
+| Method (XML Views) | Compose Parameter | Description |
+| --- | --- | --- |
+| `setTitle("Notifications")` | `title = "Notifications"` | Header title text |
+| `setShowHeader(true)` | `showHeader = true` | Toggle header visibility |
+| `setShowBackButton(false)` | `showBackButton = false` | Toggle back button |
+| `setShowFilterChips(true)` | `showFilterChips = true` | Toggle category filter chips |
+| `setFeedRequestBuilder(...)` | `feedRequestBuilder = ...` | Custom feed request |
+| `setCategoriesRequestBuilder(...)` | `categoriesRequestBuilder = ...` | Custom categories request |
+
+---
+
+## Custom View Slots
+
+### Header View
+
+Replace the entire header:
+
+
+
+```kotlin
+CometChatNotificationFeed(
+ headerView = {
+ Row(
+ modifier = Modifier.fillMaxWidth().padding(16.dp),
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ Text("My Notifications", style = CometChatTheme.typography.heading1Bold)
+ }
+ }
+)
+```
+
+
+
+### State Views
+
+
+
+```kotlin
+CometChatNotificationFeed(
+ emptyStateView = {
+ Column(
+ modifier = Modifier.fillMaxSize(),
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.Center
+ ) {
+ Text("No notifications yet")
+ }
+ },
+ errorStateView = { exception, onRetry ->
+ Column(horizontalAlignment = Alignment.CenterHorizontally) {
+ Text("Something went wrong")
+ Button(onClick = onRetry) { Text("Retry") }
+ }
+ },
+ loadingStateView = {
+ Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+ CircularProgressIndicator()
+ }
+ }
+)
+```
+
+
+
+---
+
+## Style
+
+
+
+```kotlin
+CometChatNotificationFeed(
+ style = CometChatNotificationFeedStyle(
+ backgroundColor = Color(0xFFF5F5F5),
+ headerBackgroundColor = Color.White,
+ headerTitleColor = Color(0xFF141414),
+ chipActiveBackgroundColor = Color(0xFF3399FF),
+ chipActiveTextColor = Color.White,
+ chipInactiveBackgroundColor = Color.White,
+ chipInactiveTextColor = Color(0xFF727272),
+ cardBackgroundColor = Color.White,
+ cardBorderColor = Color(0xFFE0E0E0),
+ cardBorderRadius = 12.dp,
+ unreadIndicatorColor = Color(0xFF3399FF)
+ )
+)
+```
+
+
+```kotlin
+feed.setStyle(CometChatNotificationFeedStyle(
+ backgroundColor = Color.parseColor("#F5F5F5"),
+ headerTitleColor = Color.parseColor("#141414"),
+ chipActiveBackgroundColor = Color.parseColor("#3399FF"),
+ chipActiveTextColor = Color.WHITE,
+ chipInactiveBackgroundColor = Color.TRANSPARENT,
+ chipInactiveTextColor = Color.DKGRAY,
+ cardBackgroundColor = Color.WHITE,
+ cardBorderColor = Color.parseColor("#E0E0E0"),
+ unreadIndicatorColor = Color.parseColor("#3399FF")
+))
+```
+
+
+
+### Style Properties
+
+| Property | Description |
+| --- | --- |
+| `backgroundColor` | Screen background color |
+| `headerBackgroundColor` | Header bar background |
+| `headerTitleColor` | Header title text color |
+| `headerBorderColor` | Divider below header |
+| `chipActiveBackgroundColor` | Selected filter chip background |
+| `chipActiveTextColor` | Selected filter chip text |
+| `chipInactiveBackgroundColor` | Unselected filter chip background |
+| `chipInactiveTextColor` | Unselected filter chip text |
+| `chipBorderColor` | Filter chip border |
+| `badgeActiveBackgroundColor` | Active chip badge background |
+| `badgeActiveTextColor` | Active chip badge text |
+| `badgeInactiveBackgroundColor` | Inactive chip badge background |
+| `badgeInactiveTextColor` | Inactive chip badge text |
+| `timestampTextColor` | Section header timestamp color |
+| `cardBackgroundColor` | Card container background |
+| `cardBorderColor` | Card container border |
+| `cardBorderRadius` | Card corner radius |
+| `cardBorderWidth` | Card border width |
+| `unreadIndicatorColor` | Unread dot indicator color |
+| `separatorColor` | Separator between cards |
+
+All colors default to `Color.Unspecified` (Compose) or `0` (XML) to inherit from `CometChatTheme`. Override individual values without losing theme support.
+
+---
+
+## ViewModel Access
+
+The component uses `CometChatNotificationFeedViewModel` from the shared `chatuikit-core` module. You can provide a custom ViewModel for advanced scenarios:
+
+
+
+```kotlin
+val viewModel: CometChatNotificationFeedViewModel = viewModel(
+ factory = CometChatNotificationFeedViewModelFactory(
+ feedRequestBuilder = customBuilder,
+ pollingIntervalMs = 60_000L // 1 minute polling
+ )
+)
+
+CometChatNotificationFeed(
+ viewModel = viewModel
+)
+```
+
+
+
+### ViewModel Factory Parameters
+
+| Parameter | Default | Description |
+| --- | --- | --- |
+| `feedRequestBuilder` | null | Custom feed request builder |
+| `categoriesRequestBuilder` | null | Custom categories request builder |
+| `enableListeners` | true | Enable WebSocket listeners (false for testing) |
+| `pollingIntervalMs` | 30000 | Unread count polling interval in ms |
+
+---
+
+## Common Patterns
+
+### Show only unread items
+
+
+
+```kotlin
+CometChatNotificationFeed(
+ feedRequestBuilder = NotificationFeedRequest.NotificationFeedRequestBuilder()
+ .setReadState(FeedReadState.UNREAD)
+)
+```
+
+
+
+### Hide filter chips and header
+
+
+
+```kotlin
+CometChatNotificationFeed(
+ showHeader = false,
+ showFilterChips = false
+)
+```
+
+
+```kotlin
+feed.setShowHeader(false)
+feed.setShowFilterChips(false)
+```
+
+
+
+### Custom categories request
+
+
+
+```kotlin
+CometChatNotificationFeed(
+ categoriesRequestBuilder = NotificationCategoriesRequest.NotificationCategoriesRequestBuilder()
+ .setLimit(10)
+)
+```
+
+
+
+---
+
+## Next Steps
+
+
+
+ Overview of how campaigns work end-to-end
+
+
+ Low-level SDK APIs for feed items, categories, and engagement
+
+
+ Full styling reference for all components
+
+
+ Custom ViewModels, repositories, and ListOperations
+
+