Overview

CommsEase provides the chat room feature. There is no upper limit for the number of users. Users can freely join and leave a chat room. The creation and closure of a chat room needs to be completed through the server-side API.

A chat room prototype:

Return	ChatRoomInfo interface	Description
String	getAnnouncement()	Get announcement of chat room
String	getBroadcastUrl()	Get live streaming address of chat room
String	getCreator()	Get owner account of chat room
Map	getExtension()	Get the extension field of chat room
String	getName()	Get name of chat room
int	getOnlineUserCount()	Get number of current online users
int	getQueueLevel()	Get configuration of queue level
String	getRoomId()	Get chat room ID
boolean	isMute()	Get mute state of current chat room
boolean	isValid()	Set valid tag of chat room
void	setAnnouncement(String announcement)	Set announcement of chat room
void	setBroadcastUrl(String broadcastUrl)	Set live streaming address of chat room
void	setCreator(String creator)	Set owner of chat room
void	setExtension(Map extension)	Set extension field
void	setMute(int mute)	Set mute state of current chat room
void	setName(String name)	Set name of chat room
void	setOnlineUserCount(int onlineUserCount)	Set number of current online users
void	setRoomId(String roomId)	Set Chat room ID
void	setValidFlag(int validFlag)	Set valid tag of chat room
void	setQueueLevel(int queueLevel)	Set queue level: 0 indicates permission of all members; 1 indicates permission of only streamer/administrator

Joining a chat room

Users must call the interface to join a chat room before sending and receiving messages in a chat room. The chat room allows users to join manually only and cannot send an invitation. Users can join up to 10 chat rooms at the same time.

• Users can join a chat room in independent mode or non-independent mode.
• The independent mode refers to the method for joining a chat room when the IM is not logged in, which applies to the service scenarios that only need the chat room feature.
• The non-independent mode refers to the method for joining a chat room after logging in to the IM, which applies to the service scenarios that need the IM and chat room features.

java/**
 * Enter a chat room
 *
 * @param roomData - Basic data of chat room (Chat room ID is required)
 * @param retryCount - It is the retry count if joining is failed.
 * @return InvocationFuture - Configurable callback feature. The basic information about the chat room is returned in the callback.
 */
AbortableFuture<EnterChatRoomResultData> joinChatRoomEx(EnterChatRoomData roomData, int retryCount);

EnterChatRoomData parameter:

Return	EnterChatRoomData parameter	Description
String	getAccount()	Get user account of independent login mode
String	getAppKey()	Get chat room appKey
String	getAvatar()	Get profile picture shown in a chat room
Map	getExtension()	Get the extension field shown in a chat room
ChatRoomIndependentCallback	getIndependentModeCallback()	Get callback of independent mode
String	getNick()	Get display name shown in a chat room
Map	getNotifyExtension()	Get the extension field of notifying developer in a chat room
String	getRoomId()	Get chat room ID
String	getToken()	Get user password of independent login mode
boolean	isIndependentMode()	Log in a chat room independently
void	setAppKey(String appKey)	Set chat room appKey and enable under independent login mode. If it is not specified, then corresponding appKey of IM is used and corresponding relationship between roomId and appKey needs to be guaranteed.
void	setprofile picture(String profile picture)	Set profile picture shown in a chat room
void	setExtension(Map extension)	Set extension field of showing user profile after joining chat room, with length limit 4k. Users can query this extension field when acquiring ChatRoomMember after settings. In addition, when receiving messages, users can acquire the extension field of a user profile for message sender from ChatRoomMessage#ChatRoomMessageExtension#getSenderExtension. If it is not filled, then the field is null.
void	setIndependentMode(ChatRoomIndependentCallback cb, String account, String token)	Set independent mode of chat room
void	setNick(String nick)	Set display name shown in a chat room (optional field). If it is not filled in, display name in NimUserInfo is used.
void	setNotifyExtension (Map notifyExtension)	Set extension field of a notification message in a chat room, with a length limit of 2k. Users can get this extension field from ChatRoomNotificationAttachment after settings.
void	setRoomId(String roomId)	Set Chat room ID

Non-independent mode

The non-independent mode is simple. When IM is at the login state, users can call the method to join the chat room.

• Example

java// roomId indicates chat room ID
EnterChatRoomData data = new EnterChatRoomData(roomId);
// Take "log in for once without retry" for an example
NIMClient.getService(ChatRoomService.class).joinChatRoomEx(data, 1).setCallback(new RequestCallback<EnterChatRoomResultData>() {
    @Override
    public void onSuccess(EnterChatRoomResultData result) {
        // Login successful
    }

    @Override
    public void onFailed(int code) {
        // Login failed
    }

    @Override
    public void onException(Throwable exception) {
        // Error
    }
});

Independent mode

When selecting to join the chat room by independent mode, users must set the independent mode of chat room through EnterChatRoomData.setIndependentMode(...) method.

• API prototype

java/**
 * Set independent mode of chat room
 *
 * @param cb - If it is the independent mode, the callback feature must be provided to acquire the data of chat room address from app by SDK.
 * @param account - Account of independent login, not required. Void indicates anonymous login.
 * @param token - Password for independent login
 */
public void setIndependentMode(ChatRoomIndependentCallback cb, String account, String token);

• Parameters

Parameter	Description
cb	If it is an independent mode, the callback feature must be provided to acquire the data of chat room address from app by SDK.
account	Account of independent login, not required. Void indicates anonymous login.
token	Password of independent login

• Anonymous mode and non-anonymous mode

The independent mode includes anonymous mode and non-anonymous mode. Users can receive a message and cannot send a message under anonymous mode.

If transfer parameter account of setIndependentMode method is not filled in, then it is an anonymous mode. SDK will log in by an automatically generated anonymous account. Under anonymous mode, users must set display name and profile picture information through SetNick and setprofile picture of EnterChatRoomData.

• Get the chat room address

Because independent mode does not rely on IM connection, SDK cannot get the address of chat room server automatically, and needs to request the address to developer app server from client, while app server needs to request CommsEase server, and then returns request result to the client, with request path Client <-> Developer Application Server <-> CommsEase Server (API: request chat room address).

The callback method of acquiring chat room address through developer app server by SDK must be set using ChatRoomIndependentCallback - getChatRoomLinkAddresses:

java/**
 * Callback feature for independent login mode of the chat room. It is used to provide data to SDK by upper APP.
 */ 
java.util.List<java.lang.String> getChatRoomLinkAddresses(java.lang.String roomId,
                                                          java.lang.String account);

• Example

Example 1: Anonymous login under independent mode

java// roomId - Chat room ID
EnterChatRoomData data = new EnterChatRoomData(roomId);

