Send and receive messages

// Send a text message to a one-to-one conversation
String toConversationID = "xxxx1";

ZIMTextMessage zimMessage = new ZIMTextMessage();
zimMessage.message = "Message content";

ZIMMessageSendConfig config = new ZIMMessageSendConfig();
// Set the message priority.
config.priority = ZIMMessagePriority.LOW;
// Set up the configurations of the offline notifications.
// Offline push configuration of room messages is not supported. If you need to send room offline messages, please contact ZEGOCLOUD technical support team to activate relevant permissions.
ZIMPushConfig pushConfig = new ZIMPushConfig();
pushConfig.title = "Offline notification title";
pushConfig.content= "Offline notification content";
pushConfig.extendedData = "Extension info of the offline notification";
config.pushConfig = pushConfig;

ZIMConversationType type = ZIMConversationType.Peer;

zim.sendMessage(zimMessage, toConversationID, type, config, new ZIMMessageSentFullCallback() {
    @Override
    public void onMessageAttached(ZIMMessage zimMessage) {
    // You can use this callback to monitor whether the message is ready to be sent. This callback will be thrown only if the message passes the local basic parameter verification, otherwise an error will be thrown through the onMessageSent callback.
    }

    @Override
    public void onMessageSent(ZIMMessage zimMessage, ZIMError error) {
    // You can use this callback to monitor whether the message is ready to be sent. This callback will be thrown only if the message passes the local basic parameter verification, otherwise an error will be thrown through the onMessageSent callback.
    }
});

// Send a text message to a one-to-one conversation
NSString *toConversationID = @"xxxx1";

ZIMTextMessage *textMessage = [[ZIMTextMessage alloc] init];
textMessage.message = @"Message content";

ZIMMessageSendConfig *config = [[ZIMMessageSendConfig alloc] init];
// Set the message priority.
config.priority = ZIMMessagePriorityLow;
// Set up the configurations of the offline notifications. To use this, enable this feature first. 
// Offline push configuration of room messages is not supported. If you need to send room offline messages, please contact ZEGOCLOUD technical support team to activate relevant permissions.
ZIMPushConfig *pushConfig = [[ZIMPushConfig alloc] init];
pushConfig.title = @"Offline notification title";
pushConfig.content= @"Offline notification content";
pushConfig.extendedData = @"Extension info of the offline notification";
config.pushConfig = pushConfig

ZIMMessageSendNotification *notification = [[ZIMMessageSendNotification alloc] init];
notification.onMessageAttached = ^(ZIMMessage * _Nonnull message) {
    // The callback on the message not sent yet. Before the message is sent, you can get a temporary ZIMMessage message for you to implement your business logic as needed. 
};

ZIMConversationType type = ZIMConversationTypePeer;

[self.zim sendMessage:textMessage toConversationID:toConversationID conversationType:type config:config notification:notification callback:^((ZIMMessage * _Nonnull message, ZIMError * _Nonnull errorInfo)) {
    // You can listen for this callback for the message sending results.
}];

// Send a text message to a one-to-one conversation

zim::ZIMMessage* message = nullptr;
zim::ZIMTextMessage text_message;
text_message.message = "message";
zim::ZIMMessageSendConfig config;
// Set the message priority.
config.priority = zim::ZIM_MESSAGE_PRIORITY_LOW;
message = &text_message;

zim::ZIMConversationType type = zim::ZIMConversationType::ZIM_CONVERSATION_TYPE_PEER

auto notification = std::make_shared<zim::ZIMMessageSendNotification>(
            [=](const std::shared_ptr<zim::ZIMMessage> &message) { int i = 0; });

zim_->sendMessage(message, "toConversationID", type, config, notification,
                    [=](const std::shared_ptr<zim::ZIMMessage> &message,
                              const zim::ZIMError &errorInfo) { int i = 0; });

// Send a text message to a one-to-one conversation

var toConversationID = ''; // The userID of the message receiver
var conversationType = 0; // Applicable value: 0 (one-to-one), 1 (room), 2 (group).
var config = { 
    // Set the message priority.
    // The applicable value is 1 (low, default), 2 (middle), 3 (high).
    priority: 1,
};

var notification = {
    onMessageAttached: function(message) {
        // 
    }
}

var messageTextObj = {
    type: 1,
    message: 'xxxx'
};

zim.sendMessage(messageTextObj, toConversationID, conversationType, config, notification)
    .then(function ({ message }) {
        // Sent successfully
    })
    .catch(function (err) {
        // failed to send
    });

// Send a text message to a one-to-one conversation

ZIMTextMessage textMessage = ZIMTextMessage(message: "message");
ZIMMessageSendConfig sendConfig = ZIMMessageSendConfig();
// Set the message priority.
sendConfig.priority = ZIMMessagePriority.low;

