Presence

In your chat app, you might want to graphically show up-to-date information on all users present in an app or on a given channel, showing if they are online, offline, active, or away. You may also want to let other chat users know when was the last time a given user was online.

Chat SDK provides methods and options to determine user presence on the channel and the app (global) level. Additionally, it provides a way of checking the last time the user performed some online activity in the app based on a Unix timestamp.

To find out the channel presence of a user, Chat SDK uses the PubNub Presence API. It provides a set of convenience methods for checking which channels a given user is subscribed to. Importantly, you can stream presence events and always get real-time information about the user's channel presence. You can also set dynamic custom state for users on one or more channels. This custom state persists on a channel as long as the user stays subscribed. Some examples of custom states are to add your score, game state, or location in an application if it changes frequently.

For global (app) presence, however, Chat SDK couldn't rely on Presence API as it doesn't support global user presence, but is limited to the context of a given channel. To fill that gap, the Chat SDK offers an optional lastActiveTimestamp property on each User object that states when was the last time the user was active in an app.

Suppose you want to track users' global presence in your chat app (for example, to see a user's current online state when browsing the users). In that case, you can configure your app to monitor this property and set an interval to update it. You can later use a dedicated active method to retrieve that information and display it across the app or in the context of a given channel, if you like. Contrary to the channel presence, global user presence info is not real-time information and depends on how often you update it - the default value is 600 seconds (10 minutes) and the minimum value is 60 seconds (1 minute). You can set a preferred value during the Chat SDK initialization through the storeUserActivityTimestamps parameter.

Read the sections to learn how to use all Chat SDK options and what configuration is required to implement channel and global presence in your app.

Channel presence

These methods let you monitor who is subscribed to a given channel ("present" on that channel).

Requires Presence

All channel presence methods in this section require that Presence is enabled for your app's keyset in the Admin Portal.

You can retrieve similar information for presence with different methods by calling them on the User, Channel, or Chat object. Depending on the chosen method, you must provide a different input information set.

Return channels where user is present

You can return a list of channels where a given user is present with:

wherePresent() called on the User object
wherePresent() called on the Chat object.

Both of these methods have the same name and give the same output. The only difference is that you call a given method either on the Chat or the User object. Depending on the object, you either have to specify the ID of the user whose presence you want to check or not because it's already known.

Method signature

These methods take the following parameters:

wherePresent() (on the User object)

user.wherePresent(completion: ((Swift.Result<[String], Error>) -> Void)? = nil)

wherePresent() (on the Chat object)

chat.wherePresent(
    userId: String,
    completion: ((Swift.Result<[String], Error>) -> Void)? = nil
)

Input

Parameter	Type	Required in the `User` object method	Required in the `Chat` object method	Default	Description
`userId`	`String`	No	Yes	n/a	Unique identifier (up to 92 UTF-8 characters) of the user whose presence you want to check.

Output

Type	Description
`((Swift.Result<[String], Error>) -> Void)`	List of all channel IDs on which the given user is present.

Basic usage

Get a list of channels on which the support_agent_15 user is present.

wherePresent() (on the User object)