// Log in a chat room by anonymous mode under independent mode
data.setNick("testNick"); // For this mode, display name is required. Take testNick for an example
data.setprofile picture("profile picture"); // For this mode,profile picture is required. Takeprofile picture for an example
data.setIndependentMode(new ChatRoomIndependentCallback() {
    @Override
    public List<String> getChatRoomLinkAddresses(String roomId, String account) {
        // Request chat room address from app server, instead of SDK interface
        return ChatRoomHttpClient.getInstance().fetchChatRoomAddress(roomId, null);
    }
}, null, null);

NIMClient.getService(ChatRoomService.class).joinChatRoomEx(data, 1).setCallback(new RequestCallback<EnterChatRoomResultData>() {
    @Override
    public void onSuccess(EnterChatRoomResultData result) {

    }

    @Override
    public void onFailed(int code) {

    }

    @Override
    public void onException(Throwable exception) {

    }
});

Example 2: Non-anonymous login under independent mode

java// roomId - Chat room ID
EnterChatRoomData data = new EnterChatRoomData(roomId);

// Non-anonymous login of independent mode. Account and password are required. The account and token are taken for examples.
data.setIndependentMode(new ChatRoomIndependentCallback() {
    @Override
    public List<String> getChatRoomLinkAddresses(String roomId, String account) {
        // Request chat room address from app server, instead of SDK interface
        return ChatRoomHttpClient.getInstance().fetchChatRoomAddress(roomId, "account");
    }
}, "account", "token");

NIMClient.getService(ChatRoomService.class).joinChatRoomEx(data, 1).setCallback(new RequestCallback<EnterChatRoomResultData>() {
    @Override
    public void onSuccess(EnterChatRoomResultData result) {

    }

    @Override
    public void onFailed(int code) {

    }

    @Override
    public void onException(Throwable exception) {

    }
});

Multi-device login to the same chat room

The policy for multi-device login to the same chat room can be set, that is, whether multi-device login with the same account to the same chat room at the same time is allowed. Users can join the CommsEase console to set:

• Login to only one device
• Simultaneous login at all clients.

Listening for connection changes of a chat room

After successfully joining a chat room, SDK will maintain long-lived connection with the server, disconnection, and re-connection. The notification will be sent when an online state of users has any change. The state callback also occurs in the process of login. In addition, SDK will undertake automatic login of chat room after network connection.

• API prototype

java/**
 * Register or cancel observer for online/login status of chat room
 *
 * @param observer - Observer. The parameter is chat room ID and chat room status (not join, connecting, joining, joined).
 * @param register true indicates registered, and true indicates unregistered
 */
public void observeOnlineStatus(Observer<ChatRoomStatusChangeData> observer, boolean register);

• Parameters

ChatRoomStatusChangeData attribute	Description
roomId	Chat room ID
status	Status code (See StatusCode)

In addition, Users can call the SDK interface in a callback of state change observer to acquire the cause of failure in server return and make corresponding processing on the interface.

• API prototype

java/**
 * Get the error code for failing in joining a chat room
 * If it is manual login, an error code can be found in the callback feature of joinChatRoom.
 * If it is disconnected and re-connected again, when automatic login is failed, i.e. the monitored change in online status is UNLOGIN, the detailed reason for failing in automatic login can be viewed using the interface.
 *
 * @param roomId - Chat room ID
 * @return - Error code for disconnection and re-connection of the chat room and failed automatic login.
 */
int getEnterErrorCode(String roomId);

• Parameters

Error code	Description
414	Error parameter
404	No chat room
403	No permissions
500	Server Internal Error
13001	IM main connection status is abnormal
13002	Chat room status is abnormal
13003	Not allow members in Blocklist to join a chat room

• Example

javaNIMClient.getService(ChatRoomServiceObserver.class).observeOnlineStatus(onlineStatus, register);

Observer<ChatRoomStatusChangeData> onlineStatus= new Observer<ChatRoomStatusChangeData>() {
        @Override
        public void onEvent(ChatRoomStatusChangeData data) {
            if (data.status == StatusCode.UNLOGIN) {
                int errorCode = NIMClient.getService(ChatRoomService.class).getEnterErrorCode(roomId));
                // If error codes (13001, 13002, 13003, 403, 404, 414) are returned, it indicates that you cannot join the chat room and must invoke the interface for leaving a chat room.
            }
           ...
        }
};

Listening for kickout events

The kickout event triggers a callback function if a user is kicked out of a chat room or the chat room is closed.

Note: After receiving kickout notification, the user is not required to call the interface of leaving chat room, SDK will undertake the leave from chat room. The user can clear related cache in kickout notification and do interface work.

• API prototype

java/**
 * Register or cancel the observer kicked out of a chat room.
 *
 * @param observer - Observer. The parameter is kick-out event (the removed chat room ID and kick-out reason can be acquired).
 * @param register true indicates registered, and true indicates unregistered
 */
public void observeKickOutEvent(Observer<ChatRoomKickOutEvent> observer, boolean register);

• Parameters

ChatRoomKickOutEvent.ChatRoomKickOutReason attribute

ChatRoomKickOutEvent.ChatRoomKickOutReason attribute	Description
BE_BlocklistED	added to a Blocklist
CHAT_ROOM_INVALID	Invalid chat room
Invalid_STAT	Abnormal status of current connection
KICK_OUT_BY_CONFLICT_LOGIN	Kick out by other clients
KICK_OUT_BY_administrator	Kick out by the administrator
UNKNOWN	Unknown (error)

• Example

javaNIMClient.getService(ChatRoomServiceObserver.class).observeKickOutEvent(kickOutObserver, register);

Observer<ChatRoomKickOutEvent> kickOutObserver = new Observer<ChatRoomKickOutEvent>() {
        @Override
        public void onEvent(ChatRoomKickOutEvent chatRoomKickOutEvent) {
            // Prompt kick-out reason (the chat room is dismissed; the user is kicked out by administrator or kicked out from other clients)
            // Clear cache data
        }
    };

Leaving a chat room

When leaving from a chat room, the user will disconnect from a chat room and will not receive any message from the chat room. If the user wants to leave from a chat room, he can manually call the interface of leaving from the chat room where there is no callback.

###Leaving a chat room

• API prototype

java/**
 * Leave a chat room
 *
 * @param roomId - Chat room ID
 */
void leaveChatRoom(String roomId);

• Example

javaNIMClient.getService(ChatRoomService.class).leaveChatRoom(roomId);

Leave a chat room of a specific type

• API prototype

java/**
 * Leave a chat room
 *
 * @param mode - Chat room type
 */