ZIMPushConfig pushConfig = ZIMPushConfig();
pushConfig.title = "Offline notification title";
pushConfig.content = "Offline notification content";
pushConfig.extendedData = "Extension info of the offline notificatio";
sendConfig.pushConfig = pushConfig;
ZIMMessageSendNotification notification = ZIMMessageSendNotification(onMessageAttached: (message){
    // Callback before sending: You can obtain a temporary object here, which is the same object as the zimMessage object created by you. You can utilize this feature to implement business logic, such as displaying the UI in advance.
});

ZIMConversationType type = ZIMConversationType.peer;

ZIM.getInstance()!.sendMessage(textMessage, toConversationID, type, sendConfig).then((value) => {
    // Sent successfully
}).catchError((onError){
    // Failed to send
});

zim.setEventHandler(new ZIMEventHandler() {
    @Override
    public void onPeerMessageReceived(ZIM zim, ArrayList<ZIMMessage> messageList, ZIMMessageReceivedInfo info, String fromUserID) {
        // Callback for receiving one-to-one messages. 
        for (ZIMMessage zimMessage : messageList) {
           if (zimMessage instanceof ZIMTextMessage) {
                ZIMTextMessage zimTextMessage = (ZIMTextMessage) zimMessage;
                Log.e(TAG, "The text message you received:"+ zimTextMessage.message);
           } else if (zimMessage instanceof ZIMCommandMessage) {
                ZIMCommandMessage zimCommandMessage = (ZIMCommandMessage) zimMessage;
                Log.e(TAG, "The signaling message you received:"+ zimCommandMessage.message);
           }    
        }
    }

    @Override
    public void onGroupMessageReceived(ZIM zim, ArrayList<ZIMMessage> messageList, ZIMMessageReceivedInfo info, String fromGroupID) {
        // Callback for receiving group messages. 
        for (ZIMMessage zimMessage : messageList) {
           if (zimMessage instanceof ZIMTextMessage) {
                ZIMTextMessage zimTextMessage = (ZIMTextMessage) zimMessage;
                Log.e(TAG, "The text message you received:"+ zimTextMessage.message);
           } else if (zimMessage instanceof ZIMCommandMessage) {
                ZIMCommandMessage zimCommandMessage = (ZIMCommandMessage) zimMessage;
                Log.e(TAG, "The signaling message you received:"+ zimCommandMessage.message);
           }    
        }
    }

    @Override
    public void onRoomMessageReceived(ZIM zim, ArrayList<ZIMMessage> messageList, ZIMMessageReceivedInfo info, String fromRoomID) {
        // Callback for receiving in-room messages. 
        for (ZIMMessage zimMessage : messageList) {
           if (zimMessage instanceof ZIMTextMessage) {
                ZIMTextMessage zimTextMessage = (ZIMTextMessage) zimMessage;
                Log.e(TAG, "The text message you received:"+ zimTextMessage.message);
           } else if (zimMessage instanceof ZIMCommandMessage) {
                ZIMCommandMessage zimCommandMessage = (ZIMCommandMessage) zimMessage;
                Log.e(TAG, "The signaling message you received:"+ zimCommandMessage.message);
           }    
        }
    }
});

// Set up a ZIMEventHander and listen for related callbacks.
[zim setEventHandler:self];

// Callback for receiving the one-to-one message.
- (void)zim:(ZIM *)zim
    peerMessageReceived:(NSArray<ZIMMessage *> *)messageList
            info:(ZIMMessageReceivedInfo *)info
            fromUserID:(NSString *)fromUserID{
    // Implement your event handling logic after receiving the message here. 
}

// Callback for receiving the group message.
- (void)zim:(ZIM *)zim
    groupMessageReceived:(NSArray<ZIMMessage *> *)messageList
            info:(ZIMMessageReceivedInfo *)info
            fromGroupID:(NSString *)fromGroupID{
    // Implement your event handling logic after receiving the message here. 
}

// Callback for receiving the in-room message.
- (void)zim:(ZIM *)zim
    roomMessageReceived:(NSArray<ZIMMessage *> *)messageList
            info:(ZIMMessageReceivedInfo *)info
            fromRoomID:(NSString *)fromRoomID{
    // Implement your event handling logic after receiving the message here. 
}

