Skip to main content

Thread management

Threads enable users to create a separate conversation from a specific message within a chat group to keep the main chat uncluttered.

The following illustration shows the implementation of creating a thread, a conversation in a thread, and the operations you can perform in a thread.

1655176216910

This page shows how to use the Chat SDK to create and manage threads in your app.

Understand the tech

The Chat SDK provides the ChatThreadManager, ChatThread, ChatThreadChangeListener, and ChatThreadEvent classes for thread management, which allow you to implement the following features:

  • Create and destroy a thread
  • Join and leave a thread
  • Remove a member from a thread
  • Update the name of a thread
  • Retrieve the attributes of a thread
  • Retrieve the member list of a thread
  • Retrieve a thread list
  • Retrieve the latest message from multiple threads
  • Listen for thread events

Prerequisites

Before proceeding, ensure that you meet the following requirements:

  • You have initialized the Chat SDK. For details, see Get Started with Android.
  • You understand the call frequency limit of the Chat APIs supported by different pricing plans as described in Limitations.
The thread feature is supported by all types of Pricing Plans and is enabled by default once you have enabled Chat in Agora Console.

Implementation

This section describes how to call the APIs provided by the Chat SDK to implement thread features.

Create a thread

All chat group members can call createChatThread to create a thread from a specific message in a chat group.

Once a thread is created in a chat group, all chat group members receive the ChatThreadChangeListener#onChatThreadCreated callback. In a multi-device scenario, all the other devices receive the MultiDeviceListener#onThreadEvent callback triggered by the THREAD_CREATE event.

The following sample code shows how to create a thread in a chat group:


_13
// parentId: The ID of a chat group where a thread resides.
_13
// messageId: The ID of a message, from which a thread is created.
_13
// threadName: The name of a thread. The maximum length of a thread name is 64 characters.
_13
ChatClient.getInstance().chatThreadManager().createChatThread(parentId, messageId, threadName, new ValueCallBack<ChatThread>() {
_13
@Override
_13
public void onSuccess(ChatThread value) {
_13
_13
}
_13
@Override
_13
public void onError(int error, String errorMsg) {
_13
_13
}
_13
});

Destroy a thread

Only the chat group owner and admins can call destroyChatThread to disband a thread in a chat group.

Once a thread is disbanded, all chat group members receive the ChatThreadChangeListener#onChatThreadDestroyed callback. In a multi-device scenario, all the other devices receive the MultiDeviceListener#onThreadEvent callback triggered by the THREAD_DESTROY event.

Once a thread is destroyed or the chat group where a thread resides is destroyed, all data of the thread is deleted from the local database and memory.

The following sample code shows how to destroy a thread:


_9
ChatClient.getInstance().chatThreadManager().destroyChatThread(chatThreadId, new CallBack() {
_9
@Override
_9
public void onSuccess() {
_9
_9
}
_9
@Override
_9
public void onError(int code, String error) {
_9
}
_9
});

Join a thread

All chat group members can refer to the following steps to join a thread:

  1. Use either of the following two approaches to retrieve the thread ID:
  • Retrieve the thread list in a chat group by calling getChatThreadsFromServer, and locate the ID of the thread that you want to join.
  • Retrieve the thread ID within the ChatThreadChangeListener#onChatThreadCreated and ChatThreadChangeListener#onChatThreadUpdated callbacks that you receive.
  1. Call joinChatThread to pass in the thread ID and join the specified thread.

In a multi-device scenario, all the other devices receive the MultiDeviceListener#onThreadEvent callback triggered by the THREAD_JOIN event.

The following sample code shows how to join a thread:


_9
ChatClient.getInstance().chatThreadManager().joinChatThread(chatThreadId, new ValueCallBack<ChatThread>() {
_9
@Override
_9
public void onSuccess(ChatThread value) {
_9
_9
}
_9
@Override
_9
public void onError(int error, String errorMsg) {
_9
}
_9
});

