Message threads

The message threads feature organizes conversations into threads, making it easier to follow and respond to specific topics.

Users need threads to:

• Set topic-specific discussions - within group chats or 1:1 conversations, you can initiate or participate in separate threads dedicated to specific topics, ensuring focused and structured discussions.

• Clarify and resolve issues - message threads let you address specific problems or questions within a conversation, allowing you to provide relevant input and ensure clarity and efficient problem-solving.

• Reduce confusion - by allowing you to focus the conversation in a separate thread, you minimize cross-talk and make the conversation easier to follow.

In the Chat SDK, a thread is a separate channel created for a selected message. Such a thread channel gets the ID starting with PUBNUB_INTERNAL_THREAD followed by the channel ID and message ID (separated by underscores). The message for which you create a thread channel has the hasThread parameter set to true to distinguish it from other messages. All messages in a thread (thread messages) are ordered by timetokens containing info on when messages were published.

Each thread message (threadMessage) and thread channel (threadChannel) are separate entities in the Chat SDK that extend the message and channel entities. This means that they offer separate methods for handling threads but also let you use all methods under the message and channel entities (for example, for editing or deleting).

Interactive demo

Check how a sample implementation could look like in a React app showcasing how to reply to messages in threads and quote messages sent by others.

Want to implement something similar?

Read how to do that or go straight to the demo's source code.

Create thread

createThread() creates a thread (channel) for a selected message with additional options.

Method signature

1fun createThread(
2    text: String,
3    meta: Map<String, Any>? = null,
4    shouldStore: Boolean = true,
5    usePost: Boolean = false,
6    ttl: Int? = null,
7    quotedMessage: Message? = null,
8    files: List<InputFile>? = null,
9    usersToMention: Collection<String>? = null,
10    customPushData: Map<String, String>? = null
11): PNFuture<ThreadChannel>

Input parameters

* required

Parameter	Description
text * Type: String Default: n/a	The text you want to send to the selected channel.
meta Type: Map<String, Any>? Default: null	Additional details to publish with the request.
shouldStore Type: Boolean Default: true	If true, the messages are stored in Message Persistence if enabled.
usePost Type: Boolean Default: false	Use HTTP POST for the request.
ttl Type: Int? Default: null	Time (in hours) the message should be stored.
quotedMessage Type: Message? Default: null	Contains info about quoted messages.
files Type: List<InputFile>? Default: null	List of files attached to the text message.
usersToMention Type: Collection<String>? Default: null	Collection of user IDs to notify with a mention.
customPushData Type: Map<String, String>? Default: null	Additional key-value pairs for push messages.

Output

Type	Description
PNFuture<ThreadChannel>	Object returning the thread channel metadata for managing and interacting with the thread.

Sample code

Create a thread for the last message on the support channel.

1channel.getHistory(count = 1).async { historyResult ->
2    historyResult.onSuccess { history ->
3        val messages = history.messages
4        if (messages.isNotEmpty()) {
5            val lastMessage = messages.last()
6            lastMessage.createThread(
7                text = "Thread starting text",
8                meta = mapOf("key" to "value"),
9                shouldStore = true,
10                ttl = 24
11            ).async { threadResult ->
12                threadResult.onSuccess { threadChannel ->
13                    // handle success
14                }.onFailure {
15                    // handle failure
16                }
17            }
18        } else {
19            // handle no messages found
20        }
21    }.onFailure {
22        // handle failure
23    }
24}

show all 24 lines

Send thread message

Reply to a message in a thread by calling the sendText() method from the previously created threadChannel object.

Method signature

Head over to the sendText() method section for details.

Sample code

Send a message in a thread created for the last message on the support channel.

1channel.getHistory(count = 1).async { historyResult ->
2    historyResult.onSuccess { history ->
3        val messages = history.messages
4        if (messages.isNotEmpty()) {
5            val lastMessage = messages.last()
6            lastMessage.createThread().async { threadResult ->
7                threadResult.onSuccess { threadChannel ->
8                    threadChannel.sendText("Good job, guys!").async { /*...*/ }
9                }.onFailure {
10                    // handle failure
11                }
12            }
13        } else {
14            // handle no messages found
15        }
16    }.onFailure {
17        // handle failure
18    }
19}

show all 19 lines

Get thread

Get the thread channel on which the thread message is published.

Method signature

