Read receipts

Overview

Message reading receipt helps users know whether other users have read the messages they sent in a session. This feature applies to enterprise office businesses and other scenarios in which the message reading status needs to be known in real time.

This document describes how to use APIs of the In-app Chat SDK to send messages that require a reading receipt, query the receipt status of messages, and set messages as read.

Warning

The In-app Chat SDK supports reading receipts for one-to-one messages and group messages (only common messages and rich media messages) and does not support reading receipts for in-room messages.

Implementation process

The sender sends a message through the In-app Chat SDK and sets the hasReceipt field of ZIMMessageSendConfig to identify whether a reading receipt is required for the message. Based on the receiptStatus field, the receiver determines whether a reading receipt is required for the message or whether the message is read or unread to render different UI effects. The message receiver can use different reading methods based on the scenario.

Send a message that requires a reading receipt

When Client A wants to send a message that requires a reading receipt to Client B:

Client A and Client B log in to the In-app Chat service.
Client A calls the sendMessage or sendMediaMessage API to send a message (common message or rich media message in one-to-one or group chats) to Client B and sets the hasReceipt field of ZIMMessageSendConfig to true.
By listening for related callback (receivePeerMessage or receiveGroupMessage), Client B receives a message whose receiptStatus is set to PROCESSING.

Set the reading receipt status as read

In this operation, set a message as read and set a session as read are both supported.

Set a message as read

The receiver can set a message that requires a reading receipt from the sender as read. Then, the sender will receive a message read notification.

Warning

A single message or a batch of messages are supported. The sender and receiver must be in the same session. Cross-session operations are not supported.
To perform operations on the historical messages of the conversation, you need to get the historical messages and determine the receipt status of the historical messages. For details, see Get message history.

Through related callback (receivePeerMessage or receiveGroupMessage), Client B receives a message that requires a reading receipt from Client A.
Based on the receiptStatus field of the callback, Client B determines the receipt status of the message. If this field is set to PROCESSING, the message is unread. Developers can call the sendMessageReceiptsRead API to set the message as read based on the service logic.
Client B determines whether the setting is successful based on ZIMMessageReceiptsReadSentCallback.
Based on messageReceiptChanged of ZIMEventHandler, Client A receives a callback notification, indicating that the message is set as read. Developers can implement the service logic of setting the message as read on Client A based on this callback.

Set a session as read

The receiver can set all messages received from the sender in a specified session as read.

Warning

The In-app Chat SDK supports this feature only in one-to-one chats.
This feature takes effect only on messages received before setting the feature.
It is recommended that this feature be used when a user switches from the session list page to a session. It is not recommended that this feature be used together with the sendMessageReceiptsRead API on a message chat page.
To perform operations on the historical messages of the conversation, you need to get the historical messages and determine the receipt status of the historical messages. For details, see Get message history.

Based on the receiptStatus field of the receivePeerMessage callback, Client B determines the receipt status of the message. If this field is set to PROCESSING, the message is unread. Developers can call the sendConversationMessageReceiptRead API to set all messages sent by Client A in the session as read based on the service logic.
Client B determines whether the setting is successful based on ZIMConversationMessageReceiptReadSentCallback .
Based on conversationMessageReceiptChanged of ZIMEventHandler , Client A receives a callback notification, indicating that all messages in the session are set as read. Developers can implement the logic of setting all messages sent from the sender in the session as read based on this callback. Developers can implement the service logic of knowing all sent messages in a session are set as read by Client B on Client A based on this callback.

More features

Batch query the message receipt status, number of users who have read the message, and number of users who have not read the message

To query the message receipt status, the number of users who have read the message, and the number of users who have not read the message of a message or a batch of messages, call the queryMessageReceiptsInfoByMessageList API. Call ZIMMessageReceiptsInfoQueriedCallback to obtain related information.

Warning

If messages sent by other users are queried, the number of users who have read the message and the number of users who have not read the message are 0.
To perform operations on the historical messages of the conversation, you need to get the historical messages and determine the receipt status of the historical messages. For details, see Get message history.

Query the list of members who have or have not read a group message

The In-app Chat SDK supports querying the list of members who have or have not read a group message.

Query the list of members who have read a group message

To query the list of members who have read a group message, call the queryGroupMessageReceiptReadMemberListByMessage API.

Warning

To perform operations on the historical messages of the conversation, you need to get the historical messages and determine the receipt status of the historical messages. For details, see Get message history.

Query the list of members who have not read a group message

To query the list of members who have not read a group message, call the queryGroupMessageReceiptUnreadMemberListByMessage API.

Warning

If the SDK version is older than 2.16.0, when the number of group members is greater than 100, this API will not return the list of members who have not read a group message. To use this feature, contact ZEGOCLOUD technical support.
To perform operations on the historical messages of the conversation, you need to get the historical messages and determine the receipt status of the historical messages. For details, see Get message history.

Sample code

Untitled