void leaveChatRooms(ChatRoomModeEnum mode);

• Example

javaNIMClient.getService(ChatRoomService.class).leaveChatRoom(ChatRoomModeEnum.DEPENDENT);

Messaging in a chat room

ChatRoomMessage succeeds from IMMessage. New methods include:

Return	ChatRoomMessage interface	Description
CustomChatRoomMessageConfig	getChatRoomConfig()	Get message configuration of chat room
ChatRoomMessageExtension	getChatRoomMessageExtension()	Get extension attribute of chat room message
boolean	isHighPriorityMessage()	Is it high priority message?
void	setChatRoomConfig (CustomChatRoomMessageConfig config)	Set configuration of chat room message

Sending messages

The user can create a message object using ChatRoomMessageBuilder and then call sendMessage of ChatRoomService to send a message in the chat room.

• ChatRoomMessageBuilder interface

Return	ChatRoomMessageBuilder interface	Description
static ChatRoomMessage	createChatRoomAudioMessage(String roomId, File file, long duration)	Create an audio message
static ChatRoomMessage	createChatRoomAudioMessage(String roomId, File file, long duration, String nosTokenSceneKey)	Create an audio message and specify scenario of file resource
static ChatRoomMessage	createChatRoomCustomMessage(String roomId, MsgAttachment attachment)	Create user-defined scenario
static ChatRoomMessage	createChatRoomCustomMessage(String roomId, MsgAttachment attachment, String nosTokenSceneKey)	Create user-defined message and specify scenario of file resource
static ChatRoomMessage	createChatRoomFileMessage(String roomId, File file, String displayName)	Create a file message
static ChatRoomMessage	createChatRoomFileMessage(String roomId, File file, String displayName, String nosTokenSceneKey)	Create a file message and specify scenario of file resource
static ChatRoomMessage	createChatRoomImageMessage(String roomId, File file, String displayName)	Create an image message
static ChatRoomMessage	createChatRoomImageMessage(String roomId, File file, String displayName, String nosTokenSceneKey)	Create an image message and specify scenario of file resource
static ChatRoomMessage	createChatRoomLocationMessage(String roomId, double lat, double lng, String addr)	Create a geolocation information
static ChatRoomMessage	createChatRoomTextMessage(String roomId, String text)	Create ordinary text message
static ChatRoomMessage	createChatRoomVideoMessage(String roomId, File file, long duration, int width, int height, String displayName)	Create a video message
static ChatRoomMessage	createChatRoomVideoMessage(String roomId, File file, long duration, int width, int height, String displayName, String nosTokenSceneKey)	Create a video message and specify scenario of file resource
static ChatRoomMessage	createEmptyChatRoomMessage(String roomId, long time)	Create an empty message and set room ID and time point only for recording query
static ChatRoomMessage	createTipMessage(String roomId)	Create a tip message

See scenario of file resource for nosTokenSceneKey.

The following is an example of sending text messages. Other types of message sending modes are similar to IM one-to-one chat and team chat.

• API prototype

java/**
 * Create an ordinary text message
 *
 * @param roomId - Chat room ID
 * @param text - Content of text message
 * @return ChatRoomMessage - Generated chat room message object
 */
public static ChatRoomMessage createChatRoomTextMessage(String roomId, String text);

/**
 * Send a message
 *
 * @param msg - Message body to be sent, constituted by {@link ChatRoomMessageBuilder}.
 * @param resend - If a message is sent unsuccessfully and then re-sent, it is marked as "true". Otherwise, as "false".
 * @return InvocationFuture - Configurable callback feature. It can be invoked only when the message is sent. If an error occurs, a detailed error code will be returned.
 */
InvocationFuture<Void> sendMessage(ChatRoomMessage msg, boolean resend);

• Example

java// roomId used for example
String roomId = "50";
// Content of text message
String text = "This is text message of chat room";
// Create chat room text message
ChatRoomMessage message = ChatRoomMessageBuilder.createChatRoomTextMessage(roomId, text);
// Send text message
NIMClient.getService(ChatRoomService.class).sendMessage(message, false)
       .setCallback(new RequestCallback<Void>() {
            @Override
            public void onSuccess(Void param) {
	            // Successful
            }

            @Override
            public void onFailed(int code) {
                // Failed
            }

            @Override
            public void onException(Throwable exception) {
               // Error
            }
        });

• Special error code

Error code	Description
13004	DisableSendMsg (mute)
13006	Chat room is mute and only the administrator can send the message.

Configuration options of sending messages

When sending a chat room message, the user can set the configuration option CustomChatRoomMessageConfig for setting to store on cloud history.

CustomChatRoomMessageConfig attribute	Description
skipHistory	Will the message be saved to a server? If it is true, the results pulled down using ChatRoomService#pullMessageHistory will not include the message. It is "false" by default.

• Example

java// roomId used for example
String roomId = "50";
// Content of text message
String text = "This is text message of chat room";
// Create chat room text message
ChatRoomMessage message = ChatRoomMessageBuilder.createChatRoomTextMessage(roomId, text);
// Configure not to store message history
CustomChatRoomMessageConfig config = new CustomChatRoomMessageConfig();
config.skipHistory = true;
message.setChatRoomConfig(config);
// Send Chat room message
NIMClient.getService(ChatRoomService.class).sendMessage(message, false);

Receiving messages

By adding a message observer, the user can receive a message when the message is sent.

• API prototype

java/**
 * Register or cancel the observer for receiving messages.
 *
 * @param observer - Observer. The parameter is the set of received messages.
 * @param register true indicates registered, and true indicates unregistered
 */
public void observeReceiveMessage(Observer<List<ChatRoomMessage>> observer, boolean register);

• Example

javaObserver<List<ChatRoomMessage>> incomingChatRoomMsg = new Observer<List<ChatRoomMessage>>() {
        @Override
        public void onEvent(List<ChatRoomMessage> messages) {
            // Handle received new message
        }
    };
NIMClient.getService(ChatRoomServiceObserver.class).observeReceiveMessage(incomingChatRoomMsg, register);

• Please download attachment by downloadAttachment method of ChatRoomService.
• Please use observeMsgStatus(Observer<ChatRoomMessage> observer, boolean register) of ChatRoomServiceObserver to register/log out message state observer.
• Please use observeAttachmentProgress(Observer<AttachmentProgress> observer, boolean register) of ChatRoomServiceObserver to register/log out the attachment uploading/downloading progress observer.

Notifications

Some operations in a chat room will generate chat room notifications. The notification will be generated if:

Type	Description
ChatRoomClose	Chat room is closed.
ChatRoomCommonAdd	Chat room member is set as a fixed member.
ChatRoomCommonRemove	Fixed member in a chat room is canceled.
ChatRoomInfoUpdated	Chat room information is updated.
ChatRoomadministratorAdd	A member is set as an administrator
ChatRoomadministratorRemove	Chat room administrator is removed.
ChatRoomMemberBlackAdd	Chat room member is added to the Blocklist.
ChatRoomMemberBlackRemove	Chat room member is removed from the Blocklist.
ChatRoomMemberExit	Member leaves the chat room
ChatRoomMemberIn	Member joins the chat room
ChatRoomMemberKicked	Member is kicked out.
ChatRoomMemberMuteAdd	Member is added to mute
ChatRoomMemberTempMuteAdd	Chat room member is added to temporary mute.
ChatRoomMemberTempMuteRemove	Chat room member is removed from temporary mute actively.
ChatRoomMyRoomRoleUpdated	Chat room member actively updates role information in a chat room (only nick/avator/ext).
ChatRoomQueueBatchChange	Queue is changed in batch.
ChatRoomQueueChange	Quene has change.
ChatRoomRoomDeMuted	: Chat room members are unmuted.
ChatRoomRoomMuted	: The chat room is muted, only the administrator can send a message, and others are muted.

In particular, the issuance of notifications of members joining and leaving the chat room can be set:

• Application level: CommsEase console > Select app > Issue message system of notifications users joining and leaving from chat room > Enable/disable.
• A one-to-one chat room: Call server API "notification of disabling entry and leave from specified chat room".
• If you want to exclude the chat room user entry and leave messages when querying the message history of a chat room, please contact a business consultant to apply for disabling the "storage of chat room user entry and leave message history".

All chat room messages are packaged in the form of ChatRoomMessage. Analysis for chat room notification:

Analysis steps for chat room notification:

• Get message type using ChatRoomMessage.getMsgType(). If the type is MsgTypeEnum.notification, then it is chat room notification message.
• Transform strong type of attachment object acquired using ChatRoomMessage.getAttachment() into NotificationAttachment.
• Get detailed NotificationType using NotificationAttachment.getType().
• Transform strong type of attachment acquired using ChatRoomMessage.getAttachment() into corresponding attachment type (ChatRoomNotificationAttachment or sub-type).

ChatRoomNotificationAttachment parameter:

Method	Description
getExtension()	Get the extension field of chat room notification
getOperator()	Get account of the operator
getOperatorNick()	Get display name of the operator
getTargets()	Get account list of the targets
getTargetNicks()	Get display name list of the targets

Example:

javapublic static String getNotificationText(ChatRoomNotificationAttachment attachment) {
        if (attachment == null) {
            return "";
        }
        String targets = getTargetNicks(attachment);
        String text;
        switch (attachment.getType()) {
            case ChatRoomMemberIn:
                text = buildText("Welcome", targets, "Enter a chat room");
                break;
            case ChatRoomMemberExit:
                text = buildText(targets, "Left a chat room");
                break;
            case ChatRoomMemberBlackAdd:
                text = buildText(targets, "Be added to a Blocklist by administrator");
                break;
            case ChatRoomMemberBlackRemove:
                text = buildText(targets, "Be removed from Blocklist by administrator");
                break;
            case ChatRoomMemberMuteAdd:
                text = buildText(targets, "Be muted by administrator");
                break;
            case ChatRoomMemberMuteRemove:
                text = buildText(targets, "Be unmuted by administrator");
                break;
            case ChatRoomadministratorAdd:
                text = buildText(targets, "Appointed as administrator");
                break;
            case ChatRoomadministratorRemove:
                text = buildText(targets, "De-appointed as administrator");
                break;
            case ChatRoomCommonAdd:
                text = buildText(targets, "Be set as an ordinary member");
                break;
            case ChatRoomCommonRemove:
                text = buildText(targets, "Be canceled as an ordinary member ");
                break;
            case ChatRoomClose:
                text = buildText("The chat room is closed");
                break;
            case ChatRoomInfoUpdated:
                text = buildText("The chat room information is updated");
                break;
            case ChatRoomMemberKicked:
                text = buildText(targets, "Be kicked out of a chat room");
                break;
            case ChatRoomMemberTempMuteAdd:
                text = buildText(targets, "Be muted temporarily");
                break;
            case ChatRoomMemberTempMuteRemove:
                text = buildText(targets, "Temporary mute is canceled");
                break;
            case ChatRoomMyRoomRoleUpdated:
                text = buildText(targets, "Updated your role information");
                break;
            case ChatRoomQueueChange:
                text = buildText(targets, "Change in queue");
                break;
            case ChatRoomRoomMuted:
                text = buildText("All members are muted, but the administrator can send messages");
                break;
            case ChatRoomRoomDeMuted:
                text = buildText("All members are unmuted");
                break;
            case ChatRoomQueueBatchChange:
                text = buildText("Change at a time");
                break;
            default:
                text = attachment.toString();
                break;
        }
        return text;
    }

Querying message history on cloud

There are no offline messages and roaming messages in the chat room. The chat room message history can be queried through the following interface. The server only keeps the chat room message history records of the last 10 days. But URL addresses of files (for example, image, audio, video) sent 10 days before are still valid (But developers must save these addresses, because they cannot be queried through expired message.) For extending "duration of chat room message history", please contact the commercial consultant.

Querying message history on cloud

Starting from startTime (unit: ms), you can select query direction (forward or backward) to pull down a limited number of messages. The pull-down messages also include chat room notifications.

The ranking of query results is related to query direction. If the direction is forward, then results are ranked by time in reversed order. Otherwise, by time in order.

java/**
 * Get message history. The given time can be selected to query forward or backward. If the direction is forward, then results are ranked by time in reversed order. Otherwise, by time in order.
 *
 * @return InvocationFuture - Configurable callback feature. The list of message history will be returned in the callback.
 */
InvocationFuture<List<ChatRoomMessage>> pullMessageHistoryEx(String roomId, long startTime, int limit, QueryDirectionEnum direction);

• Parameters

Parameter	Description
roomId	Chat room ID
startTime	Timestamp, unit: ms
limit	Number of pull-down messages, max. 100
direction	Query direction

QueryDirectionEnum attribute

QueryDirectionEnum attribute	Description
QUERY_OLD	Query message earlier than anchor time
QUERY_NEW	Query message later than anchor time

• Example

javalong startTime = System.currentTimeMillis();
// From on, 100 messages are queried toward QueryDirectionEnum.QUERY_OLD.
NIMClient.getService(ChatRoomService.class).pullMessageHistoryEx(roomId, startTime, 100, QueryDirectionEnum.QUERY_OLD);

