Initial configuration
Before building your chat app, you must initialize and configure the Chat SDK.
Start by signing into the Admin Portal or creating an account if you don't have one yet.
Then, create an app on the Admin Portal. You will need a PubNub app to get a keyset that consists of a Subscribe Key and a Publish Key. These keys will let you establish a connection between PubNub and the chat app you're going to create with the Chat SDK.
Limit of 3 keysets for Free tier accounts
Effective February 3, 2025, all Free tier accounts will be limited to a maximum of three keysets. If your account exceeds this limit, you must delete existing keysets to create new ones.
When you create a new app on the Admin Portal, the first set of demo keys is generated automatically, but a single app can have as many keysets as you like. We recommend that you create separate keysets for production and test environments.
Enable features on your keyset
Each keyset has its own configuration settings in the Admin Portal. To use some features in your chat app, you must enable appropriate settings on your app's keyset on the Admin Portal.
To use the Chat SDK, create or update users, track presence, and store messages in history, make sure App Context, Presence, and Message Persistence are enabled on your keyset.
Download the SDK
Download the SDK from any of the following sources:
Use Swift Package Manager
To integrate PubNub into your project using the Swift Package Manager specify PubNub in the dependencies list of your Package.swift file:
dependencies: [
.package(url: "https://github.com/pubnub/swift-chat-sdk", exact: "0.11.0-dev")
]
Use Xcode
- Create or open your project inside Xcode.
- Navigate to File -> Add Package Dependencies.
- Search for
https://github.com/pubnub/swift-chat-sdk. - From the Dependency Rule drop-down list, select Exact. In the version input field, type
0.11.0-dev. - Click the Add Package button.
Initialize PubNub
Once you have a PubNub account and an app created on the Admin Portal, you can start initializing PubNub Client API context and establish account-level credentials.
To initialize PubNub with the Chat SDK:
-
Create a
ChatImplobject, which takes the following parameters:Configuration Description pubNubConfigurationAn instance of the PubNub account configuration. You must provide at least the subscribeKeyanduserIdto connect to PubNub.chatConfigurationAn instance of chat-specific configuration required to implement advanced features, like typing indicator, user offline/online presence, push notifications, or client-side limiting that prevents spamming. -
Call the
initialize()method on yourChatImplobject.
// Chat SDK-specific configuration
public struct ChatConfiguration {
public var logLevel: LogLevel
public var typingTimeout: Int
public var storeUserActivityInterval: Int
public var storeUserActivityTimestamps: Bool
public var pushNotificationsConfig: PushNotificationsConfig
public var rateLimitFactor: Int
public var rateLimitPerChannel: [ChannelType: Int64]
public var customPayloads: CustomPayloads?
public init(
logLevel: LogLevel = .off,
typingTimeout: Int = 5,
storeUserActivityInterval: Int = 600,
Input parameters
| Parameter | Type | Description |
|---|---|---|
pubNubConfiguration | PubNubConfiguration | Mandatory PubNub account configuration. |
→ publishKey | String | Specifies the key used to publish messages on a channel. |
→ subscribeKey | String | Specifies the key used to subscribe to a channel. |
→ userId | String | Unique User ID that becomes your app's current user. It's a string of up to 92 characters that identifies a single client (end user, device, or server) that connects to PubNub. Based on User ID, PubNub calculates pricing for your apps' usage. User ID should be persisted and remain unchanged. If you don't set userId, you won't be able to connect to PubNub. |
chatConfiguration | ChatConfiguration | ChatConfiguration contains chat app configuration settings, such as saveDebugLog or typingTimeout that you provide when initializing your chat app with the initialize() method. You can later directly access these properties, like: chat.storeUserActivityInterval. |
ChatConfiguration
| Parameter | Type | Required | Default | Feature | Description |
|---|---|---|---|---|---|
logLevel | LogLevel | No | .off | Error logging | Specifies if any Chat SDK-related errors should be logged. It's disabled by default. Available options include: off, error, warn, info, debug, and verbose. |
typingTimeout | Int | No | 5 | Typing Indicator | Specifies the default timeout after which the typing indicator automatically stops when no typing signals are received. The default and maximum value is set to 5 seconds. |
storeUserActivityInterval | Int | No | 600 | User's last online activity, global presence | Specifies how often the user global presence in the app should be updated. Requires storeUserActivityTimestamps to be set to true. The default value is set to 60 seconds, and that's the minimum possible value. If you try to set it to a lower value, you'll get the storeUserActivityInterval must be at least 60000ms error. |
storeUserActivityTimestamps | Bool | No | false | User's last online activity, global presence | Specifies if you want to track the user's global presence in your chat app. The user's activity is tracked through the lastActiveTimestamp parameter on the User object. |
pushNotificationsConfig | PushNotificationsConfig | No | n/a | Push Notifications | List of parameters you must set if you want to enable sending/receiving mobile push notifications for phone devices, either through Apple Push Notification service (APNS) or Firebase Cloud Messaging (FCM). |
→ sendPushes | Bool | No | false | as above | The main option for enabling sending notifications. It must be set to true if you want a particular client (whether a mobile device, web browser, or server) to send push notifications to mobile devices. These push notifications are messages with a provider-specific payload that the Chat SDK automatically attaches to every message. Chat SDK includes a default payload setup for deviceGateway in every message sent to the registered channels. This is the only required option to enable if you want to send push notifications to Android devices. For iOS devices, you also have to configure apnsTopic. |
→ deviceToken | String | No | n/a | as above | Option for receiving notifications on iOS and Android devices. A device token refers to the unique identifier assigned to a specific mobile device by a platform's push notification service. It targets and delivers push notifications to the intended app on that specific device. Suppose you don't set this option and try to run channel registration-related methods. In that case, you'll get the Device Token has to be defined in Chat pushNotifications config error. Refer to the official Apple and Google docs to learn how to obtain a device token for the APNs and FCM services. |
→ deviceGateway | PubNub.PushService | No | fcm | as above | Option for receiving push notifications on Android (fcm or gcm) or iOS (apns or apns2) devices. These are the available types:
|
→ apnsTopic | String | No | n/a | as above | An Apple specific-option for sending and receiving notifications. This string is a bundle ID that you must define yourself for your iOS app so that Apple could enable push notifications for it in APNs. The string takes the following format: com.domainname.applicationname. Apple combines that ID with your Team ID (generated by Apple) and creates an App ID for your application. To send pushes from an iOS device, you must also set sendPushes to true. To receive pushes on an iOS device, you must also set deviceGateway to apns2, define deviceToken, and apnsEnvironment. Suppose you don't configure apnsTopic, but set deviceGateway to apns2. In that case, you'll get the apnsTopic has to be defined when deviceGateway is set to apns2 error and Chat SDK won't attach the apns payload to messages. |
→ apnsEnvironment | PubNub.PushEnvironment | No | development | as above | Option for receiving notifications on iOS devices. When registering for push notifications, this option specifies whether to use the development (development) or production (production) APNs environment. |
rateLimitFactor | Int | No | 2 | Client-side rate limiting | The so-called "exponential backoff" which multiplicatively decreases the rate at which messages are published on channels. It's bound to the rateLimitPerChannel parameter and is meant to prevent message spamming caused by excessive retries. The default value of 2 means that if you set rateLimitPerChannel for direct channels to 1 second and try to send three messages on such a channel type within the span of one second, the second message will be published one second after the first one (just like the rateLimitPerChannel value states), but the third one will be published two seconds after the second one, meaning the publishing time is multiplied by 2. |
rateLimitPerChannel | [ChannelType: Int64] | No | n/a | Client-side rate limiting | Client-side limit that states the rate at which messages can be published on a given channel type. Its purpose is to prevent message spamming in your chat app. This parameter takes an object with these three parameters: direct, group, and public. |
→ direct | Int | No | 0 (no limit) | as above | Rate set on all direct (1:1) channels at which messages can be published. |
→ group | Int | No | 0 (no limit) | as above | Rate set on all group channels at which messages can be published. |
→ public | Int | No | 0 (no limit) | as above | Rate set on all public channels at which messages can be published. |
→ unknown | Int | No | 0 (no limit) | as above | Rate set on all channels created using the Swift SDK instead of Swift Chat SDK. |
customPayloads | CustomPayloads | No | n/a | Send and receive messages | Property that lets you define your custom message payload to be sent and/or received by Chat SDK on one or all channels, whenever it differs from the default message.text Chat SDK payload. It also lets you configure your own message reactions whenever a message is edited or deleted. For examples, check Custom payload. |
→ getMessagePublishBody | Function that takes three parameters:
| No | n/a | as above | Function that lets Chat SDK send your custom payload structure. It defines the structure of your own message payload's body (of any type) that you're sending through PubNub. Expand the Message-related types section for more details on the required TextMessageContent structure. Define getMessageResponseBody whenever you use getMessagePublishBody. |
→ getMessageResponseBody | Function that takes three parameters:
| No | n/a | as above | Function that lets Chat SDK receive your custom payload structure. Use it to let Chat SDK translate your custom message payload into the default Chat SDK message format (defined in EventContent.TextMessageContent). Expand the Message-related types section for more details on the required EventContent.TextMessageContent structure. Define getMessagePublishBody whenever you use getMessageResponseBody. |
→ editMessageActionName | String | No | n/a | as above | A type of action you want to be added to your Message object whenever a published message is edited, like "changed" or "modified". The default message reaction used by Chat SDK is "edited". Expand the Message-related types section for more details. |
→ deleteMessageActionName | String | No | n/a | as above | A type of action you want to be added to your Message object whenever a published message is deleted, like "removed". The default message reaction used by Chat SDK is "deleted". Expand the Message-related types section for more details. |
Additional configuration options
Since the Chat SDK heavily relies on the latest Swift SDK for all the underlying methods, when initializing the Chat SDK client, you can also make use of all optional parameters that come with the Swift SDK.
For example, you can decide how long the server will consider the client alive for presence (presenceTimeout) or how often the client will announce itself to the server (heartbeatInterval).
For the whole list of all such inherited optional parameters which you can define when initializing the Chat SDK instance, check the Swift SDK configuration document.
Basic usage
Required setup
Use this basic example to initialize the client setting only the required parameters.
// Create PubNub configuration
let pubNubConfiguration = PubNubConfiguration(
publishKey: "your-publish-key",
subscribeKey: "your-subscribe-key",
userId: "your-user-id"
// Add other required parameters
)
// Create Chat configuration
let chatConfiguration = ChatConfiguration(
// Fill in the necessary parameters for ChatConfiguration
)
// Create ChatImpl instance
let yourChat = ChatImpl(
Typing indicator timeout
Initialize the PubNub Chat SDK and set the default typing indicator timeout value to three seconds.
// Create PubNub configuration
let pubNubConfiguration = PubNubConfiguration(
publishKey: "your-publish-key",
subscribeKey: "your-subscribe-key",
userId: "your-user-id"
// Add other required parameters
)
// Create Chat configuration
let chatConfiguration = ChatConfiguration(
typingTimeout: 3
)
// Create ChatImpl instance
let yourChat = ChatImpl(
Client-side rate limiting
Initialize the PubNub Chat SDK and set the hard limit for message publishing on public channels to three seconds. If there are more publish retries within this limit, each next retry limit should be multiplied by 3.
// Create PubNub configuration
let pubNubConfiguration = PubNubConfiguration(
publishKey: "your-publish-key",
subscribeKey: "your-subscribe-key",
userId: "your-user-id"
// Add other required parameters
)
// Create Chat configuration
let chatConfiguration = ChatConfiguration(
rateLimitFactor: 3,
rateLimitPerChannel: [
.public: Int64(3 * 1000) // 3 seconds converted to milliseconds
]
)
Custom payload
When initializing Chat SDK, you can pass your custom message payload structure using the customPayloads object and related properties. This will let Chat SDK correctly interpret your app's messages when sending and receiving them.
Define custom payload for all channels
Let's say your app doesn't follow the default message.text message body structure imposed by Chat SDK but instead uses the my.custom.payload.structure.text structure.
To successfully communicate with PubNub and send/receive messages through Chat SDK, pass your custom payload to all channels. Additionally, define your custom action names to be added to messages when they're edited or deleted.
// Define custom payloads
let customPayloads = CustomPayloads(
getMessagePublishBody: { content, _, _ in
return [
"custom": [
"payload": [
"text": content.text
]
// Optionally also save files as ["files": content.files]
]
]
},
getMessageResponseBody: { json, _, _ in
guard
let custom = try? json.decode([String: AnyJSON].self),
Define custom payload for one channel
Let's say your app doesn't follow the default message.text message body structure imposed by Chat SDK for support-channel but instead uses the my.custom.payload.structure.text structure to communicate with PubNub.
Pass your custom payload to support-channel to successfully communicate with PubNub and send/receive messages through Chat SDK. Additionally, define your custom action names to be added to messages when they're edited or deleted.
The code sets up a PubNub chat instance with specific handlers for processing message payloads differently based on the channel.
// Define custom payloads
let customPayloads = CustomPayloads(
getMessagePublishBody: { content, channelId, defaultHandler in
if channelId == "support-channel" {
return [
"my": [
"custom": [
"payload": [
"structure": content.text
]
]
],
// Optional parameter
"files": content.files as Any,
] as [String: Any]
Next steps
Now that you've initialized and configured the Chat SDK, you can start creating channels, adding users, and powering your app with all sorts of features.