// 1. Create an In-app Chat object and introduce the appID, appSign, and Application in Android.
ZIMAppConfig appConfig = new ZIMAppConfig();
appConfig.appID = 12345;    // Enter the appID you applied for from the ZEGOCLOUD Admin Console.
appConfig.appSign = "appSign";    // Enter the appSign you applied for from the ZEGOCLOUD Admin Console.
zim = ZIM.create(appConfig, application);

// 2. Log in to the In-app Chat service.
ZIMUserInfo zimUserInfo = new ZIMUserInfo();
zimUserInfo.userID = "xxxx";
zimUserInfo.userName = "xxxx";
zim.login(zimUserInfo, new ZIMLoggedInCallback() {
    @Override
    public void onLoggedIn(ZIMError error) {
          // Developers can determine whether the login is successful based on ZIMError.          
    }
 });

zim.setEventHandler(new ZIMEventHandler() {
    @Override
    public void onReceivePeerMessage(ZIM zim, ArrayList<ZIMMessage> messageList,
                                             String fromUserID) {
        // Receive a one-to-one message.
    }
    @Override
    public void onMessageReceiptChanged(ZIM zim, ArrayList<ZIMMessageReceiptInfo> infos) {
        // The other user sets a message as read.
    }
    @Override
    public void onConversationMessageReceiptChanged(ZIM zim, ArrayList<ZIMMessageReceiptInfo> infos) {
        // The other user sets all messages in a session as read.
    }
})

String conversationID = "xxx" ; // The session ID

// 3. User A sends a message that requires a reading receipt. A text one-to-one message is used as an example.

ZIMTextMessage message = new ZIMTextMessage("test");
ZIMMessageSendConfig sendConfig = new ZIMMessageSendConfig();
sendConfig.hasReceipt = true;    // Set that the messages require a reading receipt.
zim.sendMessage(message, conversationID, ZIMConversationType.PEER,sendConfig, new ZIMMessageSentCallback() {
            @Override
            public void onMessageAttached(ZIMMessage message) {}
            @Override
            public void onMessageSent(ZIMMessage message, ZIMError errorInfo) {
                if (errorInfo.code == ZIMErrorCode.SUCCESS) {
                    // This indicates that the message is sent successfully. receiptStatus of the message is set to PROCESSING. The service layer can display the logic that a message is unread based on this flag.
                }
            }
        });

// 4. User B receives the message that requires a reading receipt and sets the message as read by calling any of the following APIs.

// 4.1 Set a message as read

List<ZIMMessage> messages = new ArrayList<>();
messages.add(message);
zim.sendMessageReceiptsRead(messages, conversationID, ZIMConversationType.PEER, 
        new ZIMMessageReceiptsReadSentCallback() {
            @Override
            public void onMessageReceiptsReadSent(String conversationID, ZIMConversationType conversationType, 
ArrayList<Long> errorMessageIDs, ZIMError errorInfo) {
             if (errorInfo.code == ZIMErrorCode.SUCCESS) {
                // Callback for setting a message as read.
             }
            }
        });

// 4.2 Set a session as read

zim.sendConversationMessageReceiptRead(conversationID, ZIMConversationType.PEER, 
            new ZIMConversationMessageReceiptReadSentCallback() {
            @Override
            public void onConversationMessageReceiptReadSent(String conversationID, 
                ZIMConversationType conversationType, ZIMError errorInfo) {
                if (errorInfo.code == ZIMErrorCode.SUCCESS) {
                    // A session is read. Developers can listen for this callback to set all messages sent by the sender in this session as read.
                }
            }
        });

// 5. (Optional) Batch query the message receipt status, number of users who have read the message, and number of users who have not read the message.

List<ZIMMessage> messages = new ArrayList<>();
messages.add(message);
zim.queryMessageReceiptsInfo(messages, conversationID, ZIMConversationType.PEER, new ZIMMessageReceiptsInfoQueriedCallback() {
            @Override
            public void onMessageReceiptsInfoQueried(ArrayList<ZIMMessageReceiptInfo> infos, 
                ArrayList<Long> errorMessageIDs, ZIMError errorInfo) {
                if (errorInfo.code == ZIMErrorCode.SUCCESS) {
                    // The status and quantity of this batch of messages are queried, and the corresponding message ID and count are obtained by traversing the information.
                }
            }
        });
// 6. (Optional) Query the list of members who have or have not read a group message.

// 6.1 The list of members who have read a group message
ZIMGroupMessageReceiptMemberQueryConfig config = new ZIMGroupMessageReceiptMemberQueryConfig();
config.nextFlag = 0;    // The query flag. It is set to 0 in the first query. In subsequent queries, it is set to the flag returned in the callback.
config.count = 10;    // The user quantity to be queried.
zim.queryGroupMessageReceiptReadMemberList(message, groupID, config, 
    new ZIMGroupMessageReceiptMemberListQueriedCallback() {
            @Override
            public void onGroupMessageReceiptMemberListQueried(String groupID, ArrayList<ZIMGroupMemberInfo> userList,
             int nextFlag, ZIMError errorInfo) {
                if (errorInfo.code == ZIMErrorCode.SUCCESS) {
                   // The corresponding member list is queried.
                }
            }
        });