Querying messages by type

With startTime (unit: ms) as timestamp, you can select query direction (forward or backward) and specify one or more types of message to pull down a limited number of messages.

• API prototype

java/**
 * Get message history. The given time can be selected to query forward or backward, and one or multiple specified messages can be queried.
 *
 * If the direction is forward, then results are ranked by time in reversed order. Otherwise, by time in order.
 *
 * Available message types: 0: Text; 1: Image; 2. Audio file; 3. Video; 4. Geographical location; 5. Notification; 6. File; 10: Prompt; 11: Robot; 100: Custom. Others are Invalid parameters.
 *
 * @param roomId - Chat room ID
 * @param startTime - Timestamp, unit: ms
 * @param limit - Number of available messages
 * @param direction query direction
 * @param typeEnums - Message type, array
 * @return InvocationFuture - Configurable callback feature. The list of message history will be returned in callback.
 */
InvocationFuture<List<ChatRoomMessage>> pullMessageHistoryExType(String roomId, long startTime, int limit, QueryDirectionEnum direction, MsgTypeEnum[] typeEnums);

• Parameters

Parameter	Description
roomId	Chat room ID
startTime	timestamp, unit: ms
limit	Number of pull-down messages
direction	Query direction
typeEnums	Query message type, array

• Example

javaMsgTypeEnum[] typeEnums = new MsgTypeEnum[]{MsgTypeEnum.text, MsgTypeEnum.image};
int[] types = new int[]{MsgTypeEnum.text.getValue(), MsgTypeEnum.image.getValue()};
long anchorTime = System.currentTimeMillis();

checkResponse(NIMClient.getService(ChatRoomService.class).pullMessageHistoryExType(Constants.CHATROOM_ID, anchorTime, 50, QueryDirectionEnum.QUERY_OLD, typeEnums), new TestRequestResult.Callback<List<ChatRoomMessage>>() {
    @Override
    public boolean onResponseData(int code, List<ChatRoomMessage> data) {
       ...
    }
});

Chat room information management

Get the profile of a chat room

You can get chat room information from the server using this interface. SDK does not provide cache of chat room information, so that developers must make caches as required. The extension field of basic chat room information must be set at the server and client SDK only provides query service.

• API prototype

java/**
 * Get information about current chat room
 *
 * @param roomId - Chat room ID
 * @return InvocationFuture - Configurable callback feature. The information about the chat room is returned in the callback.
 */
InvocationFuture<ChatRoomInfo> fetchRoomInfo(String roomId);

• Example

java// roomId - Chat room ID
NIMClient.getService(ChatRoomService.class).fetchRoomInfo(roomId).setCallback(new RequestCallback<ChatRoomInfo>() {
    @Override
    public void onSuccess(ChatRoomInfo param) {
        // Successful
    }

    @Override
    public void onFailed(int code) {
        // Failed
    }

    @Override
    public void onException(Throwable exception) {
        // Error
    }
});

Editing the chat room profile

It supports updating chat room information. Only the owner and administrator can change chat room information. You can set that update is notified. If it is set to send a notification, you can receive NotificationType#ChatRoomInfoUpdated type message in a chat room.

• API prototype

java/**
 * Update chat room information
 *
 * @param roomId - Chat room ID
 * @param chatRoomUpdateInfo - Updatable chat room information
 * @param needNotify - It determines to send notification.
 * @param notifyExtension - Update extension field of chat room information related operation. This field will be covered in the extension field for updating chat room information.
 * @return InvocationFuture - Configurable callback feature. It can be invoked only after only when chat room information is updated. If an error occurs, a detailed error code will be returned.
 */
InvocationFuture<Void> updateRoomInfo(String roomId, ChatRoomUpdateInfo chatRoomUpdateInfo, boolean needNotify, Map<String, Object> notifyExtension);

• Parameters

Parameter	Description
roomId	Chat room ID
chatRoomUpdateInfo	Updatable chat room information
needNotify	Is it need to notify?
notifyExtension	Update extension field of chat room information. This field will be covered in the extension field of notification for updating chat room information.
queueLevel	Queue level: 0 indicates permission of all members; 1 indicates permission of only streamer/administrator.

• Example

java// Take "Update chat room information" for an example
ChatRoomUpdateInfo updateInfo = new ChatRoomUpdateInfo();
updateInfo.setName("New chat room name");

NIMClient.getService(ChatRoomService.class).updateRoomInfo(roomId, updateInfo, false, "")
        .setCallback(new RequestCallback<Void>() {
            @Override
            public void onSuccess(Void aVoid) {
                // Successful
            }

            @Override
            public void onFailed(int i) {
                // Failed
            }

            @Override
            public void onException(Throwable throwable) {
				// Error
            }
        });

Chat room member management

Chat room members

About chat room members:

• Chat room members include fixed members and non-fixed members (temporary member/visitor). The limit of fixed members is 1000.
• The fixed members include creator, the administrator, ordinary member, and limited user. Except for the creator, other members are considered as visitors by default when adding the team.
• Except for the creator, other members are considered as visitors by default when adding the team.
• The visitor who was set as an administrator will become a normal user (not a visitor) after his administration privileges are removed.
• An administrator will become a normal user after his/her administration permissions are removed. The administrator cannot be set as an ordinary member.
• Only the owner can perform operations on an administrator, and an administrator cannot perform operations on the owner and other administrators.
• A normal user will become a visitor after his/her identity is removed.
• A visitor will become a permanent member after he/she is Blocklisted (at the same time, the visitor will be disconnected from the server and cannot join the chat room unless he/she is removed from the Blocklist). The user will become a visitor after being removed from the Blocklist.
• The user will become a fixed member after being muted permanently. The user will become a visitor after disabling the permanent mute. The expiry of temporary mute will not be influenced after disabling permanent mute.
• The setting and relieving of temporary muting will not change the identity of a member. If temporary mute is set repeatedly, the final expiry will cover the previous setting (without accumulation).
• The visitor is an non-fixed member in the chat room only when being online. The visitor will not be any member of the chat room if he joins and then leaves the chat room (without any relation with the chat room).

Chat room member prototype:

Return	ChatRoomMember interface	Description
String	getAccount()	Get member account
String	getAvatar()	Get profile picture It is possible to getAvatar from NimUserInfo, which can be submitted by the user in a chat room.
long	getEnterTime()	Get the time of joining chat room The field is void for offline members.
Map	getExtension()	Get the extension field The length limit is 4k, which can be submitted by users in a chat room.
int	getMemberLevel()	Get member level ≥0 indicates user-defined level by developers and user.
MemberType	getMemberType()	Get member type Member type: Mainly including tourist and non-tourist.
String	getNick()	Get display name It is possible to get display name from NimUserInfo, which can be submitted by the user in a chat room.
String	getRoomId()	Get chat room ID
long	getTempMuteDuration()	Get duration of disabling temporary mute, unit: second
long	getUpdateTime()	Get records updating time of fixed member for ranking and querying the list of fixed members
boolean	isInBlocklist()	Determine that the user is in Blocklist
boolean	isMuted()	Determine that the user is muted
boolean	isOnline()	Determine that the user is online. Only special members may be offline and the state of visitor or anonymous user is online definitely.
boolean	isTempMuted()	Determine that the user is muted temporarily
boolean	isValid()	Determine that it is valid
void	setAccount(String account)	Set user account
void	setprofile picture(String profile picture)	Set member profile picture
void	setEnterTime(long joinTime)	Set the time of joining chat Room
void	setExtension(Map extension)	Set extension field
void	setInBlocklist(boolean inBlocklist)	Set that the user is in Blocklist
void	setMemberLevel(int memberLevel)	Set member level
void	setMemberType(MemberType type)	Set member type
void	setMuted(boolean muted)	Set mute
void	setNick(String nick)	Set member profile name
void	setOnline(boolean online)	Set online state
void	setRoomId(String roomId)	Set Chat room ID
void	setTempMuted(boolean tempMuted)	Set temporary mute
void	setTempMuteDuration(long tempMuteDuration)	Set duration of temporary mute
void	setUpdateTime(long updateTime)	Set update time of fixed member
void	setValid(boolean valid)	Set that it is valid

MemberQueryType schema:

Parameter	Description
GUEST	Non-fixed member (also temporary member. They can be found in the list only when being online. The number is unlimited.)
NORMAL	Fixed member (including creator, the administrator, ordinary member, limited user (mute + Blocklist) They can be found in the list even though they are not online. The number is limited.)
ONLINE_NORMAL	Only online fixed member
GUEST_DESC	Non-fixed member (also temporary member. They can be found in the list only when being online. The number is unlimited.) They are ranked by the time of joining chat room in inverted order. The later the time is, the more forward the ranking will be.
GUEST_ASC	Non-fixed member (also temporary member. They can be found in the list when being online. The number is unlimited.) They are ranked by the time of joining chat room in order. The earlier the time is, the more forward the ranking will be.
UNKNOWN	Unknown

Getting chat room members

Getting chat room members by page

The list of chat room members can be acquired using this interface, SDK will not cache the list of chat room members, and developers need to make cache based on services independently.

• API prototype

java/**
 * Get information about chat room members
 *
 * @param roomId - Chat room ID
 * @param memberQueryType - Member query type
 * @param time - updateTime for the list of permanent members
 * joinTime for the list of guests
 * If the value is 0, the query starts with the latest server time, i.e. the first page, unit: ms.
 * @param limit - Member limit
 * @return InvocationFuture - Configurable callback feature. The list of member profile will be returned in a callback.
 */
InvocationFuture<List<ChatRoomMember>> fetchRoomMembers(String roomId, MemberQueryType memberQueryType, long time, int limit);

• Parameters

Parameter	Description
roomId	Chat room ID
memberQueryType	Member query type See MemberQueryType
time	The list of fixed members is used with updateTime and the list of visitors is used with joinTime. 0 is filled in to start query with current server time, i.e. the first page, unit: ms.
limit	Member limit

• Example

java// Take a guest for an example, start from the latest time to query 10 pieces
NIMClient.getService(ChatRoomService.class).fetchRoomMembers(roomId, MemberQueryType.GUEST, 0, 10).setCallback(new RequestCallbackWrapper<List<ChatRoomMember>>() {
    @Override
    public void onResult(int code, List<ChatRoomMember> result, Throwable exception) {
      ...
    }
});

Getting the specified chat room members

java/**
 * Get information about chat room members by user ID
 *
 * @param roomId - Chat room ID
 * @param accounts - List of member accounts
 * @return InvocationFuture - Configurable callback feature. The list of member profile will be returned in a callback.
 */
InvocationFuture<List<ChatRoomMember>> fetchRoomMembersByIds(String roomId, List<String> accounts)

• Example

javaList<String> accounts = new ArrayList<>();
accounts.add(account);

NIMClient.getService(ChatRoomService.class).fetchRoomMembersByIds(roomId, accounts)
	    .setCallback(new RequestCallbackWrapper<List<ChatRoomMember>>() {... });

Get the list of chatbots

The robot list cannot be synchronized due to non-existence of IM connection under independent mode of chat room, so that this interface must be called to pull down the robot list. We recommend to call this interface after joining the chat room and take frequency-control measures to prevent high frequency of the interface when the user switches chat room frequently.

• API prototype

java/**
 * Get all current chatbots in independent chat room scene
 *
 * @param roomId - Current chat room ID
 * @return InvocationFuture - Configurable callback feature. The detailed error codes for successful or failed operations will be returned in callback.
 */
InvocationFuture<List<NimRobotInfo>> pullAllRobots(String roomId);

• Example

java
/**
 * Get the shortest interval 5min for robot information
 */
private static final long MIN_PULL_ROBOT_INTERNAL = 5 * 60 * 1000;

private long lastTime = 0L;

/**
 * It can be invoked when you join a chat room under independent mode.
 *
 * The shortest time interval MIN_PULL_ROBOT_INTERNAL
 * @param roomId
 */
public void pullRobotListIndependent(String roomId) {
    if (System.currentTimeMillis() - lastTime < MIN_PULL_ROBOT_INTERNAL) {
        return;
    }

    NIMClient.getService(ChatRoomService.class).pullAllRobots(roomId).setCallback(new RequestCallbackWrapper<List<NimRobotInfo>>() {
        @Override
        public void onResult(int code, List<NimRobotInfo> result, Throwable exception) {
            if (code == 200 && result != null) {
                lastTime = System.currentTimeMillis();
                // Update cache
            }
        }
    });
}

Editing the user profile

You can update member profile in a chat room. Only profile name, profile picture, and extension field can be updated now. You can set that update is notified. If it is set to send a notification, you can receive NotificationType#ChatRoomMyRoomRoleUpdated type message in a chat room.

java/**
 * Update my information in a chat room
 *
 * @param roomId - Chat room ID
 * @param chatRoomMemberUpdate - My updatable role information
 * @param needNotify - It determines to send notification.
 * @param notifyExtension - Update extension field of operation. This field will be covered in the extension field of notification for updating chat room information.
 * @return InvocationFuture - Configurable callback feature. It can be invoked only after only when information is updated. If an error occurs, detailed error code will be returned.
 */
