Push Inbox

Netmera Inbox allows you to access and manage previously sent push notifications in an inbox-style interface. You cannot instantiate NetmeraInbox directly; instead, you must obtain an instance through the SDK and use it to interact with push notifications.

Install Netmera Notification Inbox

Integrate the NetmeraNotificationInbox, add it to your Podfile if you are using CocoaPods.

pod 'NetmeraNotificationInbox'

Install the dependency and proceed with integration.

Import Statements

Before using Inbox and Notification features, make sure to add the following imports at the top of your Swift file:

import NetmeraNotification
import NetmeraNotificationInbox

This ensures that all related classes and methods are available for handling push notifications and inbox operations.

Filter and Fetch Notification

Create a NetmeraInboxFilter instance to specify which push notifications to fetch. You can filter by:

• Status: Read, Unread, or Deleted.

• Categories: Filter by specific categories.

• Expired Notifications: Include or exclude expired notifications.

• Page Size: Number of notifications to fetch per request.

Define Inbox Manager

var inboxManager: NetmeraInboxManager?

Create a Filter

Define the properties to filter notifications, such as status, categories, and page size.

let filter = NetmeraInboxFilter(status: status,
                                pageSize: 10,
                                shouldIncludeExpiredObjects: true,
                                categories: ["category_names"]) // Optional

Initialize Inbox Manager

self.inboxManager = Netmera.inboxManager(with: filter)

Fetch the First Page

Request the list of matching push notifications.

inboxManager?.inbox(callback: { result in
	// Handle the result
})

Sample Code

// Step 1: Define the inbox manager
var inboxManager: NetmeraInboxManager?

// Step 2: Create a filter for fetching inbox notifications
let filter = NetmeraInboxFilter(
    status: status,                        // Notification status: .unread, .read, or .deleted
    pageSize: 10,                          // Number of notifications to retrieve per page
    shouldIncludeExpiredObjects: true,     // Include expired notifications
    categories: ["category_names"]         // (Optional) Filter by specific categories
)

// Step 3: Fetch Inbox
inboxManager?.inbox(callback: { result in
    switch result {
    case .success:
        // Display inbox UI with inboxManager?.objects
    case .failure(let error):
        // Handle error
    }
})

Update Notification Status

Push notifications can have three statuses:

• Unread

• Read

• Deleted

You can update the status of notifications to allow users to mark messages as read, unread, or deleted.

Examples:

Update the status of a single notification:

inboxManager?.updateStatus(status, for: [object]) { result in
    // Handle status update
}

Update the status of all notifications:

inboxManager?.updateStatusForAllPushObjects(status) { result in
    // Handle status update
}

Fetch More Pages

If there are more notifications than the defined page size, fetch the next page:

inboxManager?.nextPage(callback: { result in
	// Handle the next page
})

All fetched notifications are stored in inbox.objects, and hasNextPage checks if more pages are available.

Incremental Fetching

The NetmeraInbox instance returned from -fetchInboxUsingFilter:completion: keeps the list of fetched notifications in inbox.objects. As you fetch more pages, new notifications are added to this list.

For example, if you set a page size of 10 and fetch 3 pages, inbox.objects will contain all 30 notifications from the 3 pages. This allows you to display the entire list of notifications in a table or collection view.

Error Handling

If the operation fails, the completion block will be triggered with an error describing the failure. If there are no more pages to fetch, the method will immediately call the completion block with an appropriate error.

Checking if All Pages are Fetched

You can check if there are more pages to fetch by using the hasNextPage property of the NetmeraInbox instance. If it returns false, it means all pages have been fetched.

Push Notification Counts

To get the total count of notifications based on status:

self.inboxManager?.count(for: NetmeraInboxStatus.read)

This method provides the count of notifications in the specified status.

Handling Push Objects

You can access the title, body, and subtitle of a push notification using the alert property on NetmeraInboxPush.

let push: NetmeraInboxPush = inboxManager.objects[indexPath.row]

let title = push.alert?.title
let body = push.alert?.body
let subtitle = push.alert?.subtitle

If the push includes a media attachment:

if let mediaURLString = push.payload?.mediaAttachmentURL,
   let url = URL(string: mediaURLString) {
    // Load and display the image
}

If you need direct access to the deep link URL:

if let deeplinkAction = push.payload?.action as? NetmeraDeeplinkAction {
    let url = deeplinkAction.deeplinkURL
}

Manage Push Notification Categories

The per-channel message category preference APIs described in this section require Netmera iOS SDK 4.26.0 or later.

Create message categories from Settings > Messaging & Content > Message Categories in the panel. Each category can be managed per channel (Mobile Push, SMS, Email, WhatsApp, In-App, Web) — so you can track and update a user's opt-in status either for the category as a whole or for one specific channel.

Channels are represented by the NetmeraUserCategoryPreference.Channel enum:

public enum Channel: String {
    case mobile = "MOBILE"
    case sms = "SMS"
    case email = "EMAIL"
    case whatsApp = "WHATS_APP"
    case inApp = "IN_APP"
    case web = "WEB"
}

Getting a User's Category Preferences

Fetch the full list of category preferences (ID, name, and opt-in status):

Netmera.getUserCategoryPreferenceList { result in
    switch result {
    case .success(let categoryPreferenceList):
        // handle category preference list
    case .failure(let error):
        // handle error
    }
}

To narrow the result down, pass categoryIds and/or channels. Both are optional and can be combined; a category that doesn't support any of the requested channels is left out of the result.

Netmera.getUserCategoryPreferenceList(
    categoryIds: [42, 43],
    channels: [.sms, .email]
) { result in
    switch result {
    case .success(let categoryPreferenceList):
        for category in categoryPreferenceList {
            print("\(category.categoryId ?? 0) - \(category.categoryName ?? "") -> \(category.categoryEnabled ?? false)")

            for channelPreference in category.channelPreferences ?? [] {
                print("  \(channelPreference.channel?.description ?? "-"): \(channelPreference.isEnabled ?? false)")
            }
        }
    case .failure(let error):
        // handle error
    }
}

You can also filter by a single category or channel:

Netmera.getUserCategoryPreferenceList(categoryIds: [42]) { result in /* ... */ }
Netmera.getUserCategoryPreferenceList(channels: [.sms]) { result in /* ... */ }
Netmera.getUserCategoryPreferenceList(categoryIds: [42], channels: [.sms]) { result in /* ... */ }

Each NetmeraUserCategoryPreference includes:

• categoryEnabled — the overall status: true if the category is enabled on any channel. This is always returned, regardless of channel filters.

• channelPreferences — a per-channel breakdown, as a list of NetmeraUserCategoryPreference.ChannelPreference (channel, isEnabled).

Updating Category Preferences

To turn a category on or off, call setUserCategoryPreference with the category ID and the new categoryEnabled value:

Netmera.setUserCategoryPreference(categoryId: 42, categoryEnabled: true) { result in
    switch result {
    case .success:
        // handle success
    case .failure(let error):
        // handle failure
    }
}

To update just one channel instead of the whole category, add a channel:

Netmera.setUserCategoryPreference(
    categoryId: 42,
    categoryEnabled: false,
    channel: .sms
) { result in
    switch result {
    case .success:
        // handle success
    case .failure(let error):
        // handle failure
    }
}