// 6.2 The list of members who have not read a group message
ZIMGroupMessageReceiptMemberQueryConfig config = new ZIMGroupMessageReceiptMemberQueryConfig();
config.nextFlag = 0;    // The query flag. It is set to 0 in the first query. In subsequent queries, it is set to the flag returned in the callback.
config.count = 10;    // The user quantity to be queried.

zim.queryGroupMessageReceiptUnreadMemberList(message, groupID, config, 
    new ZIMGroupMessageReceiptMemberListQueriedCallback() {
            @Override
            public void onGroupMessageReceiptMemberListQueried(String groupID, ArrayList<ZIMGroupMemberInfo> userList,
             int nextFlag, ZIMError errorInfo) {
                if (errorInfo.code == ZIMErrorCode.SUCCESS) {
                   // The corresponding member list is queried.
                }
            }
        });

Copied!

Untitled

// 1. Create an In-app Chat object and introduce the appID and appSign.
ZIMAppConfig *appConfig = [[ZIMAppConfig alloc] init];
appConfig.appID = (unsigned int)appID;    // Enter the appID you applied for from the ZEGOCLOUD Admin Console.
appConfig.appSign = @"appSign";    // Enter the appSign you applied for from the ZEGOCLOUD Admin Console.
self.zim = [ZIM createWithAppConfig: appConfig];

// 2. Log in to the In-app Chat service.
ZIMUserInfo *userInfo = [[ZIMUserInfo alloc]init];
userInfo.userID = @"zegoUser1"; // Enter a value of the NSString type.
userInfo.userName = @"zegotest";// Enter a value of the NSString type.

[self.zim loginWithUserInfo:userInfo callback:^(ZIMError * _Nonnull errorInfo){
    // Developers can determine whether the login is successful based on ZIMError.
}];


- (void)zim:(ZIM *)zim messageReceiptChanged:(NSArray<ZIMMessageReceiptInfo *> *)infos{
     // The other user sets a message as read.
}


- (void)zim:(ZIM *)zim conversationMessageReceiptChanged:(NSArray<ZIMMessageReceiptInfo *> *)infos{
    // The other user sets all messages in a session as read.
}



NSString *conversationID = @"xxx" ; // The session ID.

// 3. User A sends a message that requires a reading receipt. A text one-to-one message is used as an example.

ZIMTextMessage *message = [[ZIMTextMessage alloc] init];
ZIMMessageSendConfig *sendConfig = [[ZIMMessageSendConfig alloc]init];
sendConfig.hasReceipt = true;    // Set that the messages require a reading receipt.
[self.zim sendMessage:cmdMsg toUserID:toUserID conversationType:type config:config notification:notification callback:^((ZIMMessage * _Nonnull message, ZIMError * _Nonnull errorInfo)) {
    // Developers can listen for whether a message is sent successfully through this callback.
    if (errorInfo.code == 0) {
        // This indicates that the message is sent successfully. receiptStatus of the message is set to PROCESSING. The service layer can display the logic that a message is unread based on this flag.
    }
}];


// 4. User B receives the message that requires a reading receipt and sets the message as read by calling any of the following APIs.

// 4.1 Set a message as read
NSMutableArray<ZIMMessage *> *messageList = [[NSMutableArray alloc] init];

[[ZIM getInstance] sendMessageReceiptsRead:messageList conversationID:@"conversationID" conversationType:conversationType callback:^(NSString * _Nonnull conversationID, ZIMConversationType conversationType, NSArray<NSNumber *> * _Nonnull errorMessageIDs, ZIMError * _Nonnull errorInfo) {
     // Callback for setting a message as read.
}];
// 4.2 Set a session as read
[[ZIM getInstance] sendConversationMessageReceiptRead:@"conversationID" conversationType:conversationType callback:^(NSString * _Nonnull conversationID, ZIMConversationType conversationType, ZIMError * _Nonnull errorInfo) {
    // Callback for setting all messages in a session as read.
}];

// 5. (Optional) Batch query the message receipt status, number of users who have read the message, and number of users who have not read the message.
NSMutableArray<ZIMMessage *> *messageList = [[NSMutableArray alloc] init];
[[ZIM getInstance] queryMessageReceiptsInfoByMessageList:messageList conversationID:conversationID conversationType:conversationType callback:^(NSArray<ZIMMessageReceiptInfo *> * _Nonnull infos, NSArray<NSNumber *> * _Nonnull errorMessageIDs, ZIMError * _Nonnull errorInfo) {
     // The status and quantity of this batch of messages are queried, and the corresponding message ID and count are obtained by traversing the information.
}];


// 6. (Optional) Query the list of members who have or have not read a group message.