InvocationFuture<Void> updateMyRoomRole(String roomId, ChatRoomMemberUpdate chatRoomMemberUpdate, boolean needNotify, Map<String, Object> notifyExtension);

• Parameters

Parameter	Description
roomId	Chat room ID
chatRoomMemberUpdate	Updatable role information about member
needNotify	Is it need to notify?
notifyExtension	Update extension field of operation. This field will be covered in the extension field of notification for updating chat room information.

ChatRoomMemberUpdate interface

Return	ChatRoomMemberUpdate interface	Description
String	getAvatar()	Get profile picture shown in a chat room
Map	getExtension()	Get the extension field
String	getNick()	Get display name shown in a chat room
boolean	isNeedSave()	Determine that updated information is persisted. It is valid only for fixed members. It is "false" by default. V3.8.0 adds this feature.
void	setprofile picture(String profile picture)	Set profile picture shown in a chat room
void	setExtension(Map extension)	Set extension field, length limit 2048
void	setNeedSave(boolean needSave)	Determine that it is persisted. It is valid only for fixed members. V3.8.0 adds this feature.
void	setNick(String nick)	Set display name shown in a chat room

• Example

java// Take "Update my profile name" for an example
ChatRoomMemberUpdate update = new ChatRoomMemberUpdate();
update.setNick("My new profile name");

NIMClient.getService(ChatRoomService.class).updateMyRoomRole(roomId, update, false, "").setCallback(new RequestCallback<Void>() {
    @Override
    public void onSuccess(Void param) {
        // Successful
    }

    @Override
    public void onFailed(int code) {
        // Failed
    }

    @Override
    public void onException(Throwable exception) {
		// Error
    }
});

Adding or removing an administrator

java/**
 * Set or cancel chat room administrator
 *
 * @param isAdd - "true" indicates to set chat room administrator, and "false" indicates to cancel chat room administrator.
 * @param memberOption - Request parameter, including chat room ID, account ID, and optional extension field.
 * @return InvocationFuture - Configurable callback feature. The member profile will be returned in a callback.
 */
InvocationFuture<ChatRoomMember> markChatRoomadministrator(boolean isAdd, MemberOption memberOption);

• Parameters

Return	MemberOption interface	Description
String	getAccount()	Get member account
Map	getNotifyExtension()	Get the extension field defined by developersin notification event
String	getRoomId()	Get chat room ID
void	setAccount(String account)	Set member account
void	setNotifyExtension(Map notifyExtension)	Set extension field in notification event
void	setRoomId(String roomId)	Set chat room ID

• Example

java// Take "Set as administrator" for an example
NIMClient.getService(ChatRoomService.class)
       .markChatRoomadministrator(true, new MemberOption(roomId, account))
       .setCallback(new RequestCallback<ChatRoomMember>() {
            @Override
            public void onSuccess(ChatRoomMember param) {
                // Successful
            }

            @Override
            public void onFailed(int code) {
                // Failed

            @Override
            public void onException(Throwable exception) {
				// Error
            }
        });

Adding or removing ordinary members

java/**
 * Set or cancel normal chat room members.
 *
 * @param isAdd - "true" indicates to set chat room administrator, and "false" indicates to cancel chat room administrator.
 * @param memberOption - Request parameter, including chat room ID, account ID, and optional extension field.
 * @return InvocationFuture - Configurable callback feature. The member profile will be returned in a callback.
 */
InvocationFuture<ChatRoomMember> markNormalMember(boolean isAdd, MemberOption memberOption);

• Example

java// Take "Set ordinary members" for an example
NIMClient.getService(ChatRoomService.class).markNormalMember(true, new MemberOption(roomId, account)))
       .setCallback(new RequestCallback<ChatRoomMember>() {
            @Override
            public void onSuccess(ChatRoomMember param) {
               // Successful
            }

            @Override
            public void onFailed(int code) {
				// Failed
            }

            @Override
            public void onException(Throwable exception) {
				// Error
            }
        });

Adding or removing a member in a blocklist

java/**
 * Add a member to a blocklist.
 *
 * @param isAdd - "true" is to add, and "false" is to remove.
 * @param memberOption - Request parameter, including chat room ID, account ID, and optional extension field.
 * @return InvocationFuture - Configurable callback feature. The member profile will be returned in a callback.
 */
InvocationFuture<ChatRoomMember> markChatRoomBlocklist(boolean isAdd, MemberOption memberOption);

• Example

java// Take "Add to the blocklist" for an example
MemberOption option = new MemberOption(roomId, account);
NIMClient.getService(ChatRoomService.class).markChatRoomBlocklist(true, option).setCallback(new RequestCallback<ChatRoomMember>() {
        @Override
        public void onSuccess(ChatRoomMember param) {
        // Successful
        }

        @Override
        public void onFailed(int code) {
        // Failed
        }

        @Override
        public void onException(Throwable exception) {
		// Error
        }
});

Muting or unmuting members

When being added to the mute list, the user will receive ChatRoomMemberMuteAdd type chat room notification.

When being removed from the mute list, the user will receive ChatRoomMemberMuteRemove type chat room notification.

java/**
 * Add to mute list or cancel mute.
 *
 * @param isAdd - "true" is to add, and "false" is to cancel.
 * @param memberOption - Request parameter, including chat room ID, account ID, and optional extension field.
 * @return InvocationFuture - Configurable callback feature. The member profile will be returned in a callback.
 */
InvocationFuture<ChatRoomMember> markChatRoomMutedList(boolean isAdd, MemberOption memberOption);

• Example

java// Take "Add to mute list" as an example.
MemberOption option = new MemberOption(roomId, account);
NIMClient.getService(ChatRoomService.class).markChatRoomMutedList(true, option)
        .setCallback(new RequestCallback<ChatRoomMember>() {
            @Override
            public void onSuccess(ChatRoomMember param) {
                // Successful
            }

            @Override
            public void onFailed(int code) {
                // Failed
            }

            @Override
            public void onException(Throwable exception) {
				// Error
            }
        });

Kicking members

Only administrators can kick out team members. Only the team owner can kick out an administrator.

If a member is kicked out of the chat room, the member will receive a notification of ChatRoomMemberKicked type.

The extension field of kickout notification can be added. This field will be covered in the extension field of kickout notification. The max. length of extension field of notification is 1K. "Map<String,Object>" must be specified for extension field, and SDK will transform it into Json String.

java/**
 * Kick out special members.
 *
 * @return InvocationFuture - Configurable callback feature. It can be invoked only when members are kicked out. If an error occurs, detailed error code will be returned.
 */