This method has the following signature:

1message.getThread(): PNFuture<ThreadChannel>

Input

This method doesn't take any parameters.

Output

Type	Description
PNFuture<ThreadChannel>	Object returning the thread channel metadata.

Sample code

Get the thread channel created from the message with the 16200000000000001 timetoken.

1val supportChannel = chat.getChannel("support")
2

3supportChannel.getMessage(16200000000000001).async { messageResult ->
4    messageResult.onSuccess { message ->
5        message?.getThread()?.async { threadResult ->
6            threadResult.onSuccess { threadChannel ->
7                // handle success
8            }.onFailure {
9                // handle failure
10            }
11        } ?: run {
12            // handle message not found
13        }
14    }.onFailure {
15        // handle failure
16    }
17}

show all 17 lines

Check if message starts thread

You can access the hasThread property of the Message object to check if a given message starts a thread.

Sample code

Check if the message with the 16200000000000001 timetoken starts a thread.

1// get the channel
2pubnub.getChannel("support").async { result ->
3    result.onSuccess { channel ->
4        // fetch the message history
5        channel.getHistory(
6            startTimetoken = 16200000000000000,
7            endTimetoken = 16200000000000001,
8            count = 1
9        ).async { historyResult ->
10            historyResult.onSuccess { history: PNHistoryResult ->
11                // reference the message
12                val message = history.messages.firstOrNull()
13

14                // check if the message starts a thread
15                if (message?.hasThread == true) {
16                    println("The message starts a thread.")
17                } else {
18                    println("The message does not start a thread.")
19                }
20            }.onFailure { error ->
21                // handle failure
22                println("Failed to fetch history: ${error.message}")
23            }
24        }
25    }.onFailure { error ->
26        // handle failure
27        println("Failed to get channel: ${error.message}")
28    }
29}

show all 29 lines

Get thread message updates

You can receive updates when specific message threads and related message reactions are added, edited, or removed on other clients using the streamUpdatesOn() on the ThreadMessage object.

This method accepts a callback function as an argument. The Chat SDK invokes this callback whenever someone adds, edits or deletes a message, or adds or removes a message reaction to/from a list of thread messages.

Underneath, this method subscribes the current user to a channel and adds a message actions event listener to receive all messageAction events of type added or removed. These methods also return the unsubscribe function you can invoke to stop receiving messageAction events and unsubscribe from the channel.

Method signature

This method takes the following parameters:

1class ThreadMessage {
2        companion object {
3            fun streamUpdatesOn(
4                messages: Collection<ThreadMessage>,
5                callback: (messages: Collection<ThreadMessage>) -> Unit
6            ): AutoCloseable
7        }
8    }

Input

* required

Parameter	Description
messages * Type: Collection<ThreadMessage> Default: n/a	Collection of ThreadMessage objects for which you want to get updates on changed message threads or related message reactions.
callback * Type: (messages: Collection<ThreadMessage>) -> Unit Default: n/a	Callback function passed to the method as a parameter. It defines the custom behavior to be executed when detecting changes in message threads or related message reactions.

Output

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

Sample code

Get message threads and message reaction-related updates for the first page of messages published in a thread.

1val messageWithThread: Message
2

3messageWithThread.getThread().async {
4    it.onSuccess { threadChannel ->
5        threadChannel.getHistory().async {
6            it.onSuccess { historyResponse ->
7                // stream updates for the fetched thread messages
8                val autoCloseable =
9                    ThreadMessage.streamUpdatesOn(messages = historyResponse.messages) { updatedThreadMessages ->
10                        updatedThreadMessages.forEach { updatedThreadMessage ->
11                            println("-=Updated thread message: $updatedThreadMessage")
12                        }
13                    }
14

15                // to stop streaming updates at some later point, use:
16                // autoCloseable.close()
17            }.onFailure {
18                // ...
19            }
20        }
21    }.onFailure {
22        
23    }
24}

show all 24 lines

Other examples

Stop listening to updates for the last ten messages published in a thread.