// Send rich media content in one-to-one conversation - Send an image:
ZIMImageMessage message = new ZIMImageMessage("/storage/emulated/0/Android/data/packagename/picture/xxx.jpg");
// If a network URL is entered here, the SDK will pass through the path without ZIM background service processing. If both the network URL and the local path are entered, the SDK will prioritize the network URL that you want to use.
message.setLargeImageDownloadUrl("url");
message.setFileDownloadUrl("url");
message.setThumbnailDownloadUrl("url");
ZIMMessageSendConfig config = new ZIMMessageSendConfig();
// Set message priority. 
config.priority = ZIMMessagePriority.LOW;
// Set up the configurations of the offline notifications.
ZIMPushConfig pushConfig = new ZIMPushConfig();
pushConfig.title = "Offline notification title";
pushConfig.content= "Offline notification content";
pushConfig.extendedData = "Extension info of the offline notification";
config.pushConfig = pushConfig;

zim.sendMessage(message, toConversationID, ZIMConversationType.PEER, config, new ZIMMessageSentFullCallback() {
    @Override
    public void onMessageSent(ZIMMessage message, ZIMError errorInfo) {
     // You can use this callback to monitor whether the message is ready to be sent. This callback will be thrown only if the message passes the local basic parameter verification, otherwise an error will be thrown through the onMessageSent callback.。                    
    }

    @Override
    public void onMessageAttached(ZIMMessage message){
    
    }

    @Override
    public void onMediaUploadingProgress(ZIMMediaMessage message, long currentFileSize, long totalFileSize, ) {
         // You can use this callback to monitor whether the message is sent successfully.              
    }
});

// Send rich media content in one-to-one conversation - Send a file:
ZIMFileMessage message = new ZIMFileMessage("/storage/emulated/0/Android/data/packagename/picture/xxx.zip");
// If a network URL is provided here, the SDK will pass through the path directly without processing it via the ZIM backend services. When both a network URL and a local path are provided, the SDK will prioritize using the network URL. 
message.setFileDownloadUrl("url");
ZIMMessageSendConfig config = new ZIMMessageSendConfig();
config.priority = ZIMMessagePriority.HIGH;
zim.sendMessage(message, conversationID, ZIMConversationType.PEER, config, new ZIMMessageSentFullCallback() {
    @Override
    public void onMessageSent(ZIMMessage message, ZIMError errorInfo) {
               
    }

    @Override
    public void onMessageAttached(ZIMMessage message){
    
    }

    @Override
    public void onMediaUploadingProgress(ZIMMediaMessage message, long currentFileSize, long totalFileSize) {
               
    }
});

// Send rich media content in one-to-one conversation - Send an audio:
ZIMAudioMessage message = new ZIMAudioMessage("/storage/emulated/0/Android/data/packagename/picture/xxx.mp3", 300); // 300 is only for example, the unit is second.

// If a network URL is provided here, the SDK will pass through the path directly without processing it via the ZIM backend services. When both a network URL and a local path are provided, the SDK will prioritize using the network URL. 
message.setFileDownloadUrl("url");
ZIMMessageSendConfig config = new ZIMMessageSendConfig();

ZIMMessageSendConfig config = new ZIMMessageSendConfig();
config.priority = ZIMMessagePriority.HIGH;
zim.sendMessage(message, conversationID, ZIMConversationType.PEER, config, new ZIMMessageSentFullCallback() {
    @Override
    public void onMessageSent(ZIMMessage message, ZIMError errorInfo) {
               
    }
    
    @Override
    public void onMessageAttached(ZIMMessage message){
    
    }

    @Override
    public void onMediaUploadingProgress(ZIMMediaMessage message, long currentFileSize, long totalFileSize) {
               
    }
});

// Send rich media content in one-to-one conversation - Send a video:
ZIMVideoMessage message = new ZIMVideoMessage("/storage/emulated/0/Android/data/packagename/picture/xxx.mp4", 300);//这里单位是秒

// 如果此处填了网络 URL，SDK 则会透传该路径，而不会经过 ZIM 后台服务处理，同时填入网络 URL 与本地路径，SDK 会优先认为用户想要使用网络 URL
message.setFileDownloadUrl("url");
message.videoFirstFrameDownloadUrl("url");
ZIMMessageSendConfig config = new ZIMMessageSendConfig();
config.priority = ZIMMessagePriority.HIGH;
zim.sendMessage(message, conversationID, ZIMConversationType.PEER, config, new ZIMMessageSentFullCallback() {
    @Override
    public void onMessageSent(ZIMMessage message, ZIMError errorInfo) {
               
    }
   
    @Override
    public void onMessageAttached(ZIMMessage message){
    
    }

    @Override
    public void onMediaUploadingProgress(ZIMMediaMessage message, long currentFileSize, long totalFileSize) {
               
    }
});

// Send rich media content in one-to-one conversation - Send an image:
ZIMImageMessage *imgMsg = [[ZIMImageMessage alloc] init];