// 6.1 The list of members who have read a group message
ZIMGroupMessageReceiptMemberQueryConfig *config =  [[ZIMGroupMessageReceiptMemberQueryConfig alloc]init];
config.nextFlag = 0;    // The query flag. It is set to 0 in the first query. In subsequent queries, it is set to the flag returned in the callback.
config.count = 10;    // The user quantity to be queried.
[[ZIM getInstance] queryGroupMessageReceiptReadMemberListByMessage:message groupID:groupID config:config callback:^(NSString * _Nonnull groupID, NSArray<ZIMGroupMemberInfo *> * _Nonnull userList, unsigned int nextFlag, ZIMError * _Nonnull errorInfo)    {
    // The corresponding member list is queried.
}];


// 6.2 The list of members who have not read a group message
ZIMGroupMessageReceiptMemberQueryConfig config = new ZIMGroupMessageReceiptMemberQueryConfig();
config.nextFlag = 0;    // The query flag. It is set to 0 in the first query. In subsequent queries, it is set to the flag returned in the callback.
config.count = 10;    // The user quantity to be queried.
[[ZIM getInstance] queryGroupMessageReceiptUnreadMemberListByMessage:message groupID:groupID config:config callback:^(NSString * _Nonnull groupID, NSArray<ZIMGroupMemberInfo *> * _Nonnull userList, unsigned int nextFlag, ZIMError * _Nonnull errorInfo) {
    // The corresponding member list is queried.
}];

Copied!

Untitled

// 1. Create an In-app Chat object and introduce the appID and appSign.
ZIMAppConfig *appConfig = [[ZIMAppConfig alloc] init];
appConfig.appID = (unsigned int)appID;    // Enter the appID you applied for from the ZEGOCLOUD Admin Console.
appConfig.appSign = @"appSign";    // Enter the appSign you applied for from the ZEGOCLOUD Admin Console.
self.zim = [ZIM createWithAppConfig: appConfig];

// 2. Log in to the In-app Chat service.
ZIMUserInfo *userInfo = [[ZIMUserInfo alloc]init];
userInfo.userID = @"zegoUser1"; // Enter a value of the NSString type.
userInfo.userName = @"zegotest";// Enter a value of the NSString type.

[self.zim loginWithUserInfo:userInfo callback:^(ZIMError * _Nonnull errorInfo){
    // Developers can determine whether the login is successful based on ZIMError.
}];


- (void)zim:(ZIM *)zim messageReceiptChanged:(NSArray<ZIMMessageReceiptInfo *> *)infos{
     // The other user sets a message as read.
}


- (void)zim:(ZIM *)zim conversationMessageReceiptChanged:(NSArray<ZIMMessageReceiptInfo *> *)infos{
    // The other user sets all messages in a session as read.
}



NSString *conversationID = @"xxx" ; // The session ID.

// 3. User A sends a message that requires a reading receipt. A text one-to-one message is used as an example.

ZIMTextMessage *message = [[ZIMTextMessage alloc] init];
ZIMMessageSendConfig *sendConfig = [[ZIMMessageSendConfig alloc]init];
sendConfig.hasReceipt = true;    // Set that the messages require a reading receipt.
[self.zim sendMessage:cmdMsg toUserID:toUserID conversationType:type config:config notification:notification callback:^((ZIMMessage * _Nonnull message, ZIMError * _Nonnull errorInfo)) {
    // Developers can listen for whether a message is sent successfully through this callback.
    if (errorInfo.code == 0) {
        // This indicates that the message is sent successfully. receiptStatus of the message is set to PROCESSING. The service layer can display the logic that a message is unread based on this flag.
    }
}];


// 4. User B receives the message that requires a reading receipt and sets the message as read by calling any of the following APIs.

// 4.1 Set a message as read
NSMutableArray<ZIMMessage *> *messageList = [[NSMutableArray alloc] init];

[[ZIM getInstance] sendMessageReceiptsRead:messageList conversationID:@"conversationID" conversationType:conversationType callback:^(NSString * _Nonnull conversationID, ZIMConversationType conversationType, NSArray<NSNumber *> * _Nonnull errorMessageIDs, ZIMError * _Nonnull errorInfo) {
     // Callback for setting a message as read.
}];
// 4.2 Set a session as read
[[ZIM getInstance] sendConversationMessageReceiptRead:@"conversationID" conversationType:conversationType callback:^(NSString * _Nonnull conversationID, ZIMConversationType conversationType, ZIMError * _Nonnull errorInfo) {
    // Callback for setting all messages in a session as read.
}];

// 5. (Optional) Batch query the message receipt status, number of users who have read the message, and number of users who have not read the message.
NSMutableArray<ZIMMessage *> *messageList = [[NSMutableArray alloc] init];
[[ZIM getInstance] queryMessageReceiptsInfoByMessageList:messageList conversationID:conversationID conversationType:conversationType callback:^(NSArray<ZIMMessageReceiptInfo *> * _Nonnull infos, NSArray<NSNumber *> * _Nonnull errorMessageIDs, ZIMError * _Nonnull errorInfo) {
     // The status and quantity of this batch of messages are queried, and the corresponding message ID and count are obtained by traversing the information.
}];