1val messageWithThread: Message
2        
3messageWithThread.getThread().async {
4    it.onSuccess { threadChannel ->
5        threadChannel.getHistory(count = 10).async {
6            it.onSuccess { historyResponse ->
7                // stream updates for the fetched thread messages
8                val autoCloseable =
9                    ThreadMessage.streamUpdatesOn(messages = historyResponse.messages) { updatedThreadMessages ->
10                        updatedThreadMessages.forEach { updatedThreadMessage ->
11                            println("-=Updated thread message: $updatedThreadMessage")
12                        }
13                    }
14

15                // stop listening to updates at some later point
16                // Note: You will add this at the point where you want to stop listening
17                // In this example, it is immediate for demonstration purposes.
18                autoCloseable.close() // Stop listening to updates
19            }.onFailure {
20                // ...
21            }
22        }
23    }.onFailure {
24        // ...
25    }
26}

show all 26 lines

Get historical thread message

getHistory() called on the threadChannel object fetches historical thread messages from that thread channel.

Method signature

This method takes the following parameters:

1threadChannel.getHistory(
2    startTimetoken: Long?,
3    endTimetoken: Long?,
4    count: Int
5): PNFuture<HistoryResponse<ThreadMessage>>

Input

* required

Parameter	Description
startTimetoken Type: Long Default: n/a	Timetoken delimiting the start of a time slice (exclusive) to pull thread messages from. For details, refer to Message Persistence.
endTimetoken Type: Long Default: n/a	Timetoken delimiting the end of a time slice (inclusive) to pull thread messages from. For details, refer to the Message Persistence.
count * Type: Int Default: 25	Number of historical thread messages to return for the channel in a single call. Since each call returns all attached message reactions by default, the maximum number of returned thread messages is 25. For more details, refer to the description of the includeMessageActions parameter in the Kotlin SDK docs.

Output

Parameter	Description
PNFuture<HistoryResponse<ThreadMessage>> Type: object	PNFuture holding HistoryResponse containing a list of ThreadMessage objects and a Boolean flag indicating if there are more messages available.

By default, each call returns all message reactions and metadata attached to the retrieved thread messages.

Sample code

From the thread created for the last message in the support channel, fetch 10 historical thread messages that are older than the timetoken 15343325214676133.

1// reference the "support" channel asynchronously
2chat.getChannel("support").async { channelResult ->
3    channelResult.onSuccess { channel ->
4        if (channel != null) {
5            // get the last message on the channel, which is the root message for the thread
6            channel.getHistory(count = 1).async { messageResult ->
7                messageResult.onSuccess { historyResponse ->
8                    val message = historyResponse.messages.firstOrNull()
9                    
10                    if (message != null) {
11                        // get the thread channel
12                        message.getThread().async { threadChannelResult ->
13                            threadChannelResult.onSuccess { threadChannel ->
14                                if (threadChannel != null) {
15                                    // fetch the required historical messages
16                                    threadChannel.getHistory(
17                                        startTimetoken = null,
18                                        endTimetoken = 15343325214676133,
19                                        count = 10
20                                    ).async { threadMessageResult ->
21                                        threadMessageResult.onSuccess { threadHistoryResponse ->
22                                            // handle the retrieved thread messages (success)
23                                            val threadMessages = threadHistoryResponse.messages
24                                            threadMessages.forEach { println(it) }
25                                        }.onFailure {
26                                            // handle failure in fetching thread messages
27                                            println("Failed to fetch thread messages")
28                                            it.printStackTrace()
29                                        }
30                                    }
31                                } else {
32                                    println("Failed to retrieve the thread channel")
33                                }
34                            }.onFailure {
35                                println("Failed to get the thread channel")
36                                it.printStackTrace()
37                            }
38                        }
39                    } else {
40                        println("No messages found in the support channel")
41                    }
42                }.onFailure {
43                    println("Failed to get history for the support channel")
44                    it.printStackTrace()
45                }
46            }
47        } else {
48            println("Support channel does not exist")
49        }
50    }.onFailure {
51        // handle failure in getting the support channel
52        println("Failed to retrieve the support channel")
53        it.printStackTrace()
54    }
55}

show all 55 lines

Remove thread

removeThread() removes a thread (channel) for a selected message.

Method signature

This method has the following signature:

1message.removeThread(): PNFuture<Pair<PNRemoveMessageActionResult, Channel>>

Input

This method doesn't take any parameters.

Output

Type	Description
PNFuture<Pair<PNRemoveMessageActionResult, Channel>>	A pair of values containing an object with details about the result of the remove message reaction (indicating whether the message was successfully removed and potentially including additional metadata or information about the removal) aand the updated channel object after the removal of the thread.