// Fill in a UTF-8 local path (the path to the local picture is recommended)
// The following uses a temporary image path as an example:
imgMsg.fileLocalPath = @"/private/var/mobile/Containers/Data/Application/C142EFE6-9DEC-449D-89B7-BF99F2578F98/tmp/D1513E30-2641-440B-B897-48CD43BE1D04.jpeg";

// If a network URL is entered here, the SDK will pass through the path without ZIM background service processing. If both the network URL and the local path are entered, the SDK will prioritize the network URL that you want to use.
imgMsg.fileDownloadUrl = @"";

ZIMMessageSendConfig *sendConfig = [[ZIMMessageSendConfig alloc] init];
sendConfig.priority = 1;
        
ZIMMessageSendNotification *notification = [[ZIMMessageSendNotification alloc] init];
notification.onMessageAttached = ^(ZIMMessage * _Nonnull message) {
    // Implement your event handling logic before the message is sent. 
};
        
notification.onMediaUploadingProgress = ^(ZIMMediaMessage * _Nonnull message, unsigned long long currentFileSize, unsigned long long totalFileSize) {
    // You can listen for the callback to know the uploading progress of the rich media message you sent.
};

[[ZIM getInstance] sendMessage:imgMsg toConversationID:@"conversationID" conversationType:ZIMConversationTypePeer config:sendConfig notification:notification callback:^(ZIMMessage * _Nonnull message, ZIMError * _Nonnull errorInfo) {
        
}];

// Send rich media content in one-to-one conversation - Send an audio: 
// You need to provide the local path in UTF-8 format (it is recommended to use the path of the app's local audio), audio duration (in seconds). 
// Here, a local audio file path is used as an example.
ZIMAudioMessage audioMessage = [[ZIMAudioMessage alloc] initWithFileLocalPath:@"/private/var/mobile/Containers/Shared/AppGroup/D5144D14-3FE8-4C6C-8527-01F368B8E49E/File Provider Storage/IMG_0131.mp3" audioDuration:10];

// If a network URL is entered here, the SDK will pass through the path without ZIM background service processing. If both the network URL and the local path are entered, the SDK will prioritize the network URL that you want to use.
audioMessage.fileDownloadUrl = @"";

ZIMMessageSendConfig *sendConfig = [[ZIMMessageSendConfig alloc] init];
sendConfig.priority = ZIMMessagePriorityHigh;

ZIMMessageSendNotification *notification = [[ZIMMessageSendNotification alloc] init];
notification.onMessageAttached = ^(ZIMMessage * _Nonnull message) {
    // Implement your event handling logic before the message is sent. 
};
        
notification.onMediaUploadingProgress = ^(ZIMMediaMessage * _Nonnull message, unsigned long long currentFileSize, unsigned long long totalFileSize) {
    // You can listen for the callback to know the uploading progress of the rich media message you sent.
};

[[ZIM getInstance] sendMessage:audioMessage toConversationID:@"conversationID" conversationType:ZIMConversationTypePeer config:sendConfig notification:notification callback:^(ZIMMessage * _Nonnull message, ZIMError * _Nonnull errorInfo) {
        
}];

// Send rich media content in one-to-one conversation - Send an video: 
ZIMVideoMessage *videoMessage = [[ZIMVideoMessage alloc] init];

// You need to provide the local path in UTF-8 format.
// Here, a local video file path is used as an example.
videoMessage.fileLocalPath = @"/var/mobile/Containers/Data/Application/C142EFE6-9DEC-449D-89B7-BF99F2578F98/Documents/22-08-31-10:23:49.mp4";

// If a network URL is entered here, the SDK will pass through the path without ZIM background service processing. If both the network URL and the local path are entered, the SDK will prioritize the network URL that you want to use.
videoMessage.fileDownloadUrl = @"";

ZIMMessageSendConfig *sendConfig = [[ZIMMessageSendConfig alloc] init];
sendConfig.priority = ZIMMessagePriorityHigh;

ZIMMessageSendNotification *notification = [[ZIMMessageSendNotification alloc] init];
notification.onMessageAttached = ^(ZIMMessage * _Nonnull message) {
    // Implement your event handling logic before the message is sent. 
};
        
notification.onMediaUploadingProgress = ^(ZIMMediaMessage * _Nonnull message, unsigned long long currentFileSize, unsigned long long totalFileSize) {
    // You can listen for the callback to know the uploading progress of the rich media message you sent.
};

[[ZIM getInstance] sendMessage:videoMessage toConversationID:@"conversationID" conversationType:ZIMConversationTypePeer config:sendConfig notification:notification callback:^(ZIMMessage * _Nonnull message, ZIMError * _Nonnull errorInfo) {
        
}];

// Send rich media content in one-to-one conversation - Send a file: 
ZIMFileMessage *fileMsg = [[ZIMFileMessage alloc] init];