// 6. (Optional) Query the list of members who have or have not read a group message.

// 6.1 The list of members who have read a group message
ZIMGroupMessageReceiptMemberQueryConfig *config =  [[ZIMGroupMessageReceiptMemberQueryConfig alloc]init];
config.nextFlag = 0;    // The query flag. It is set to 0 in the first query. In subsequent queries, it is set to the flag returned in the callback.
config.count = 10;    // The user quantity to be queried.
[[ZIM getInstance] queryGroupMessageReceiptReadMemberListByMessage:message groupID:groupID config:config callback:^(NSString * _Nonnull groupID, NSArray<ZIMGroupMemberInfo *> * _Nonnull userList, unsigned int nextFlag, ZIMError * _Nonnull errorInfo)    {
    // The corresponding member list is queried.
}];


// 6.2 The list of members who have not read a group message
ZIMGroupMessageReceiptMemberQueryConfig config = new ZIMGroupMessageReceiptMemberQueryConfig();
config.nextFlag = 0;    // The query flag. It is set to 0 in the first query. In subsequent queries, it is set to the flag returned in the callback.
config.count = 10;    // The user quantity to be queried.
[[ZIM getInstance] queryGroupMessageReceiptUnreadMemberListByMessage:message groupID:groupID config:config callback:^(NSString * _Nonnull groupID, NSArray<ZIMGroupMemberInfo *> * _Nonnull userList, unsigned int nextFlag, ZIMError * _Nonnull errorInfo) {
    // The corresponding member list is queried.
}];

Copied!

Untitled

// 1. Create an In-app Chat object and introduce the appID and appSign.
zim::ZIMAppConfig appConfig;
appConfig.appID = appid;  // Enter the appID you applied for from the ZEGOCLOUD Admin Console.
appConfig.appSign = "appSign";   // Enter the appSign you applied for from the ZEGOCLOUD Admin Console.
zim_ = zim::ZIM::create(appConfig);
zim_->setEventHandler(event_handler_);

// 2. Log in to the In-app Chat service.
zim::ZIMUserInfo userInfo;
userInfo.userID = user_id;
userInfo.userName = user_name;

zim_->login(userInfo, [=](zim::ZIMError errorInfo) {

    if (errorInfo.code == zim::ZIMErrorCode::ZIM_ERROR_CODE_SUCCESS) {
    // You can determine whether the login is successful based on ZIMError.
    }
 });




// 3. User A sends a message that requires a reading receipt. A text one-to-one message is used as an example.

zim::ZIMMessageSendConfig sendConfig;
zim::ZIMPushConfig pushConfig;

pushConfig.content = "win_push_content";
pushConfig.payload = "win_push_extended_data";
pushConfig.title = "win_push_title";

sendConfig.priority = zim::ZIM_MESSAGE_PRIORITY_MEDIUM;
sendConfig.pushConfig = &pushConfig;
sendConfig.hasReceipt = true; // Set that the messages require a reading receipt.

auto smessage = std::make_shared<zim::ZIMTextMessage>("test message");

auto notification = std::make_shared<zim::ZIMMessageSendNotification>(
    [=](const std::shared_ptr<zim::ZIMMessage> &message) { 
        
       //  Notification for message being stored in the database
    });

zim_->sendMessage(
    std::static_pointer_cast<zim::ZIMMessage>(smessage), userID,
    zim::ZIMConversationType::ZIM_CONVERSATION_TYPE_PEER, sendConfig, notification,
    [=](const std::shared_ptr<zim::ZIMMessage> &cb_message, const zim::ZIMError &errorInfo) {
        if (errorInfo.code == zim::ZIMErrorCode::ZIM_ERROR_CODE_SUCCESS) {
            // This indicates that the message has been successfully sent. The receiptStatus of the message will be PROCESSING, and the business layer can implement logic to display the unread receipt.
        }
    });


// 4. User B receives the message that requires a reading receipt and sets the message as read by calling any of the following APIs.

// 4.1 Set a message as read

std::vector<std::shared_ptr<zim::ZIMMessage>> messages;
messages.emplace_back(message);

zim_->sendMessageReceiptsRead(
    messages, conversationID, zim::ZIMConversationType::ZIM_CONVERSATION_TYPE_PEER,
    [=](const std::string &conversationID, zim::ZIMConversationType conversationType,
        const std::vector<long long> &errorMessageIDs,
        const zim::ZIMError &errorInfo) { 
        // Callback for setting a message as read.
    });

// 4.2 Set a session as read

zim_->sendConversationMessageReceiptRead(
    conversationID, zim::ZIMConversationType::ZIM_CONVERSATION_TYPE_PEER,
    [=](const std::string &conversationID, zim::ZIMConversationType conversationType,
        const zim::ZIMError &errorInfo) { 
            // Callback for conversation read receipt. Developers can use this callback to set all messages sent by the other party in this conversation as read.
    });