Sample code

Remove a thread for the last message on the support channel.

1// retrieve the "support" channel
2chat.getChannel("support").async { channelResult ->
3    channelResult.onSuccess { channel ->
4        // get the last message from the channel’s history
5        channel.getHistory(count = 1).async { historyResult ->
6            historyResult.onSuccess { historyResponse ->
7                val message = historyResponse.messages.firstOrNull()
8                if (message != null) {
9                    // remove the thread for the last message
10                    message.removeThread().async { removeThreadResult ->
11                        removeThreadResult.onSuccess { (removeMessageResult, updatedChannel) ->
12                            println("Thread removed successfully.")
13                            println("Result: $removeMessageResult")
14                            println("Updated Channel: $updatedChannel")
15                        }.onFailure { throwable ->
16                            println("Failed to remove thread.")
17                            throwable.printStackTrace()
18                        }
19                    }
20                } else {
21                    println("No messages found in the support channel.")
22                }
23            }.onFailure { throwable ->
24                println("Failed to get history for the support channel.")
25                throwable.printStackTrace()
26            }
27        }
28    }.onFailure { throwable ->
29        println("Failed to retrieve the support channel.")
30        throwable.printStackTrace()
31    }
32}

show all 32 lines

Pin thread message to thread channel

pinMessage() called on the ThreadChannel object pins a selected thread message to the thread channel.

Method signature

This method takes the following parameters:

1threadChannel.pinMessage(
2    message: Message
3): PNFuture<ThreadChannel>

Input

* required

Parameter	Description
message * Type: Message Default: n/a	Message object you want to pin to the selected thread channel.

Output

Type	Description
PNFuture<ThreadChannel>	Object returning the thread channel metadata updated with these custom fields: pinnedMessageTimetoken to mark the timetoken when the message was pinned pinnedMessageChannelID to mark the channel on which the message was pinned to the thread channel (unpinning was performed either directly on the parent channel or on a thread channel).

Sample code

A thread was created for the last message in the support parent channel. Pin the last message from this thread to the thread channel.

1// reference the "support" channel where the root message for the thread is published
2chat.getChannel("support").async { channelResult ->
3    channelResult.onSuccess { channel ->
4        // get the last message on the channel, which is the root message for the thread
5        channel.getHistory(null, null, 1).async { historyResult ->
6            historyResult.onSuccess { history ->
7                val message = history.messages[0]
8

9                // get the thread channel
10                message.getThread().async { threadChannelResult ->
11                    threadChannelResult.onSuccess { threadChannel ->
12                        // get the last message on the thread channel
13                        threadChannel.getHistory(null, null, 1).async { threadHistoryResult ->
14                            threadHistoryResult.onSuccess { threadHistory ->
15                                val threadMessage = threadHistory.messages[0]
16

17                                // pin the last message from the thread to the thread channel
18                                threadChannel.pinMessage(threadMessage).async { pinResult ->
19                                    pinResult.onSuccess { pinnedChannel ->
20                                        // handle success (pinnedChannel refers to the thread channel with the pinned message)
21                                    }.onFailure { pinError ->
22                                        // Handle failure
23                                    }
24                                }
25                            }.onFailure { threadHistoryError ->
26                                // handle failure
27                            }
28                        }
29                    }.onFailure { threadChannelError ->
30                        // handle failure
31                    }
32                }
33            }.onFailure { historyError ->
34                // handle failure
35            }
36        }
37    }.onFailure { channelError ->
38        // handle failure
39    }
40}

show all 40 lines

Pin thread message to parent channel

You can pin a selected thread message to the parent channel with pinMessageToParentChannel() and pinToParentChannel(). They give the same output, and the only difference is that you call a given method either on the ThreadChannel or the ThreadMessage object. Depending on the object, these methods take different input parameters - you have to specify the thread message you want to pin or not because it's already known.

Method signature

These methods take the following parameters:

• pinMessageToParentChannel()

  1threadChannel.pinMessageToParentChannel(
  2    message: ThreadMessage
  3):  PNFuture<Channel>

• pinToParentChannel()

  1threadMessage.pinToParentChannel(): PNFuture<Channel>

Input

Parameter	Required in pinMessageToParentChannel()	Required in pinToParentChannel()	Description
message Type: ThreadMessage Default: n/a	Yes	No	ThreadMessage object you want to pin to the selected parent channel.