InvocationFuture<Void> kickMember(String roomId, String account, Map<String, Object> notifyExtension);

• Parameters

Parameter	Description
roomId	Chat room ID
account	Kick out member account Only administrator can kick out team members. If the target is administrator, only the owner can kick him out.
notifyExtension	Extension field of kickout notification. This field will be covered in the extension field of kickout notification.

• Example

javaMap<String, Object> reason = new HashMap<>();
reason.put("reason", "kick");
NIMClient.getService(ChatRoomService.class).kickMember(roomId, account, reason).setCallback(new RequestCallback<Void>() {... });

Temporarily muting members

When being added to the temporary mute list, the user will receive ChatRoomMemberTempMuteAdd type chat room notification.

When being removed from the temporary mute list, the user will receive ChatRoomMemberTempMuteRemove type chat room notification.

Chat room supports to set temporary mute. The mute state will be canceled when it is expired. The duration in notification message after successfully setting temporary mute is remaining time of mute. If the mute duration is set to 0, it indicates to cancel temporary mute. If the first mute duration has not ended and the second temporary mute is set, then the time is counted by the second settings.

java/**
 * Set temporary mute for chat room members
 *
 * @return InvocationFuture - Configurable callback feature. If an error occurs, detailed error code will be returned.
 */
InvocationFuture<Void> markChatRoomTempMute(boolean needNotify, long duration, MemberOption memberOption);

• Parameters

Parameter	Description
needNotify	Is it need to send broadcasting notification. True: Yes; false: No.
duration	Mute duration, unit: second
memberOption	Request parameters, including chat room ID, account ID, and optional extension field.

• Example

java// Take "Send broadcast notification and set temporary mute for 10s" for an example
MemberOption option = new MemberOption(roomId, account);
NIMClient.getService(ChatRoomService.class).markChatRoomTempMute(true, 10, option)
       .setCallback(new RequestCallback<Void>() {
            @Override
            public void onSuccess(Void param) {
                // Successful
            }

            @Override
            public void onFailed(int code) {
                // Failed
            }

            @Override
            public void onException(Throwable exception) {
				// Error
            }
        });

Chat room queue

The chat room provides the queue service, which can be used in conjunction with the speaking queue management in the interactive live streaming scenario. The level is determined by ChatRoomInfo.getQueueLevel() and can be updated using updateChat roomInfo interface. By default, all users can call the interface to update the queue content.

Getting the chat room queue

java/**
 * Chat room queue service: Sort and list all queue elements.
 *
 * @param roomId - Chat room ID.
 * @return InvocationFuture - Configurable callback feature. All sorted key-value pairs of queue elements will be returned in a callback.
 */
InvocationFuture<List<Entry<String, String>>> fetchQueue(String roomId);

• Example

javaNIMClient.getService(ChatRoomService.class).fetchQueue(roomId).setCallback(new RequestCallback<List<Entry<String, String>>>() {
    @Override
    public void onSuccess(List<Entry<String, String>> param) {
        // Successful
    }

    @Override
    public void onFailed(int code) {
        // Failure
    }

    @Override
    public void onException(Throwable exception) {
		// Error
    }
});

Adding or updating queue elements

For the element added or updated using the interface by the user, if "isTransient" parameter is "true", it indicates the server will automatically delete the element added or updated by the user when the user is offline or leaves the chat room.

Besides, the server will send chat room notifications. The notification message type is NotificationType#ChatRoomQueueBatchChange and its attachment type is ChatRoomPartClearAttachment. It is a queue change notification, so that attachment type includes queue change type ChatRoomQueueChangeType#PARTCLEAR.

java/**
 * Chat room queue service: Add or update queue elements. It determines to delete the element when a user is offline or leaves a chat room.
 * @param roomId - Chat room ID.
 * @param key - Unique key of a new element (or element to be updated).
 * @param value - Content of a new element (element to be updated).
 * @param isTransient - (Optional parameter. If the value is null, it will be false by default). "true" indicates that this element must be deleted when the user who submits this new element is offline or leaves chat room. Default "false" value indicates not to delete.
 * @return InvocationFuture - Configurable callback feature. The detailed error codes for successful or failed operations will be returned in callback.
 */
InvocationFuture<Void> updateQueueEx(String roomId, String key, String value, boolean isTransient);

• Parameters

Parameter	Description
roomId	Chat room ID.
key	Unique key of a new element (or element to be updated).
value	Content of a new element (element to be updated).
isTransient	(Optional parameter) "true" indicates that this element must be deleted when the user who submits this new element is offline or leaves chat room. Default "false" value indicates not to delete.

ChatRoomPartClearAttachment

Return	ChatRoomPartClearAttachment interface	Description
ChatRoomQueueChangeType	getChatRoomQueueChangeType()	Returned queue change type, with value ChatRoomQueueChangeType.PARTCLEAR
Map	getContentMap()	Added or updated element when the user is offline or leaves chat room, and the returned user uses "updateQueueEx" interface and sets "isTransient" parameter is "true".

• Example

javaNIMClient.getService(ChatRoomService.class)
        .updateQueueEx(roomId, "this is key", "this is value", true)
        .setCallback(new RequestCallback<Void>() {
            @Override
            public void onSuccess(Void param) {
                // Successful
            }

            @Override
            public void onFailed(int code) {
                // Failed
            }

            @Override
            public void onException(Throwable exception) {
				// Error
            }
        });

Updating multiple queue elements at a time

Only the existing key is updated and new element will not be added.

java/**
 * Update multiple queue elements at a time
 *
 * @param roomId - Chat room ID.
 * @param queues - Queue elements to be updated.
 * @param needNotify - It determines that broadcast notification must be sent.
 * @param notifyExt - Custom field in notification, with max. length 2k.
 * @return - Unavailable elementKey list.
 */
InvocationFuture<List<String>> batchUpdateQueue(String roomId, List<Entry<String, String>> queues, boolean needNotify, Map<String, Object> notifyExt);

• Example

javaList<Entry<String, String>> queues = new ArrayList<>();
        queues.add(new Entry<String, String>("key", "value1"));
        queues.add(new Entry<String, String>("key1", "value2"));
        queues.add(new Entry<String, String>("key2", "value3" ));

        Map<String, Object> notifyExt = new HashMap<>();
        notifyExt.put("notes", "notes_vaules");
        NIMClient.getService(ChatRoomService.class).batchUpdateQueue(roomId, queues, true, notifyExt).setCallback(new RequestCallback<List<String>>() {
            @Override
            public void onSuccess(List<String> result) {
               // Successful
               //result : Unavailable key list.
            }

            @Override
            public void onFailed(int code) {
               //Failure
            }

            @Override
            public vo