// 5. (Optional) Batch query the message receipt status, number of users who have read the message, and number of users who have not read the message.

std::vector<std::shared_ptr<zim::ZIMMessage>> messages;
messages.emplace_back(message);
zim_->queryMessageReceiptsInfo(
    messages, conversationID, zim::ZIMConversationType::ZIM_CONVERSATION_TYPE_PEER,
    [=](const std::vector<zim::ZIMMessageReceiptInfo> &infos,
        std::vector<long long> errorMessageIDs, const zim::ZIMError &errorInfo) {});


// 6. (Optional) Query the list of members who have or have not read a group message.

// 6.1 Read user list
zim::ZIMGroupMessageReceiptMemberQueryConfig readMemberQueryConfig;
readMemberQueryConfig.count = 10;    // Number of users to query.
readMemberQueryConfig.nextFlag = 0;    // Query flag, fill in 0 initially, and fill in the flag returned from the callback later.

zim_->queryGroupMessageReceiptReadMemberList(
    message, "group_id", readMemberQueryConfig,
    [=](const std::string &groupID, const std::vector<zim::ZIMGroupMemberInfo> &userList,
        unsigned int nextFlag, const zim::ZIMError &errorInfo) {
                if (errorInfo.code == zim::ZIMErrorCode::ZIM_ERROR_CODE_SUCCESS) {
                   // Query the corresponding member list
                }
        });

// 6.2 Unread user list
zim::ZIMGroupMessageReceiptMemberQueryConfig unreadMemberQueryConfig;
unreadMemberQueryConfig.count = 10;    // Number of users to query.
unreadMemberQueryConfig.nextFlag = 0;    // Query flag, fill in 0 initially, and fill in the flag returned from the callback later.

zim_->queryGroupMessageReceiptUnreadMemberList(
    message, "group_id", unreadMemberQueryConfig,
    [=](const std::string &groupID, const std::vector<zim::ZIMGroupMemberInfo> &userList,
        unsigned int nextFlag, const zim::ZIMError &errorInfo) {
                if (errorInfo.code == zim::ZIMErrorCode::ZIM_ERROR_CODE_SUCCESS) {
                   // Query the corresponding member list
                }
        });

Copied!

Untitled

// 1. Create an In-app Chat object and introduce the appID, appSign, and Application in Android.
ZIMAppConfig appConfig = ZIMAppConfig();
appConfig.appID = 12345;  // Enter the appID you applied for from the ZEGOCLOUD Admin Console.
appConfig.appSign = "appSign";   // Enter the appSign you applied for from the ZEGOCLOUD Admin Console.
zim = ZIM.create(appConfig);

// 2. Log in to the In-app Chat service.
try{
     ZIMLoginConfig loginConfig = ZIMLoginConfig();
     // The user's nickname, leave it blank if you don't want to modify the nickname
    loginConfig.userName = 'userName';
     // If using token as the login authentication method, please fill in this parameter, otherwise no need to fill in
     loginConfig.token = '';
     // Whether this login is an offline login, please refer to the offline login related documentation for details
    loginConfig.isOfflineLogin = false;
    await ZIM.getInstance()?.login('zego', loginConfig);
     // Login successful, write the business logic for successful login
 } on PlatformException catch(onError){
     // Login failed
     // Error code for login failure, please refer to the error code table in the integration documentation to handle
     onError.code;
     // Error message for login failure
     onError.message;
 }
	 
   
   
   
	 
 ZIMEventHandler.onReceivePeerMessage = (zim, messageList, fromUserID) {
 // Receive private chat messages
 };
	 
 ZIMEventHandler.onMessageReceiptChanged = (zim, infos) {
 // The other party has set the message read receipt
= };
	 
 ZIMEventHandler.onConversationMessageReceiptChanged = (zim, infos) {
	      // The other party has set the conversation read receipt
 };


String conversationID = "xxx" ; // The conversation ID

// 3. User A sends a message that requires a reading receipt. A text one-to-one message is used as an example.

  ZIMTextMessage message = ZIMTextMessage(message: "test");
  ZIMMessageSendConfig sendConfig = ZIMMessageSendConfig();
  sendConfig.hasReceipt = true; // Set that the messages require a reading receipt.
  ZIM
      .getInstance()!
      .sendMessage(
          message, conversationID, ZIMConversationType.peer, sendConfig)
      .then((result) {
        // This indicates that the message is sent successfully. receiptStatus of the message is set to PROCESSING. The service layer can display the logic that a message is unread based on this flag.
      })
      .catchError((onError) {

      });
// 4. User B receives the message that requires a reading receipt and sets the message as read by calling any of the following APIs.

// 4.1 Set a message as read

  List<ZIMMessage> messages = [];
  ZIM
      .getInstance()!
      .sendMessageReceiptsRead(
          messages, conversationID, ZIMConversationType.peer)
      .then((result) {
        // Callback for setting a message as read.
      })
      .catchError((onError) {

      });