Output

Type	Description
PNFuture<Channel>	Object returning the channel metadata updated with these custom fields: pinnedMessageTimetoken to mark the timetoken when the message was pinned pinnedMessageChannelID to mark the channel on which the message was pinned to the parent channel (pinning was performed either directly on the parent channel or on a thread channel).

Sample code

A thread was created for the last message in the support parent channel. Pin the last message from this thread to the parent channel.

• pinMessageToParentChannel()

  1// reference the "support" channel where the root message for the thread is published
  2chat.getChannel("support").async { channelResult ->
  3    channelResult.onSuccess { channel ->
  4        // get the last message on the channel, which is the root message for the thread
  5        channel.getHistory(null, null, 1).async { historyResult ->
  6            historyResult.onSuccess { history ->
  7                val message = history.messages[0]
  8
  
  9                // get the thread channel
  10                message.getThread().async { threadChannelResult ->
  11                    threadChannelResult.onSuccess { threadChannel ->
  12                        // get the last message on the thread channel
  13                        threadChannel.getHistory(null, null, 1).async { threadHistoryResult ->
  14                            threadHistoryResult.onSuccess { threadHistory ->
  15                                val threadMessage = threadHistory.messages[0]
  16
  
  17                                // pin the message to the parent channel
  18                                threadChannel.pinMessageToParentChannel(threadMessage).async { pinResult ->
  19                                    pinResult.onSuccess { pinnedChannel ->
  20                                        // handle success (pinnedChannel refers to the parent channel with the pinned message)
  21                                    }.onFailure { pinError ->
  22                                        // handle failure
  23                                    }
  24                                }
  25                            }.onFailure { threadHistoryError ->
  26                                // handle failure
  27                            }
  28                        }
  29                    }.onFailure { threadChannelError ->
  30                        // handle failure
  31                    }
  32                }
  33            }.onFailure { historyError ->
  34                // handle failure
  35            }
  36        }
  37    }.onFailure { channelError ->
  38        // handle failure
  39    }
  40}

  show all 40 lines

• pinToParentChannel()

  1// reference the "support" channel where the root message for the thread is published
  2chat.getChannel("support").async { channelResult ->
  3    channelResult.onSuccess { channel ->
  4        // get the last message on the channel, which is the root message for the thread
  5        channel.getHistory(null, null, 1).async { historyResult ->
  6            historyResult.onSuccess { history ->
  7                val message = history.messages[0]
  8
  
  9                // get the thread channel
  10                message.getThread().async { threadChannelResult ->
  11                    threadChannelResult.onSuccess { threadChannel ->
  12                        // get the last message on the thread channel
  13                        threadChannel.getHistory(null, null, 1).async { threadHistoryResult ->
  14                            threadHistoryResult.onSuccess { threadHistory ->
  15                                val threadMessage = threadHistory.messages[0]
  16
  
  17                                // pin the message to the parent channel using threadMessage.pinToParentChannel()
  18                                threadMessage.pinToParentChannel().async { pinResult ->
  19                                    pinResult.onSuccess { pinnedChannel ->
  20                                        // handle success (pinnedChannel refers to the parent channel with the pinned message)
  21                                    }.onFailure { pinError ->
  22                                        // handle failure
  23                                    }
  24                                }
  25                            }.onFailure { threadHistoryError ->
  26                                // handle failure
  27                            }
  28                        }
  29                    }.onFailure { threadChannelError ->
  30                        // handle failure
  31                    }
  32                }
  33            }.onFailure { historyError ->
  34                // handle failure
  35            }
  36        }
  37    }.onFailure { channelError ->
  38        // handle failure
  39    }
  40}

  show all 40 lines

Unpin thread message from thread channel

unpinMessage() called on the ThreadChannel object unpins the previously pinned thread message from the thread channel.

Method signature

This method has the following signature:

1threadChannel.unpinMessage(): PNFuture<ThreadChannel>

Input

This method doesn't take any parameters.

Output

Type	Description
PNFuture<ThreadChannel>	Object returning the thread channel metadata updated with these custom fields: pinnedMessageTimetoken to mark the timetoken when the message was unpinned pinnedMessageChannelID to mark the channel on which the message was unpinned from the thread channel (unpinning was performed either directly on the parent channel or on a thread channel).