// You need to provide the local path in UTF-8 format.
fileMsg.fileLocalPath = @"/private/var/mobile/Containers/Shared/AppGroup/D5144D14-3FE8-4C6C-8527-01F368B8E49E/File Provider Storage/IMG_0131.HEIC";

// If a network URL is entered here, the SDK will pass through the path without ZIM background service processing. If both the network URL and the local path are entered, the SDK will prioritize the network URL that you want to use.
fileMsg.fileDownloadUrl = @"";


ZIMMessageSendConfig *sendConfig = [[ZIMMessageSendConfig alloc] init];
sendConfig.priority = ZIMMessagePriorityHigh;

ZIMMessageSendNotification *notification = [[ZIMMessageSendNotification alloc] init];
notification.onMessageAttached = ^(ZIMMessage * _Nonnull message) {
    // Implement your event handling logic before the message is sent. 
};
        
notification.onMediaUploadingProgress = ^(ZIMMediaMessage * _Nonnull message, unsigned long long currentFileSize, unsigned long long totalFileSize) {
    // You can listen for the callback to know the uploading progress of the rich media message you sent.
};

[[ZIM getInstance] sendMessage:fileMsg toConversationID:@"conversationID" conversationType:ZIMConversationTypePeer config:sendConfig notification:notification callback:^(ZIMMessage * _Nonnull message, ZIMError * _Nonnull errorInfo) {
        
}];

// Send rich media content in one-to-one conversation - Send an image:
zim::ZIMMediaMessage *message = nullptr;
auto imageMessage = zim::ZIMImageMessage();

zim::ZIMMessageSendConfig sendConfig;
zim::ZIMPushConfig pushConfig;
// Offline notification title
pushConfig.title = "win_push_title";
// Offline notification content
pushConfig.content = "win_push_content";
// Extension info of the offline notification
pushConfig.extendedData = "win_push_extended_data";
sendConfig.priority = zim::ZIM_MESSAGE_PRIORITY_MEDIUM;
// Assign a value when offline push is required; if not needed, it can be assigned as nullptr.
sendConfig.pushConfig = &pushConfig;

// Provide the local path in UTF-8 format. 
imageMessage.fileLocalPath = "D:\\image\\img.jpg";
// If a network URL is provided here, the SDK will pass through the path directly without processing it via the ZIM backend services. When both a network URL and a local path are provided, the SDK will prioritize using the network URL. 
imageMessage.fileDownloadUrl = "";
imageMessage.largeImageDownloadUrl = "";
imageMessage.thumbnailDownloadUrl = "";

message = &imageMessage;

auto notification = std::make_shared<zim::ZIMMessageSendNotification>(
            [=](const std::shared_ptr<zim::ZIMMessage> &message) { 
                // Implement your event handling logic before the message is sent. 
            },
            [=](const std::shared_ptr<zim::ZIMMediaMessage> &message,
                unsigned long long currentFileSize,
                unsigned long long totalFileSize) { 
                    // You can listen for the callback to know the uploading progress of the rich media message you sent.
            });

zim_->sendMessage(message, receiver_id, zim::ZIMConversationType::ZIM_CONVERSATION_TYPE_PEER,
    sendConfig,notification,
    [=](const std::shared_ptr<zim::ZIMMessage> &message, const zim::ZIMError &errorInfo) {
        
    });

// Send rich media content in one-to-one conversation - Send a file:
zim::ZIMMediaMessage *message = nullptr;
auto fileMessage = zim::ZIMFileMessage();

zim::ZIMMessageSendConfig sendConfig;
zim::ZIMPushConfig pushConfig;
// Offline notification title
pushConfig.title = "win_push_title";
// Offline notification content
pushConfig.content = "win_push_content";
// Extension info of the offline notification
pushConfig.extendedData = "win_push_extended_data";

sendConfig.priority = zim::ZIM_MESSAGE_PRIORITY_MEDIUM;
// Assign a value when offline push is required; if not needed, it can be assigned as nullptr.
sendConfig.pushConfig = &pushConfig;

// Provide the local path in UTF-8 format. 
fileMessage.fileLocalPath = "D:\\file\\files.zip";
// If a network URL is provided here, the SDK will pass through the path directly without processing it via the ZIM backend services. When both a network URL and a local path are provided, the SDK will prioritize using the network URL. 
fileMessage.fileDownloadUrl = "";

message = &fileMessage;

auto notification = std::make_shared<zim::ZIMMessageSendNotification>(
            [=](const std::shared_ptr<zim::ZIMMessage> &message) { 
                // Implement your event handling logic before the message is sent. 
            },
            [=](const std::shared_ptr<zim::ZIMMediaMessage> &message,
                unsigned long long currentFileSize,
                unsigned long long totalFileSize) { 
                    // You can listen for the callback to know the uploading progress of the rich media message you sent.
            });