// 4.2 Set a session as read

  ZIM
      .getInstance()!
      .sendConversationMessageReceiptRead(
          conversationID, ZIMConversationType.peer)
      .then((value) {
        // A session is read. Developers can listen for this callback to set all messages sent by the sender in this session as read.
      })
      .catchError((onError) {

      });

// 5. (Optional) Batch query the message receipt status, number of users who have read the message, and number of users who have not read the message.


List<ZIMMessage> messages = [];
  ZIM
      .getInstance()!
      .queryMessageReceiptsInfo(
          messages, conversationID, ZIMConversationType.peer)
      .then((value) {
        // The status and quantity of this batch of messages are queried, and the corresponding message ID and count are obtained by traversing the information.
      })
      .catchError((onError) {});
// 6. (Optional) Query the list of members who have or have not read a group message.

// 6.1 The list of members who have read a group message
ZIMGroupMessageReceiptMemberQueryConfig config =
      ZIMGroupMessageReceiptMemberQueryConfig();
config.nextFlag = 0;    // The query flag. It is set to 0 in the first query. In subsequent queries, it is set to the flag returned in the callback.
config.count = 10;    // The user quantity to be queried.

  ZIM
      .getInstance()!
      .queryGroupMessageReceiptReadMemberList(message, groupID, config)
      .then((result) {
          //  The corresponding member list is queried.
      })
      .catchError((onError) {

      });

// 6.2 The list of members who have not read a group message
ZIMGroupMessageReceiptMemberQueryConfig config = ZIMGroupMessageReceiptMemberQueryConfig();
config.nextFlag = 0;    // The query flag. It is set to 0 in the first query. In subsequent queries, it is set to the flag returned in the callback.
config.count = 10;    // The user quantity to be queried.

  ZIM
      .getInstance()!
      .queryGroupMessageReceiptUnreadMemberList(message, groupID, config)
      .then((result) {
          // The corresponding member list is queried.
      })
      .catchError((onError) {

      });

Copied!

Untitled

// 1. Create a ZIM object and pass in the appID and appSign
ZIMAppConfig appConfig = new ZIMAppConfig();
appConfig.appID = 12345;  // Replace with the AppID you obtained from the ZEGO Console
appConfig.appSign = "appSign";   // Replace with the AppSign you obtained from the ZEGO Console
ZIM.Create(appConfig);

// 2. Log in
ZIMUserInfo zimUserInfo = new ZIMUserInfo();
zimUserInfo.userID = "xxxx";
zimUserInfo.userName = "xxxx";
ZIM.GetInstance().Login(zimUserInfo, (ZIMError errorInfo) =>
{
    // Developers can use ZIMError to determine if the login is successful.
});

ZIM.GetInstance().onMessageReceiptChanged = (ZIM zim, List<ZIMMessageReceiptInfo> infos) =>
{
    // Group message receipt status changed
};

ZIM.GetInstance().onConversationMessageReceiptChanged = (ZIM zim, List<ZIMMessageReceiptInfo> infos) =>
{
    // Conversation message receipt status changed
};

string conversationID = "xxx"; // Conversation ID

// 3. User A sends a message with receipt, taking a peer-to-peer text message as an example

ZIMTextMessage message = new ZIMTextMessage("test");
ZIMMessageSendConfig sendConfig = new ZIMMessageSendConfig();
sendConfig.hasReceipt = true;    // Set the message with receipt
ZIMMessageSendNotification notification = new ZIMMessageSendNotification();
ZIM.GetInstance().SendMessage(message, "conversationID", ZIMConversationType.Peer, sendConfig, notification,
    (ZIMMessage message, ZIMError errorInfo) => { });

// 4. User B receives the receipt and marks it as read, choose one of the following interfaces

// 4.1 Message read

List<ZIMMessage> messages = new List<ZIMMessage>();
messages.Add(message);
ZIM.GetInstance().SendMessageReceiptsRead(messages, "conversationID", ZIMConversationType.Peer, (string conversationID, ZIMConversationType conversationType,
                   List<long> errorMessageIDs, ZIMError errorInfo) =>
{
    // Callback for sending message read
});

// 4.2 Conversation read

ZIM.GetInstance().SendConversationMessageReceiptRead("conversationID", ZIMConversationType.Peer, (string conversationID, ZIMConversationType conversationType,
                           ZIMError errorInfo) =>
{
    // Callback for sending conversation message read
});

// 5. (Optional) Query the receipt status, unread user count, and read user count for a batch of messages

List<ZIMMessage> queryMessages = new List<ZIMMessage>();
queryMessages.Add(message);
ZIM.GetInstance().QueryMessageReceiptsInfo(queryMessages, "conversationID", ZIMConversationType.Peer, (List<ZIMMessageReceiptInfo> infos, List<long> errorMessageIDs,
                           ZIMError errorInfo) =>
{ });