Sample code

Unpin the thread message from the thread (channel) created for the last message on the support channel.

1// reference the "support" channel where the root message for the thread is published
2chat.getChannel("support").async { channelResult ->
3    channelResult.onSuccess { channel ->
4        // get the last message on the channel, which is the root message for the thread
5        channel.getHistory(null, null, 1).async { historyResult ->
6            historyResult.onSuccess { history ->
7                val message = history.messages[0]
8

9                // get the thread channel
10                message.getThread().async { threadChannelResult ->
11                    threadChannelResult.onSuccess { threadChannel ->
12                        // get the last message on the thread channel
13                        threadChannel.getHistory(null, null, 1).async { threadHistoryResult ->
14                            threadHistoryResult.onSuccess { threadHistory ->
15                                val threadMessage = threadHistory.messages[0]
16

17                                // unpin the last message from the thread channel
18                                threadChannel.unpinMessage(threadMessage).async { unpinResult ->
19                                    unpinResult.onSuccess { unpinnedThreadChannel ->
20                                        // handle success (unpinnedThreadChannel refers to the thread channel without the unpinned message)
21                                    }.onFailure { unpinError ->
22                                        // Handle failure
23                                    }
24                                }
25                            }.onFailure { threadHistoryError ->
26                                // handle failure
27                            }
28                        }
29                    }.onFailure { threadChannelError ->
30                        // handle failure
31                    }
32                }
33            }.onFailure { historyError ->
34                // handle failure
35            }
36        }
37    }.onFailure { channelError ->
38        // handle failure
39    }
40}

show all 40 lines

Unpin thread message from parent channel

You can unpin the previously pinned thread message from the parent channel with unpinMessageFromParentChannel() and unpinFromParentChannel().

Method signature

These methods have the following signatures:

• unpinMessageFromParentChannel()

  1threadChannel.unpinMessageFromParentChannel(): PNFuture<Channel>

• unpinFromParentChannel()

  1threadMessage.unpinFromParentChannel(): PNFuture<Channel>

Input

These methods don't take any parameters.

Output

Type	Description
PNFuture<Channel>	Object returning the channel metadata updated with these custom fields: pinnedMessageTimetoken to mark the timetoken when the message was unpinned pinnedMessageChannelID to mark the channel on which the message was unpinned from the parent channel (unpinning was performed either directly on the parent channel or on a thread channel).

Sample code

Unpin the thread message from the support parent channel.

• unpinMessageFromParentChannel()

  1// reference the "support" channel where the root message for the thread is published
  2chat.getChannel("support").async { channelResult ->
  3    channelResult.onSuccess { channel ->
  4        // get the last message on the channel, which is the root message for the thread
  5        channel.getHistory(null, null, 1).async { historyResult ->
  6            historyResult.onSuccess { history ->
  7                val message = history.messages[0]
  8
  
  9                // get the thread channel
  10                message.getThread().async { threadChannelResult ->
  11                    threadChannelResult.onSuccess { threadChannel ->
  12                        // get the last message on the thread channel
  13                        threadChannel.getHistory(null, null, 1).async { threadHistoryResult ->
  14                            threadHistoryResult.onSuccess { threadHistory ->
  15                                val threadMessage = threadHistory.messages[0]
  16
  
  17                                // unpin the last message from the parent "support" channel
  18                                threadChannel.unpinMessageFromParentChannel(threadMessage).async { unpinResult ->
  19                                    unpinResult.onSuccess { parentChannel ->
  20                                        // handle success (parentChannel refers to the parent "support" channel without the unpinned message)
  21                                    }.onFailure { unpinError ->
  22                                        // Handle failure
  23                                    }
  24                                }
  25                            }.onFailure { threadHistoryError ->
  26                                // handle failure
  27                            }
  28                        }
  29                    }.onFailure { threadChannelError ->
  30                        // handle failure
  31                    }
  32                }
  33            }.onFailure { historyError ->
  34                // handle failure
  35            }
  36        }
  37    }.onFailure { channelError ->
  38        // handle failure
  39    }
  40}

  show all 40 lines