zim_->sendMessage(message, receiver_id, zim::ZIMConversationType::ZIM_CONVERSATION_TYPE_PEER,
    sendConfig,,notification,
    [=](const std::shared_ptr<zim::ZIMMessage> &message, const zim::ZIMError &errorInfo) {
        auto media_message = std::static_pointer_cast<zim::ZIMFileMessage>(message);

        int code = errorInfo.code;
    });

// Send rich media content in one-to-one conversation - Send an audio:
zim::ZIMMediaMessage *message = nullptr;
auto audioMessage = zim::ZIMAudioMessage();

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

// Offline notification title
pushConfig.title = "win_push_title";
// Offline notification content
pushConfig.content = "win_push_content";
// Extension info of the offline notification
pushConfig.extendedData = "win_push_extended_data";

sendConfig.priority = zim::ZIM_MESSAGE_PRIORITY_MEDIUM;
// Assign a value when offline push is required; if not needed, it can be assigned as nullptr.
sendConfig.pushConfig = &pushConfig;

// Provide the local path in UTF-8 format. 
audioMessage.fileLocalPath = "D:\\audio\\audio.mp3";
// If a network URL is provided here, the SDK will pass through the path directly without processing it via the ZIM backend services. When both a network URL and a local path are provided, the SDK will prioritize using the network URL. 
audioMessage.fileDownloadUrl = "";
// Audio duration in seconds
audioMessage.audioDuration = 15;

message = &audioMessage;

auto notification = std::make_shared<zim::ZIMMessageSendNotification>(
            [=](const std::shared_ptr<zim::ZIMMessage> &message) { 
                // Implement your event handling logic before the message is sent. 
            },
            [=](const std::shared_ptr<zim::ZIMMediaMessage> &message,
                unsigned long long currentFileSize,
                unsigned long long totalFileSize) { 
                    // You can listen for the callback to know the uploading progress of the rich media message you sent.
            });

zim_->sendMessage(message, receiver_id, zim::ZIMConversationType::ZIM_CONVERSATION_TYPE_PEER,
    sendConfig,notification ,
    [=](const std::shared_ptr<zim::ZIMMessage> &message, const zim::ZIMError &errorInfo) {
        auto media_message = std::static_pointer_cast<zim::ZIMAudioMessage>(message);

        int code = errorInfo.code;
    });

// Send rich media content in one-to-one conversation - Send a video:
zim::ZIMMediaMessage *message = nullptr;
auto videoMessage = zim::ZIMVideoMessage();

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

// Offline notification title
pushConfig.title = "win_push_title";
// Offline notification content
pushConfig.content = "win_push_content";
// Extension info of the offline notification
pushConfig.extendedData = "win_push_extended_data";

sendConfig.priority = zim::ZIM_MESSAGE_PRIORITY_MEDIUM;
// Assign a value when offline push is required; if not needed, it can be assigned as nullptr.
sendConfig.pushConfig = &pushConfig;

// Provide the local path in UTF-8 format. 
videoMessage.fileLocalPath = "D:\\file\\video.mp4";
// If a network URL is provided here, the SDK will pass through the path directly without processing it via the ZIM backend services. When both a network URL and a local path are provided, the SDK will prioritize using the network URL. 
videoMessage.fileDownloadUrl = "";
videoMessage.videoFirstFrameDownloadUrl = "";
// Video duration in seconds
videoMessage.videoDuration = 100;

message = &videoMessage;
auto notification = std::make_shared<zim::ZIMMessageSendNotification>(
            [=](const std::shared_ptr<zim::ZIMMessage> &message) { 
                // Implement your event handling logic before the message is sent. 
            },
            [=](const std::shared_ptr<zim::ZIMMediaMessage> &message,
                unsigned long long currentFileSize,
                unsigned long long totalFileSize) { 
                    // You can listen for the callback to know the uploading progress of the rich media message you sent.
            });

zim_->sendMessage(message, receiver_id, zim::ZIMConversationType::ZIM_CONVERSATION_TYPE_PEER,
    sendConfig,notification,
    [=](const std::shared_ptr<zim::ZIMMessage> &message, const zim::ZIMError &errorInfo) {
        auto media_message = std::static_pointer_cast<zim::ZIMVideoMessage>(message);

        int code = errorInfo.code;
    });