// Assuming you have a "chat" instance available
// Invoke the "getUser" method to fetch metadata of the 'support_agent_15'
chat?.getUser(
  userId: "support_agent_15"
) {
  switch $0 {
  case let .success(user):
    if let user = user {
      debugPrint("Fetched user metadata with ID: \(user.id)")      
      // Showcase usage of `wherePresent()` on the `User` object
      user.wherePresent { result in
        switch result {
        case let .success(channels):
          debugPrint("User is present in the following channels: \(channels)")
        case let .failure(error):
show all 25 lines

wherePresent() (on the Chat object)

// Reference the "chat" object and invoke the "wherePresent()" method
chat.wherePresent(userId: "support_agent_15") { result in
  switch result {
  case let .success(channels):
    debugPrint("User is present in the following channels: \(channels)")
  case let .failure(error):
    debugPrint("Failed to fetch channels for user: \(error)")
  }
}

Check user's channel presence

You can return information if the user is present on a specified channel with:

isPresentOn() called on the User object
isPresent() called on the Channel object.
isPresent() called on the Chat object.

All of these methods give the same output. The only difference is that you call a given method on the User, Channel, or Chat object. Depending on the object, you have to specify the ID of the user whose presence you want to check, the channel ID where you want to check user's presence, or both user and channel IDs.

Method signature

These methods take the following parameters:

isPresentOn() (on the User object)

user.isPresentOn(
    channelId: String,
    completion: ((Swift.Result<Bool, Error>) -> Void)? = nil
)

isPresent() (on the Channel object)

channel.isPresent(
    userId: String, 
    completion: ((Swift.Result<Bool, Error>) -> Void)? = nil
)

isPresent() (on the Chat object)

chat.isPresent(
    userId: String,
    channelId: String,
    completion: ((Swift.Result<Bool, Error>) -> Void)? = nil
)

Input

Parameter	Type	Required in the `User` object method	Required in the `Channel` object method	Required in the `Chat` object method	Default	Description
`userId`	`String`	No	Yes	Yes	n/a	Unique ID (up to 92 UTF-8 characters) of the user whose presence you want to check.
`channelId`	`String`	Yes	No	Yes	n/a	Unique identifier of the channel where you want to check the user's presence.

Output

Type	Description
`((Swift.Result<Bool, Error>) -> Void)`	Returns information on whether a given user is present on a specified channel (`true`) or not (`false`) or an error.

Basic usage

Find out if the support_agent_15 user is present on the support channel.

isPresentOn() (on the User object)

// 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 chat = ChatImpl(
show all 58 lines

isPresent() (on the Channel object)

// Assuming you have a channel instance (channel initialization code depending on the context)
let userId = "support_agent_15"
let channelId = "support_channel_123"

// Assuming Channel object initialization
let channel = ChannelImpl(chat: chat, id: channelId) 
// Showcase usage of `isPresent()` on the `Channel` object
channel.isPresent(userId: userId) { result in
  switch result {
  case let .success(isPresent):
    if isPresent {
      debugPrint("User \(userId) is present on the channel \(channelId).")
    } else {
      debugPrint("User \(userId) is NOT present on the channel \(channelId).")
    }
show all 19 lines

isPresent() (on the Chat object)

chat.isPresent(userId: userId, channelId: channelId) { result in
  switch result {
  case let .success(isPresent):
    if isPresent {
      debugPrint("User \(userId) is present on the channel \(channelId).")
    } else {
      debugPrint("User \(userId) is NOT present on the channel \(channelId).")
    }
  case let .failure(error):
    debugPrint("Failed to check presence for user \(userId) on the channel \(channelId): \(error)")
  }
}

Return all users present on channel

You can return a list of users present on the given channel with:

whoIsPresent() called on the Channel object
whoIsPresent() called on the Chat object.

Both of these methods have the same name and give the same output. The only difference is that you call a given method either on the Chat or the Channel object. Depending on the object, you either have to specify the ID of the channel where you want to check all present users or not because it's already known.

Method signature

These methods take the following parameters:

whoIsPresent() (on the Channel object)

channel.whoIsPresent(completion: ((Swift.Result<[String], Error>) -> Void)? = nil)

whoIsPresent() (on the Chat object)

chat.whoIsPresent(
    channelId: String,
    completion: ((Swift.Result<[String], Error>) -> Void)? = nil
) 

Input

Parameter	Type	Required in the `Channel` object method	Required in the `Chat` object method	Default	Description
`channelId`	`String`	No	Yes	n/a	Unique identifier of the channel where you want to check all present users.

Output

Type	Description
`((Swift.Result<[String], Error>) -> Void)`	List of all user IDs that are present on the given channel.

Basic usage

Get a list of users that are present on the support channel.

whoIsPresent() (on the Channel object)

// Assuming you have a channel instance available
let channel = ChannelImpl(chat: chat, id: "support_channel_123")  // Initialize with the correct channel ID

// Fetch the list of users present on the given channel
channel.whoIsPresent { result in
  switch result {
  case let .success(userIds):
    debugPrint("Users present on the channel: \(userIds)")
  case let .failure(error):
    debugPrint("Failed to fetch users present on the channel: \(error)")
  }
}

whoIsPresent() (on the Chat object)

// Fetch the list of users present on the given channel
chat.whoIsPresent(channelId: channelId) { result in
  switch result {
  case let .success(userIds):
    debugPrint("Users present on the channel \(channelId): \(userIds)")
  case let .failure(error):
    debugPrint("Failed to fetch users present on the channel \(channelId): \(error)")
  }
}

Get presence updates

Get up-to-date information about the real-time presence of users in the specified channel by subscribing to PubNub Presence events. The streamPresence() method lets you constantly track who connects to or disconnects from the channel and visually represent that in your chat app through some status, like offline, online, active, away, or any other.

Method signature

This method takes the following parameters:

channel.streamPresence(callback: @escaping (Set<String>) -> Void) -> AutoCloseable

Input

Parameter	Type	Required	Default	Description
`callback`	n/a	Yes	n/a	Callback function passed as a parameter. It defines the custom behavior to be executed when detecting new user presence events.
→ `userIds`	`Set<String>`	Yes	n/a	Returns an updated collection of user IDs.

Output

Type	Description
`AutoCloseable`	Interface that lets you stop receiving presence-related updates (`presence` events) by invoking the `close()` method.

Basic usage

Get user presence updates on support channel.

// Reference the "chat" object and invoke the "getChannel()" method
chat?.getChannel(
  channelId: "support"
) {
  switch $0 {
  case let .success(channel):
    if let channel = channel {
      debugPrint("Fetched channel metadata with ID: \(channel.id)")
      
      // Subscribe to user presence updates on the 'support' channel
      let autoCloseable = channel.streamPresence { userIds in
        debugPrint("Current users present on 'support' channel: \(userIds)")
      }
      
      // Optionally, store `autoCloseable` to stop receiving updates later
show all 24 lines

Global presence

The Chat SDK lets you configure your app to track the user's last online activity - this gives near real-time visibility into the availability of other chat members, allowing you to see whether someone is offline or available and reach out to them to start immediate communication.

Using this online activity information provided by the Chat SDK, you can later configure your app to display different statuses next to user profiles, like offline, online, active, away or any other.

This feature relies on the lastActiveTimestamp property set in seconds on the User object. This property stands for the Unix timestamp (numeric value representing the number of seconds since January 1, 1970) for the last time the user was active in a chat app. To track this, you must explicitly state that when configuring your app during the Chat SDK initialization by:

Setting the storeUserActivityTimestamps parameter to true.
Deciding how frequently a user's online activity will be updated by configuring the storeUserActivityInterval option - the default value is set to 600 seconds (10 minutes) and the minimum value is 60 seconds (1 minute).

If you set these options, you can track a user's global presence through the active method that relies on the above setup. If the user showed no online activity within the defined period of time, they are considered inactive.

Check user's app presence

active is a method called on the User object that lets you check whether a user has recently been active in the chat app based on their last activity timestamp and a configured interval.

Required configuration

To track the user's online activity, you must first configure the storeUserActivityTimestamps and storeUserActivityInterval parameters when initializing the Chat SDK.

Method signature

This method has the following signature:

user.active(completion: ((Swift.Result<Bool, Error>) -> Void))

Input

This method doesn't take any parameters.

Output

Type Description

((Swift.Result<Bool, Error>) -> Void)) Returned info on whether the user is active (true) or not active (false) on the channel. The returned value depends strictly on how you configure your chat app during initialization - if you set the storeUserActivityInterval parameter to the default 600 seconds (10 minutes) and the user has been active in the app within the last 10 minutes (based on their lastActiveTimestamp property), the active method returns true.

Type	Description
`((Swift.Result<Bool, Error>) -> Void))`	Returned info on whether the user is active (`true`) or not active (`false`) on the channel. The returned value depends strictly on how you configure your chat app during initialization - if you set the `storeUserActivityInterval` parameter to the default `600` seconds (10 minutes) and the user has been active in the app within the last 10 minutes (based on their `lastActiveTimestamp` property), the `active` method returns `true`.

Basic usage

Check if the user support_agent_15 has been recently active (assuming you configured the chat app to use the default activity interval value).

chat.getUser(
  userId: "support_agent_15"
) {
  switch $0 {
  case let .success(user):
    if let user = user {
      debugPrint("Fetched user metadata with ID: \(user.id)")
      
      // Check if the user is active
      user.active { result in
        switch result {
        case let .success(isActive):
          if isActive {
            debugPrint("User \(user.id) is currently active.")
          } else {
show all 29 lines

Check user's last online activity

Required configuration

To track the user's online activity, you must first configure the storeUserActivityTimestamps and storeUserActivityInterval parameters when initializing the Chat SDK.

Let's assume you configured your app to track the user's online activity and update it every 2 minutes. You can retrieve information on the user's last online activity directly from the User object, convert it to a human-readable date (using external date and time libraries), and display it next to the user's profile in your chat app. Thanks to that, other app users will be able to see the last time the given user was online.

Basic usage

Show the Unix timestamp when support_agent_15 was last time active in an app.

chat.getUser(
  userId: "support_agent_15"
) {
  switch $0 {
  case let .success(user):
    if let user = user {
      debugPrint("Fetched user metadata with ID: \(user.id)")
      debugPrint("Last active timestamp: \(user.lastActiveTimestamp)")      
    } else {
      debugPrint("User not found")
    }
  case let .failure(error):
    debugPrint("Failed to fetch user metadata: \(error)")
  }
}

Channel presence​

Requires Presence

Return channels where user is present​

Method signature​

Input​

Output​

Basic usage​

Check user's channel presence​

Method signature​

Input​

Output​

Basic usage​

Return all users present on channel​

Method signature​

Input​

Output​

Basic usage​

Get presence updates​

Method signature​

Input​

Output​

Basic usage​

Global presence​

Check user's app presence​

Required configuration

Method signature​

Input​

Output​

Basic usage​

Check user's last online activity​

Required configuration

Basic usage​

Channel presence

Return channels where user is present

Method signature

Input

Output

Basic usage

Check user's channel presence

Method signature

Input

Output

Basic usage

Return all users present on channel

Method signature

Input

Output

Basic usage

Get presence updates

Method signature

Input

Output

Basic usage

Global presence

Check user's app presence

Method signature

Input

Output

Basic usage

Check user's last online activity

Basic usage