• unpinFromParentChannel()

  1// reference the "support" channel where the root message for the thread is published
  2chat.getChannel("support").async { channelResult ->
  3    channelResult.onSuccess { channel ->
  4        // get the last message on the channel, which is the root message for the thread
  5        channel.getHistory(null, null, 1).async { historyResult ->
  6            historyResult.onSuccess { history ->
  7                val message = history.messages[0]
  8
  
  9                // get the thread channel
  10                message.getThread().async { threadChannelResult ->
  11                    threadChannelResult.onSuccess { threadChannel ->
  12                        // get the last message on the thread channel
  13                        threadChannel.getHistory(null, null, 1).async { threadHistoryResult ->
  14                            threadHistoryResult.onSuccess { threadHistory ->
  15                                val threadMessage = threadHistory.messages[0]
  16
  
  17                                // unpin the last message from the parent "support" channel
  18                                threadMessage.unpinFromParentChannel().async { unpinResult ->
  19                                    unpinResult.onSuccess { parentChannel ->
  20                                        // handle success (parentChannel refers to the parent "support" channel without the unpinned message)
  21                                    }.onFailure { unpinError ->
  22                                        // Handle failure
  23                                    }
  24                                }
  25                            }.onFailure { threadHistoryError ->
  26                                // handle failure
  27                            }
  28                        }
  29                    }.onFailure { threadChannelError ->
  30                        // handle failure
  31                    }
  32                }
  33            }.onFailure { historyError ->
  34                // handle failure
  35            }
  36        }
  37    }.onFailure { channelError ->
  38        // handle failure
  39    }
  40}

  show all 40 lines

Create thread message draft

createThreadMessageDraft() creates a message draft for composing a message in an existing thread channel. This allows users to craft a message with additional options like user suggestion and typing indicator.

Method signature

1fun Message.createThreadMessageDraft(
2    userSuggestionSource: UserSuggestionSource = UserSuggestionSource.CHANNEL,
3    isTypingIndicatorTriggered: Boolean = true,
4    userLimit: Int = 10,
5    channelLimit: Int = 10
6): PNFuture<MessageDraft>

Input parameters

* required

Parameter	Description
userSuggestionSource Type: UserSuggestionSource Default: UserSuggestionSource.CHANNEL	Scope for searching suggested users.
isTypingIndicatorTriggered Type: Boolean Default: true	Whether modifying the message text triggers a typing indicator.
userLimit Type: Int Default: 10	Limit on number of users returned for mentions.
channelLimit Type: Int Default: 10	Limit on number of channels returned for references.

Output

Type	Description
PNFuture<MessageDraft>	Object used for composing and formatting a message draft in a thread channel.

Sample code

Create a message draft for the last message in the support channel and set up user suggestions and typing indicator.

1channel.getHistory(count = 1).async { historyResult ->
2    historyResult.onSuccess { history ->
3        val messages = history.messages
4        if (messages.isNotEmpty()) {
5            val lastMessage = messages.last()
6            lastMessage.createThreadMessageDraft(
7                userSuggestionSource = UserSuggestionSource.CHANNEL,
8                isTypingIndicatorTriggered = true,
9                userLimit = 10,
10                channelLimit = 10
11            ).async { draftResult ->
12                draftResult.onSuccess { messageDraft ->
13                    // Handle success: Compose your message using messageDraft
14                }.onFailure {
15                    // Handle failure
16                }
17            }
18        } else {
19            // Handle no messages found
20        }
21    }.onFailure {
22        // Handle failure in fetching history
23    }
24}

show all 24 lines

Create thread (deprecated)

Deprecated

This method is deprecated. Use Create thread instead.

createThread() creates a thread (channel) for a selected message.

Method signature

This method has the following signature:

1message.createThread(): PNFuture<ThreadChannel>

Input

This method doesn't take any parameters.

Output

Type	Description
PNFuture<ThreadChannel>	Object returning the thread channel metadata for the message updated with the hasThread parameter (and a threadRootId action type underneath).

Sample code

Create a thread for the last message on the support channel.

1channel.getHistory(count = 1).async { historyResult ->
2    historyResult.onSuccess { history ->
3        val messages = history.messages
4        if (messages.isNotEmpty()) {
5            val lastMessage = messages.last()
6            lastMessage.createThread().async { threadResult ->
7                threadResult.onSuccess { threadChannel ->
8                    // handle success
9                }.onFailure {
10                    // handle failure
11                }
12            }
13        } else {
14            // handle no messages found
15        }
16    }.onFailure {
17        // handle failure
18    }
19}

show all 19 lines