// 6. (Optional) Query the list of read group members and unread group members for a specific group message

// 6.1 List of read users
ZIMGroupMessageReceiptMemberQueryConfig config = new ZIMGroupMessageReceiptMemberQueryConfig();
config.nextFlag = 0;    // The flag for querying, fill in 0 initially, and then fill in the flag returned from the callback.
config.count = 10;    // The number of users to query.

ZIM.GetInstance().QueryGroupMessageReceiptReadMemberList(message, "groupID", config, (string groupID, List<ZIMGroupMemberInfo> userList,
                           uint nextFlag, ZIMError errorInfo) =>
{ });

// 6.2 List of unread users
ZIMGroupMessageReceiptMemberQueryConfig groupMessageReceiptMemberQueryConfig = new ZIMGroupMessageReceiptMemberQueryConfig();
groupMessageReceiptMemberQueryConfig.nextFlag = 0;    // The flag for querying, fill in 0 initially, and then fill in the flag returned from the callback.
groupMessageReceiptMemberQueryConfig.count = 10;    // The number of users to query.

ZIM.GetInstance().QueryGroupMessageReceiptUnreadMemberList(message, "groupID", groupMessageReceiptMemberQueryConfig, (string groupID, List<ZIMGroupMemberInfo> userList,
                           uint nextFlag, ZIMError errorInfo) => { });

Copied!

Untitled

// 1. Register a callback.

// Receive a one-to-one message.
zim.on('receivePeerMessage', function (zim, { messageList, fromConversationID }) {
    console.log('receivePeerMessage', messageList, fromConversationID);
});
// The other user sets a message as read.
zim.on('messageReceiptChanged', function (zim, { infos }) {
    console.log('messageReceiptChanged', infos);
});
// The other user sets all messages in a session as read.
zim.on('conversationMessageReceiptChanged', function (zim, { infos }) {
    console.log('conversationMessageReceiptChanged', infos);
});

var userID_A = "xxxx" ;    // The ID of user A.
var userID_B = "xxxx" ;    // The ID of user B.

// 2. User A sends a message that requires a reading receipt to user B. A text one-to-one message is used as an example.

var messageObj = { type: 1, message: 'text receipt message' }
var config = {
    priority: 1,    // Message priority. Valid values: 1: Low (default), 2: Medium, 3: High
    hasReceipt: true    // Set that the messages require a reading receipt.
}
var notification = {
    onMessageAttached: function(message) {
        // todo: Loading
    }
}

zim.sendMessage(messageObj, userID_B, 0, config, notification)
    .then(function ({ message }) {
        // Sent successfully.
    })
    .catch(function (err) {
        // Sending failed.
    });

// 3. User B receives the message that requires a reading receipt and sets the message as read by calling any of the following APIs.

// 3.1 Set a message as read
var messages = [];    // Queried from queryHistoryMessage or received from receivePeerMessage
zim.sendMessageReceiptsRead(messages, userID_A, 0)    
    .then(function ({ conversationID, conversationType, errorMessageIDs }) {
        // The operation is successful. Messages that failed to be set as read are returned through errorMessageIDs.
    })
    .catch(function (err) {
        // The operation fails.
    });

// 3.2 Set a session as read
zim.sendConversationMessageReceiptRead(userID_A, 0)
    .then(function ({ conversationID, conversationType }) {
        // The operation is successful. User B can set all messages sent from user A in this session as read.
    })
    .catch(function (err) {
        // The operation fails.
    });

// 4. (Optional) Batch query the message receipt status, number of users who have read the message, and number of users who have not read the message.

var messages = []; // Queried from queryHistoryMessage
zim.queryMessageReceiptsInfo(messages, userID_B, 0)    
    .then(function ({ infos, errorMessageIDs }) {
        // The operation is successful. Messages that failed to be queried are returned through errorMessageIDs.
    })
    .catch(function (err) {
        // The operation fails.
    });

// 5. (Optional) Query the list of members who have or have not read a group message.

var groupMsgObj = {}    // Queried from queryHistoryMessage
var queryConfig = {
    count: 10,    // The user quantity to be queried.
    nextFlag: 0    // The query flag. It is set to 0 in the first query. In subsequent queries, it is set to the flag returned in Promise.
}

// 5.1 The list of members who have read a group message
zim.queryGroupMessageReceiptReadMemberList(groupMsgObj, groupMsgObj.conversationID, queryConfig)
    .then(function ({ nextFlag, userList, groupID }) {
        // The operation is successful.
    })
    .catch(function (err) {
        // The operation fails.
    });

// 5.2 The list of members who have not read a group message
zim.queryGroupMessageReceiptUnreadMemberList(groupMsgObj, groupMsgObj.conversationID, queryConfig)
    .then(function ({ nextFlag, userList, groupID }) {
        // The operation is successful.
    })
    .catch(function (err) {
        // The operation fails.
    });

Copied!