// Send rich media content in one-to-one conversation - Send an image:
ZIMImageMessage imageMessage = ZIMImageMessage('xxx/xxx.jpeg');
ZIMMessageSendConfig sendConfig = ZIMMessageSendConfig();
ZIMMessageSendNotification notification = ZIMMessageSendNotification(onMessageAttached: (message){
    // Implement your event handling logic after sending the message here. 
},onMediaUploadingProgress: (message,currentFileSize,totalFileSize){
    // You can listen for the callback to know the uploading progress of the rich media message you sent.
});
ZIM.getInstance()!.sendMessage(
    imageMessage,
    'toConversationID',
    ZIMConversationType.peer,
    sendConfig, notification).then((value) => {
        // Sent successfully
    }).catchError((onError){
        // Failed to send
    });

// Send rich media content in one-to-one conversation - Send a video:
ZIMVideoMessage videoMessage = ZIMVideoMessage('xxx/xxx.mov');
ZIMMessageSendConfig sendConfig = ZIMMessageSendConfig();
ZIMMessageSendNotification notification = ZIMMessageSendNotification(onMessageAttached: (message){
    // Implement your event handling logic after sending the message here. 
},onMediaUploadingProgress: (message,currentFileSize,totalFileSize){
    // You can listen for the callback to know the uploading progress of the rich media message you sent.
});
ZIM
    .getInstance()
    !.sendMessage(
        videoMessage,
        'toConversationID',
        ZIMConversationType.peer,
        sendConfig, notification)
    .then((value) => {
        // Sent successfully
    })
    .catchError((onError) {
        // Failed to send
    });

// Send rich media content in one-to-one conversation - Send an audio:
ZIMAudioMessage audioMessage  = ZIMAudioMessage('xxx/xxx.mp3');
ZIMMessageSendConfig sendConfig = ZIMMessageSendConfig();
ZIMMessageSendNotification notification = ZIMMessageSendNotification(onMessageAttached: (message){
    // Implement your event handling logic after sending the message here. 
},onMediaUploadingProgress: (message,currentFileSize,totalFileSize){
    // You can listen for the callback to know the uploading progress of the rich media message you sent.
});
ZIM
    .getInstance()
    !.sendMessage(
        audioMessage,
        'toConversationID',
        ZIMConversationType.peer,
        ZIMMessageSendConfig(), notification)
    .then((value) => {
        // Sent successfully
    })
    .catchError((onError) {
        // Failed to send
    });

// Send rich media content in one-to-one conversation - Send a file:
ZIMFileMessage fileMessage = ZIMFileMessage('xxx/xxx.txt');
ZIMMessageSendConfig sendConfig = ZIMMessageSendConfig();
ZIMMessageSendNotification notification = ZIMMessageSendNotification(onMessageAttached: (message){
    // Implement your event handling logic after sending the message here. 
},onMediaUploadingProgress: (message,currentFileSize,totalFileSize){
    // You can listen for the callback to know the uploading progress of the rich media message you sent.
});
ZIM
    .getInstance()
    !.sendMessage(
        fileMessage,
        'toConversationID',
        ZIMConversationType.peer,
        ZIMMessageSendConfig(), notification)
    .then((value) => {
        // Sent successfully
    })
    .catchError((onError) {
        // Failed to send
    });

// Receive rich media content in one-to-one conversation - Receive images:
@Override
public void onPeerMessageReceived(ZIM zim, ArrayList<ZIMMessage> messageList, ZIMMessageReceivedInfo info, String fromUserID) {
    super.onPeerMessageReceived(zim, messageList, info, fromUserID);
    
    ZIMMediaDownloadConfig config = new ZIMMediaDownloadConfig();

    for (ZIMMessage message : messageList) {
        // You can tell by the Type which kind of message you are receiving. 
        if (message.getType() == ZIMMessageType.IMAGE) {
            // Receive the image
            ZIMImageMessage imageMessage = (ZIMImageMessage) message;
            zim.downloadMediaFile(imageMessage, ZIMMediaFileType.ORIGINAL_FILE, config, new ZIMMediaDownloadedCallback() {

                @Override
                public void onMediaDownloaded(ZIMMessage message, ZIMError errorInfo) {
                    // The callback for download completion.
                }

                @Override
                public void onMediaDownloadingProgress(ZIMMessage message, long currentFileSize, long totalFileSize) {
                    // The download progress 
                }
            });
        } else if (message.getType() == ZIMMessageType.VIDEO) {
            // Receive the video
            ZIMVideoMessage videoMessage = (ZIMVideoMessage) message;
        } else if (message.getType() == ZIMMessageType.AUDIO) {
            // Receive the audio
            ZIMAudioMessage audioMessage = (ZIMAudioMessage) message;
        } else if (message.getType() == ZIMMessageType.FILE) {
            // Receive the file
            ZIMFileMessage fileMessage = (ZIMFileMessage) message;
        }
    }
}