Leave a thread

All thread members can call leaveChatThread to leave a thread. Once a member leaves a thread, they can no longer receive the thread messages.

In a multi-device scenario, all the other devices receive the MultiDeviceListener#onThreadEvent callback triggered by the THREAD_LEAVE event.

The following sample code shows how to leave a thread:


_9
ChatClient.getInstance().chatThreadManager().leaveChatThread(chatThreadId, new CallBack() {
_9
@Override
_9
public void onSuccess() {
_9
_9
}
_9
@Override
_9
public void onError(int code, String error) {
_9
}
_9
});

Remove a member from a thread

Only the chat group owner and admins can call removeMemberFromChatThread to remove the specified member from a thread.

Once a member is removed from a thread, they receive the ChatThreadChangeListener#onChatThreadUserRemoved callback and can no longer receive the thread messages. In a multi-device scenario, all the other devices receive the MultiDeviceListener#onChatThreadEvent callback triggered by the THREAD_KICK event.

The following sample code shows how to remove a member from a thread:


_12
// chatThreadId: : The ID of a thread.
_12
// member: The ID of the user to be removed from a thread.
_12
ChatClient.getInstance().chatThreadManager().removeMemberFromChatThread(chatThreadId, member,
_12
new CallBack() {
_12
@Override
_12
public void onSuccess() {
_12
_12
}
_12
@Override
_12
public void onError(int code, String error) {
_12
}
_12
});

Update the name of a thread

Only the chat group owner, chat group admins, and thread creator can call updateChatThreadName to update a thread name.

Once a thread name is updated, all chat group members receive the ChatThreadChangeListener#onChatThreadUpdated callback. In a multi-device scenario, all the other devices receive the MultiDeviceListener#onThreadEvent callback triggered by the THREAD_UPDATE event.

The following sample code shows how to update a thread name:


_12
// chatThreadId: The ID of a thread.
_12
// newChatThreadName: The updated thread name. The maximum length of a thread name is 64 characters.
_12
ChatClient.getInstance().chatThreadManager().updateChatThreadName(chatThreadId, newChatThreadName,
_12
new CallBack() {
_12
@Override
_12
public void onSuccess() {
_12
_12
}
_12
@Override
_12
public void onError(int code, String error) {
_12
}
_12
});

Retrieve the attributes of a thread

All chat group members can call getChatThreadFromServer to retrieve the thread attributes from the server.

The following sample code shows how to retrieve the thread attributes:


_10
// chatThreadID: The thread ID.
_10
ChatClient.getInstance().chatThreadManager().getChatThreadFromServer(chatThreadId, new ValueCallBack<ChatThread>() {
_10
@Override
_10
public void onSuccess(ChatThread value) {
_10
_10
}
_10
@Override
_10
public void onError(int error, String errorMsg) {
_10
}
_10
});

Retrieve the member list of a thread

All chat group members can call getChatThreadMembers to retrieve the paginated member list of a thread from the server, as shown in the following sample code:


_13
// chatThreadId: The thread ID.
_13
// limit: The maximum number of members to retrieve per page. The range is [1, 50].
_13
// cursor: The position from which to start getting data. Pass in `null` or an empty string at the first call.
_13
ChatClient.getInstance().chatThreadManager().getChatThreadMembers(chatThreadId, limit, cursor,
_13
new ValueCallBack<CursorResult<String>>() {
_13
@Override
_13
public void onSuccess(CursorResult<String> value) {
_13
_13
}
_13
@Override
_13
public void onError(int error, String errorMsg) {
_13
}
_13
});

Retrieve a thread list

Users can call getJoinedChatThreadsFromServer to retrieve a paginated list of all the threads they have joined from the server, as shown in the following sample code:


_12
// limit: The maximum number of threads to retrieve per page. The range is [1, 50].
_12
// cursor: The position from which to start getting data. Pass in `null` or an empty string at the first call.
_12
ChatClient.getInstance().chatThreadManager().getJoinedChatThreadsFromServer(limit, cursor,
_12
new ValueCallBack<CursorResult<ChatThread>>() {
_12
@Override
_12
public void onSuccess(CursorResult<ChatThread> value) {
_12
_12
}
_12
@Override
_12
public void onError(int error, String errorMsg) {
_12
}
_12
});

Users can call getJoinedChatThreadsFromServer to retrieve a paginated list of all the threads they have joined in a specified chat group from the server, as shown in the following sample code:


_13
// parentId: The chat group ID.
_13
// limit: The maximum number of threads to retrieve per page. The range is [1, 50].
_13
// cursor: The position from which to start getting data. Pass in `null` or an empty string at the first call.
_13
ChatClient.getInstance().chatThreadManager().getJoinedChatThreadsFromServer(parentId, limit, cursor,
_13
new ValueCallBack<CursorResult<ChatThread>>() {
_13
@Override
_13
public void onSuccess(CursorResult<ChatThread> value) {
_13
_13
}
_13
@Override
_13
public void onError(int error, String errorMsg) {
_13
}
_13
});

Users can also call getChatThreadsFromServer to retrieve a paginated list of all the threads in a specified chat group from the server, as shown in the following sample code:


_13
// parentId: The chat group ID.
_13
// limit: The maximum number of threads to retrieve per page. The range is [1, 50].
_13
// cursor: The position from which to start getting data. Pass in `null` or an empty string at the first call.
_13
ChatClient.getInstance().chatThreadManager().getChatThreadsFromServer(parentId, limit, cursor,
_13
new ValueCallBack<CursorResult<ChatThread>>() {
_13
@Override
_13
public void onSuccess(CursorResult<ChatThread> value) {
_13
_13
}
_13
@Override
_13
public void onError(int error, String errorMsg) {
_13
}
_13
});

Retrieve the latest message from multiple threads

Users can call getChatThreadLatestMessage to retrieve the latest message from multiple threads.

The following sample code shows how to retrieve the latest message from multiple threads:


_11
// chatThreadIdList: The thread IDs. You can pass in a maximum of 20 thread IDs.
_11
ChatClient.getInstance().chatThreadManager().getChatThreadLatestMessage(chatThreadIdList,
_11
new ValueCallBack<Map<String, ChatMessage>>() {
_11
@Override
_11
public void onSuccess(Map<String, ChatMessage> value) {
_11
_11
}
_11
@Override
_11
public void onError(int error, String errorMsg) {
_11
}
_11
});

Listen for thread events

To monitor thread events, users can listen for the callbacks in the ChatThreadManager class and add app logics accordingly. If a user wants to stop listening for the callbacks, make sure that the user removes the listener to prevent memory leakage.

Refer to the following sample code to listen for thread events:


_18
ChatThreadChangeListener chatThreadChangeListener = new ChatThreadChangeListener() {
_18
@Override
_18
// Occurs when a thread is created.
_18
public void onChatThreadCreated(ChatThreadEvent event) {}
_18
@Override
_18
// Occurs when a thread has a new message, a thread name is updated, or a thread message is recalled.
_18
public void onChatThreadUpdated(ChatThreadEvent event) {}
_18
// Occurs when a thread is destroyed.
_18
@Override
_18
public void onChatThreadDestroyed(ChatThreadEvent event) {}
_18
// Occurs when a member is removed from a thread.
_18
@Override
_18
public void onChatThreadUserRemoved(ChatThreadEvent event) {}
_18
};
_18
// Adds the thread listener.
_18
ChatClient.getInstance().chatThreadManager().addChatThreadChangeListener(chatThreadChangeListener);
_18
// Removes the thread listener.
_18
ChatClient.getInstance().chatThreadManager().removeChatThreadChangeListener(chatThreadChangeListener);

Page Content