// Receive rich media content in one-to-one conversation - Receive images 
- (void)peerMessageReceived:(NSArray<ZIMMessage *> *)messageList
                info:(ZIMMessageReceivedInfo *)info
                fromUserID:(NSString *)fromUserID{
    
    ZIMMediaDownloadConfig *config = [[ZIMMediaDownloadConfig alloc] init];

    for (ZIMMessage *msg in reverseMsgList) {

        // You can tell by the Type which kind of message you are receiving. 
        switch (msg.type) {
            case ZIMMessageTypeImage:{
                ZIMImageMessage *imageMsg = (ZIMImageMessage *)msg;
                [[ZIM getInstance] downloadMediaFileWithMessage:imageMsg fileType:ZIMMediaFileTypeOriginalFile config:config
                    progress:^(ZIMMessage * _Nonnull message, unsigned long long currentFileSize, unsigned long long totalFileSize) {
                            
                            } callback:^(ZIMMessage * _Nonnull message, ZIMError * _Nonnull errorInfo) {
                                
                }];
                break;
            }
            case ZIMMessageTypeVideo:{
                ZIMVideoMessage *videoMsg = (ZIMVideoMessage *)msg;
                break;
            }
            case ZIMMessageTypeAudio:{
                ZIMAudioMessage *audioMsg = (ZIMAudioMessage *)msg;
                break;
            }
            case ZIMMessageTypeFile:{
                ZIMFileMessage *fileMsg = (ZIMFileMessage *)msg;
                break;
            }
            default:
                break;
        }
        
    }
}

// Send a signaling message to a user
String userID = "xxxx";

ZIMCommandMessage zimCustomMessage = new ZIMCommandMessage();
zimCustomMessage.message = new byte[]{0x1,0x2,0x1,0x2};

ZIMMessageSendConfig config = new ZIMMessageSendConfig();
// Set message priority.
config.priority = ZIMMessagePriority.LOW;
// Configure for offline notification
// For a room conversation, offline notification is not supported. To use it, contact ZEGOCLOUD Technical Support to enable the feature first.
ZIMPushConfig pushConfig = new ZIMPushConfig();
pushConfig.title = "Offline notification title";
pushConfig.content= "Offline notification content";
pushConfig.extendedData = "Extra information for the offline notification";
config.pushConfig = pushConfig;

// Send a one-to-one message.
ZIMConversationType type = ZIMConversationType.Peer;

// Send a group message.
// ZIMConversationType type = ZIMConversationType.Gourp;

// Send a in-room message.
// ZIMConversationType type = ZIMConversationType.Room;

zim.sendMessage(zimCustomMessage, toConversationID, type, config, new ZIMMessageSentFullCallback() {
    @Override
    public void onMessageAttached(ZIMMessage zimMessage) {
        // You can use this callback to monitor whether the message is ready to be sent. This callback will be thrown only if the message passes the local basic parameter verification, otherwise an error will be thrown through the onMessageSent callback.
    }

    @Override
    public void onMessageSent(ZIMMessage zimMessage, ZIMError error) {
        // You can listen for the callback to know whether the message is sent successfully.
    }
});

// Send signaling messages to a specified user.
NSData *anyData = [[NSData alloc] init];
NSString *toUserID = @"toUserID";
ZIMCommandMessage * cmdMsg = [[ZIMCommandMessage alloc] initWithMessage:anyData];
ZIMMessageSendConfig *sendConfig = [[ZIMMessageSendConfig alloc] init];
sendConfig.priority = ZIMMessagePriorityMedium;

[self.zim sendMessage:cmdMsg toUserID:toUserID conversationType:type config:config notification:notification callback:^((ZIMMessage * _Nonnull message, ZIMError * _Nonnull errorInfo)) {
    // You can listen for this callback on the results of the message sending.
}];

// Receive signaling messages.
zim.setEventHandler(new ZIMEventHandler() {
    @Override
    public void onPeerMessageReceived(ZIM zim, ArrayList<ZIMMessage> messageList, ZIMMessageReceivedInfo info, String fromUserID) {
        // Callback on the command message received.
        for (ZIMMessage zimMessage : messageList) {
            if (zimMessage instanceof ZIMCommandMessage) {
                ZIMCommandMessage zimCommandMessage = (ZIMCommandMessage) zimMessage;
                
           }    
        }
    }
});

// Receive signaling messages.
- (void)zim:(ZIM *)zim peerMessageReceived:(NSArray<ZIMMessage *> *)messageList info:(ZIMMessageReceivedInfo *)info fromUserID:(NSString *)fromUserID {
    if (zim != self.zim) {
        return;
    }
    for (ZIMMessage *msg in messageList) {
        if(msg.type == ZIMMessageTypeCommand){
            ZIMCommandMessage *cmdMsg = (ZIMCommandMessage *)msg;
            NSData *receivedData = cmdMsg.message;
        }
    }
}