V2TIMManager
and V2TIMMessageManager (Android)
/ V2TIMManager(Message) (iOS and macOS)
.V2TIMMessage
type.V2TIMMessage
can contain V2TIMElem
sub-types to indicate different types of messages.sendMessage
API (Android / iOS and macOS / Windows) is one of the core APIs for message sending. It supports sending messages of all types.sendMessage
.// V2TIMMessageManagerpublic abstract String sendMessage(V2TIMMessage message,String receiver,String groupID,int priority,boolean onlineUserOnly,V2TIMOfflinePushInfo offlinePushInfo,V2TIMSendCallback<V2TIMMessage> callback);
Parameter | Definition | Valid for One-to-One Chat | Valid for Group Chat | Description |
message | Message object | YES | YES | It needs to be created through the createXxxMessage API. Here, Xxx indicates the specific type. |
receiver | userID of the one-to-one message receiver | YES | NO | Just specify receiver for sending one-to-one chat messages. |
groupID | groupID of the group chat | NO | YES | Just specify groupID for sending group messages. |
priority | Message priority | NO | YES | Set a higher priority for important messages (such as red packets and gifts) and a lower priority for frequent and unimportant messages (such as likes). |
onlineUserOnly | Whether the message can be received by online users only | YES | YES | If it is set to true , the message cannot be pulled when a receiver pulls historical messages. This is often used to implement weak prompts, such as "The other party is typing..." and unimportant prompts in a group. |
offlinePushInfo | Offline push message | YES | YES | The title and content carried when a message is pushed offline. |
callback | Callback for message sending | YES | YES | Includes the callback for upload progress, callback for successful sending, and callback for failed sending. |
// V2TIMManager+Message.h- (NSString *)sendMessage:(V2TIMMessage *)messagereceiver:(NSString *)receivergroupID:(NSString *)groupIDpriority:(V2TIMMessagePriority)priorityonlineUserOnly:(BOOL)onlineUserOnlyofflinePushInfo:(V2TIMOfflinePushInfo *)offlinePushInfoprogress:(V2TIMProgress)progresssucc:(V2TIMSucc)succfail:(V2TIMFail)fail;
Parameter | Definition | Valid for One-to-One Chat | Valid for Group Chat | Description |
message | Message object | YES | YES | It needs to be created through the `createXxxMessage` API. Here, `Xxx` indicates the specific type. |
receiver | `userID` of the one-to-one message receiver | YES | NO | Just specify `receiver` for sending one-to-one messages. |
groupID | `groupID` of the group chat | NO | YES | Just specify `groupID` for sending group messages. |
priority | Message priority | NO | YES | Set a higher priority for important messages (such as red packets and gifts) and a lower priority for frequent and unimportant messages (such as likes). |
onlineUserOnly | Whether the message can be received by online users only | YES | YES | If it is set to `true`, the message cannot be pulled when a receiver pulls historical messages. This is often used to implement weak prompts, such as "The other party is typing..." and unimportant prompts in a group. |
offlinePushInfo | Offline push message | YES | YES | The title and content carried when a message is pushed offline. |
progress | File upload progress | YES | YES | File upload progress. It applies to sending messages that contain rich media such as images, audios, videos, and files. There is no callback for pure text, emoji, and location messages. |
succ | Callback for successful message sending | YES | YES | - |
fail | Callback for failed message sending | YES | YES | Callback failure error code and error description. |
// V2TIMMessageManagervirtual V2TIMString SendMessage(V2TIMMessage& message,const V2TIMString& receiver,const V2TIMString& groupID,V2TIMMessagePriority priority,bool onlineUserOnly,const V2TIMOfflinePushInfo& offlinePushInfo,V2TIMSendCallback* callback);
Parameter | Definition | Valid for One-to-One Chat | Valid for Group Chat | Description |
message | Message object | YES | YES | It needs to be created through the createXxxMessage API. Here, Xxx indicates the specific type. |
receiver | userID of the one-to-one message receiver | YES | NO | Just specify receiver for sending one-to-one chat messages. |
groupID | groupID of the group chat | NO | YES | Just specify groupID for sending group messages. |
priority | Message priority | NO | YES | Set a higher priority for important messages (such as red packets and gifts) and a lower priority for frequent and unimportant messages (such as likes). |
onlineUserOnly | Whether the message can be received by online users only | YES | YES | If it is set to true , the message cannot be pulled when a receiver pulls historical messages. This is often used to implement weak prompts, such as "The other party is typing..." and unimportant prompts in a group. |
offlinePushInfo | Offline push message | YES | YES | The title and content carried when a message is pushed offline. |
callback | Callback for message sending | YES | YES | Includes the callback for upload progress, callback for successful sending, and callback for failed sending. |
groupID
and receiver
are set, targeted group messages are sent to receiver
. For more information, see Targeted Group Message.sendMessage
mentioned above.sendC2CTextMessage
API (Android / iOS and macOS / Windows) to send a one-to-one text message simply by passing in the message content and receiver's userID
.// `msgID` returned by the API for on-demand useString msgID = V2TIMManager.getInstance().sendC2CTextMessage("One-to-one text message", "receiver_userID", new V2TIMValueCallback<V2TIMMessage>() {@Overridepublic void onSuccess(V2TIMMessage message) {// The one-to-one text message sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the one-to-one text message}});
// `msgID` returned by the API for on-demand useNSString *msgID = [[V2TIMManager sharedInstance] sendC2CTextMessage:@"One-to-one text message"to:@"receiver_userID"succ:^{// The one-to-one text message sent successfully} fail:^(int code, NSString *msg) {// Failed to send the one-to-one text message}];
class SendCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendCallback() = default;~SendCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallback progress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};auto callback = new SendCallback{};callback->SetCallback([=](const V2TIMMessage& message) {// The one-to-one text message sent successfullydelete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the one-to-one text messagedelete callback;},[=](uint32_t progress) {// The progress is not called back for the text message.});// `msgID` returned by the API for on-demand useV2TIMString msgID =V2TIMManager::GetInstance()->SendC2CTextMessage("One-to-one text message", "receiver_userID", callback);
createTextMessage
(Android / iOS and macOS / Windows) to create a text message.sendMessage
(Android / iOS and macOS / Windows) to send the message.// Create a text messageV2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createTextMessage("content");// Send the messageV2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {@Overridepublic void onProgress(int progress) {// The progress is not called back for the text message.}@Overridepublic void onSuccess(V2TIMMessage message) {// The text message sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the text message}});
// Create a text messageV2TIMMessage *message = [[V2TIMManager sharedInstance] createTextMessage:@"content"];// Send the message[V2TIMManager.sharedInstance sendMessage:messagereceiver:@"userID"groupID:nilpriority:V2TIM_PRIORITY_NORMALonlineUserOnly:NOofflinePushInfo:nilprogress:nilsucc:^{// The text message sent successfully}fail:^(int code, NSString *desc) {// Failed to send the text message}];
class SendCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendCallback() = default;~SendCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallback progress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};// Create a text messageV2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateTextMessage("One-to-one text message");// Send the messageauto callback = new SendCallback{};callback->SetCallback([=](const V2TIMMessage& message) {// The progress is not called back for the text message.delete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the text messagedelete callback;},[=](uint32_t progress) {// The progress is not called back for the text message.});V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(v2TIMMessage, "userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);
sendGroupTextMessage
(Android / iOS and macOS / Windows) to send a group message simply by passing in the message content, groupID
of the group chat, and message priority.V2TIMMessagePriority
definition.// `msgID` returned by the API for on-demand useString msgID = V2TIMManager.getInstance().sendGroupTextMessage("Group text message", "groupID", V2TIMMessage.V2TIM_PRIORITY_NORMAL, new V2TIMValueCallback<V2TIMMessage>() {@Overridepublic void onSuccess(V2TIMMessage message) {// The group text message sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the group text message}});
// `msgID` returned by the API for on-demand useNSString *msgID = [[V2TIMManager sharedInstance] sendGroupTextMessage:@"Group text message"to:@"groupID" // `groupID` of the group chatpriority:V2TIM_PRIORITY_NORMAL // Message prioritysucc:^{// The group text message sent successfully} fail:^(int code, NSString *msg) {// Failed to send the group text message}];
class SendGroupTextMessageCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendGroupTextMessageCallback() = default;~SendGroupTextMessageCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallbackprogress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};auto callback = new SendGroupTextMessageCallback;callback->SetCallback([=](const V2TIMMessage& message) {// The group text message sent successfullydelete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the group text messagedelete callback;},[=](uint32_t progress) {// The progress is not called back for the text message.});// `msgID` returned by the API for on-demand useV2TIMString msgID = V2TIMManager::GetInstance()->SendGroupTextMessage("Group text message", "groupID", V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, callback);
createTextMessage
(Android / iOS and macOS / Windows) to create a text message.sendMessage
(Android / iOS and macOS / Windows) to send the message.// Create a text messageV2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createTextMessage("content");// Send the messageV2TIMManager.getMessageManager().sendMessage(v2TIMMessage, null, "receiver_groupID", V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {@Overridepublic void onProgress(int progress) {// The progress is not called back for the text message.}@Overridepublic void onSuccess(V2TIMMessage message) {// The group text message sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the group text message}});
// Create a text messageV2TIMMessage *message = [[V2TIMManager sharedInstance] createTextMessage:content];// Send the message[V2TIMManager.sharedInstance sendMessage:messagereceiver:nilgroupID:@"receiver_groupID" // `groupID` of the group chatpriority:V2TIM_PRIORITY_NORMAL // Message priorityonlineUserOnly:NO // For online users onlyofflinePushInfo:nil // Custom information for offline pushprogress:nilsucc:^{// The text message sent successfully}fail:^(int code, NSString *desc) {// Failed to send the text message}];
class SendCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendCallback() = default;~SendCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallback progress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};// Create a text messageV2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateTextMessage("Group text message");// Send the messageauto callback = new SendCallback{};callback->SetCallback([=](const V2TIMMessage& message) {// The group text message sent successfullydelete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the group text messagedelete callback;},[=](uint32_t progress) {// The progress is not called back for the text message.});V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(v2TIMMessage, {}, "receiver_groupID", V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);
sendMessage
mentioned above (Android / iOS and macOS / Windows), which supports more sending parameters (such as priority and offline push message) than the ordinary API.sendC2CCustomMessage
(Android / iOS and macOS / Windows) to send a custom one-to-one message simply by passing in the binary content and receiver's userID
.String msgID = V2TIMManager.getInstance().sendC2CCustomMessage("Custom one-to-one message".getBytes(), "receiver_userID", new V2TIMValueCallback<V2TIMMessage>() {@Overridepublic void onSuccess(V2TIMMessage message) {// The custom one-to-one message sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the custom one-to-one message}});
NSData *customData = [@"Custom one-to-one message" dataUsingEncoding:NSUTF8StringEncoding];NSString *msgID = [[V2TIMManager sharedInstance] sendC2CCustomMessage:customDatato:@"receiver_userID" // Receiver's `userID`succ:^{// The custom one-to-one message sent successfully}fail:^(int code, NSString *msg) {// Failed to send the custom one-to-one message}];
class SendC2CCustomMessageCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendC2CCustomMessageCallback() = default;~SendC2CCustomMessageCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallback progress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};auto callback = new SendCallback{};callback->SetCallback([=](const V2TIMMessage& message) {// The custom one-to-one message sent successfullydelete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the custom one-to-one messagedelete callback;},[=](uint32_t progress) {// The progress is not called back for the custom message.});V2TIMString str = u8"Custom one-to-one message";V2TIMBuffer customData = {reinterpret_cast<const uint8_t*>(str.CString()), str.Size()};V2TIMString msgID = V2TIMManager::GetInstance()->SendC2CCustomMessage(customData, "receiver_userID", callback);
createCustomMessage
(Android / iOS and macOS / Windows) to create a custom message.sendMessage
(Android / iOS and macOS / Windows) to send the message.// Create a custom messageV2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createCustomMessage("Custom one-to-one message".getBytes());// Send the messageV2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {@Overridepublic void onProgress(int progress) {// The progress is not called back for the custom message.}@Overridepublic void onSuccess(V2TIMMessage message) {// The custom one-to-one message sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the custom one-to-one message}});
V2TIMMessage *message = [[V2TIMManager sharedInstance] createCustomMessage:data];[[V2TIMManager sharedInstance] sendMessage:messagereceiver:@"receiver_userID" // Receiver's `userID`groupID:nilpriority:V2TIM_PRIORITY_DEFAULT // Message priorityonlineUserOnly:NOofflinePushInfo:nilprogress:nilsucc:^{// The custom one-to-one message sent successfully} fail:^(int code, NSString *desc) {// Failed to send the custom one-to-one message}];
class SendCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendCallback() = default;~SendCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallback progress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};// Create a custom messageV2TIMString str = u8"Custom one-to-one message";V2TIMBuffer customData = {reinterpret_cast<const uint8_t*>(str.CString()), str.Size()};V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateCustomMessage(customData);// Send the messageauto callback = new SendCallback{};callback->SetCallback([=](const V2TIMMessage& message) {// The custom one-to-one message sent successfullydelete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the custom one-to-one messagedelete callback;},[=](uint32_t progress) {// The progress is not called back for the custom message.});V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);
sendGroupCustomMessage
(Android / iOS and macOS / Windows) to send a custom group message simply by passing in the binary content, groupID
of the group chat, and priority.
For message priorities, see the V2TIMMessagePriority
definition.String msgID = V2TIMManager.getInstance().sendGroupCustomMessage("Custom group message".getBytes(), "groupID", V2TIMMessage.V2TIM_PRIORITY_NORMAL, new V2TIMValueCallback<V2TIMMessage>() {@Overridepublic void onSuccess(V2TIMMessage message) {// The custom group message sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the custom group message}});
NSData *customData = [@"Custom group message" dataUsingEncoding:NSUTF8StringEncoding];NSString *msgID = [[V2TIMManager sharedInstance] sendGroupCustomMessage:customDatato:@"receiver_groupID" // `groupID` of the group chatpriority:V2TIM_PRIORITY_HIGH // Message prioritysucc:^{// The custom group message sent successfully} fail:^(int code, NSString *msg) {// Failed to send the custom group message}];
class SendCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendCallback() = default;~SendCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallback progress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};auto callback = new SendCallback{};callback->SetCallback([=](const V2TIMMessage& message) {// The custom group message sent successfullydelete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the custom group messagedelete callback;},[=](uint32_t progress) {// The progress is not called back for the custom message.});V2TIMString str = u8"Custom group message";V2TIMBuffer customData = {reinterpret_cast<const uint8_t*>(str.CString()), str.Size()};V2TIMString msgID = V2TIMManager::GetInstance()->SendGroupCustomMessage(customData, "groupID", V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, callback);
createCustomMessage
(Android / iOS and macOS / Windows) to create a custom message.sendMessage
(Android / iOS and macOS / Windows) to send the message.// Create a custom messageV2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createCustomMessage("Custom group message".getBytes());// Send the messageV2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {@Overridepublic void onProgress(int progress) {// The progress is not called back for the custom message.}@Overridepublic void onSuccess(V2TIMMessage message) {// The custom group message sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the custom group message}});
V2TIMMessage *message = [[V2TIMManager sharedInstance] createCustomMessage:data];[[V2TIMManager sharedInstance] sendMessage:messagereceiver:nilgroupID:@"receiver_groupID" // `groupID` of the group chatpriority:V2TIM_PRIORITY_DEFAULT // Message priorityonlineUserOnly:NOofflinePushInfo:nilprogress:nilsucc:^{// The custom group message sent successfully} fail:^(int code, NSString *desc) {// Failed to send the custom group message}];
class SendCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendCallback() = default;~SendCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallback progress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};// Create a custom messageV2TIMString str = u8"Custom group message";V2TIMBuffer customData = {reinterpret_cast<const uint8_t*>(str.CString()), str.Size()};V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateCustomMessage(customData);// Send the messageauto callback = new SendCallback{};callback->SetCallback([=](const V2TIMMessage& message) {// The custom group message sent successfullydelete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the custom group messagedelete callback;},[=](uint32_t progress) {// The progress is not called back for the custom message.});V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(v2TIMMessage, {}, "receiver_groupID", V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);
createXxxMessage
to create a rich media message object of a specified type. Here, Xxx
indicates the specific message type.sendMessage
(Android / iOS and macOS / Windows) to send the message.// Create an image messageV2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createImageMessage("/sdcard/xxx");// Send the messageV2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {@Overridepublic void onProgress(int progress) {// Image upload progress in the range of [0, 100]}@Overridepublic void onSuccess(V2TIMMessage message) {// The image message sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the image message}});
// Get the local image pathNSString *imagePath = [[NSBundle mainBundle] pathForResource:@"test" ofType:@"png"];// Create an image messageV2TIMMessage *message = [[V2TIMManager sharedInstance] createImageMessage:imagePath];// Send the message[[V2TIMManager sharedInstance] sendMessage:messagereceiver:@"userID"groupID:nilpriority:V2TIM_PRIORITY_DEFAULTonlineUserOnly:NOofflinePushInfo:nilprogress:^(uint32_t progress) {// Image upload progress in the range of [0, 100]} succ:^{// The image message sent successfully} fail:^(int code, NSString *desc) {// Failed to send the image message}];
class SendCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendCallback() = default;~SendCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallback progress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};// Create an image messageV2TIMMessage v2TIMMessage =V2TIMManager::GetInstance()->GetMessageManager()->CreateImageMessage("./File/Xxx.jpg");// Send the messageauto callback = new SendCallback{};callback->SetCallback([=](const V2TIMMessage& message) {// The image message sent successfullydelete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the image messagedelete callback;},[=](uint32_t progress) {// Image upload progress in the range of [0, 100]});V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);
// Create an audio messageV2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createSoundMessage("/sdcard/xxx", 5);// Send the messageV2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {@Overridepublic void onProgress(int progress) {// Audio upload progress in the range of [0, 100]}@Overridepublic void onSuccess(V2TIMMessage message) {// The audio message sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the audio message}});
// Get the local audio file pathNSString *soundPath = [[NSBundle mainBundle] pathForResource:@"test" ofType:@"m4a"];// Get the audio duration (which is only used for UI display)AVURLAsset *asset = [AVURLAsset assetWithURL:[NSURL fileURLWithPath:soundPath]];CMTime time = [asset duration];int duration = ceil(time.value/time.timescale);// Create an audio messageV2TIMMessage *message = [[V2TIMManager sharedInstance] createSoundMessage:soundPath duration:duration];// Send the message[[V2TIMManager sharedInstance] sendMessage:messagereceiver:@"userID"groupID:nilpriority:V2TIM_PRIORITY_DEFAULTonlineUserOnly:NOofflinePushInfo:nilprogress:^(uint32_t progress) {// Audio upload progress in the range of [0, 100]} succ:^{// The audio message sent successfully} fail:^(int code, NSString *desc) {// Failed to send the audio message}];
class SendCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendCallback() = default;~SendCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallback progress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};// Create an audio messageV2TIMMessage v2TIMMessage =V2TIMManager::GetInstance()->GetMessageManager()->CreateSoundMessage("./File/Xxx.mp3", 5);// Send the messageauto callback = new SendCallback{};callback->SetCallback([=](const V2TIMMessage& message) {// The audio message sent successfullydelete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the audio messagedelete callback;},[=](uint32_t progress) {// Audio upload progress in the range of [0, 100]});V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);
// Create a video messageV2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createVideoMessage("/sdcard/xxx", "mp4", 10, "/sdcard/xxx");// Send the messageV2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {@Overridepublic void onProgress(int progress) {// Video upload progress in the range of [0, 100]}@Overridepublic void onSuccess(V2TIMMessage message) {// The video message sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the video message}});
// Get the local video file pathNSString *videoPath = [[NSBundle mainBundle] pathForResource:@"test" ofType:@"mp4"];// Get the local video thumbnail pathNSString *snapShotPath = [[NSBundle mainBundle] pathForResource:@"testpng" ofType:@""];// Get the video durationAVURLAsset *asset = [AVURLAsset assetWithURL:[NSURL fileURLWithPath:path]];CMTime time = [asset duration];int duration = ceil(time.value/time.timescale);// Create a video messageV2TIMMessage *message = [[V2TIMManager sharedInstance] createVideoMessage:videoPathtype:@"mp4"duration:durationsnapshotPath:snapShotPath];// Send the message[[V2TIMManager sharedInstance] sendMessage:messagereceiver:@"userID"groupID:nilpriority:V2TIM_PRIORITY_DEFAULTonlineUserOnly:NOofflinePushInfo:nilprogress:^(uint32_t progress) {// Video upload progress in the range of [0, 100]} succ:^{// The video message sent successfully} fail:^(int code, NSString *desc) {// Failed to send the video message}];
class SendCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendCallback() = default;~SendCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallback progress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};// Create a video messageV2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateVideoMessage("./File/Xxx.mp4", "mp4", 10, "./File/Xxx.jpg");// Send the messageauto callback = new SendCallback{};callback->SetCallback([=](const V2TIMMessage& message) {// The video message sent successfullydelete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the video messagedelete callback;},[=](uint32_t progress) {// Video upload progress in the range of [0, 100]});V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);
// Create a file messageV2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createFileMessage("/sdcard/xxx", "Filename");// Send the messageV2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {@Overridepublic void onProgress(int progress) {// File upload progress in the range of [0, 100]}@Overridepublic void onSuccess(V2TIMMessage message) {// The file message sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the file message}});
// Get the local file pathNSString *filePath = [[NSBundle mainBundle] pathForResource:@"test" ofType:@"mp4"];// Create a file messageV2TIMMessage *message = [[V2TIMManager sharedInstance] createFileMessage:filePath fileName:@"Send the file message"];// Send the message[[V2TIMManager sharedInstance] sendMessage:messagereceiver:@"userID"groupID:nilpriority:V2TIM_PRIORITY_DEFAULTonlineUserOnly:NOofflinePushInfo:nilprogress:^(uint32_t progress) {// File upload progress in the range of [0, 100]} succ:^{// The file message sent successfully} fail:^(int code, NSString *desc) {// Failed to send the file message}];
class SendCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendCallback() = default;~SendCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallback progress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};// Create a file messageV2TIMMessage v2TIMMessage =V2TIMManager::GetInstance()->GetMessageManager()->CreateFileMessage("./File/Xxx.zip", "Xxx");// Send the messageauto callback = new SendCallback{};callback->SetCallback([=](const V2TIMMessage& message) {// The file message sent successfullydelete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the file messagedelete callback;},[=](uint32_t progress) {// File upload progress in the range of [0, 100]});V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);
// Create a location messageV2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createLocationMessage("Geographical location", 0.5, 0.5);// Send the messageV2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {@Overridepublic void onProgress(int progress) {// The progress is not called back for the location message.}@Overridepublic void onSuccess(V2TIMMessage message) {// The location message sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the location message}});
// Create a location messageV2TIMMessage *message = [[V2TIMManager sharedInstance] createLocationMessage:@"Send the geographical location message" longitude:0.5 latitude:0.5];// Send the message[[V2TIMManager sharedInstance] sendMessage:messagereceiver:@"userID"groupID:nilpriority:V2TIM_PRIORITY_DEFAULTonlineUserOnly:NOofflinePushInfo:nilprogress:nilsucc:^{// The location message sent successfully} fail:^(int code, NSString *desc) {// Failed to send the location message}];
class SendCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendCallback() = default;~SendCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallback progress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};// Create a location messageV2TIMMessage v2TIMMessage =V2TIMManager::GetInstance()->GetMessageManager()->CreateLocationMessage("Location", 0.5, 0.5);// Send the messageauto callback = new SendCallback{};callback->SetCallback([=](const V2TIMMessage& message) {// The location message sent successfullydelete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the location messagedelete callback;},[=](uint32_t progress) {// The progress is not called back for the location message.});V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);
// Create an emoji messageV2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createFaceMessage(1, "tt00".getBytes());// Send the messageV2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {@Overridepublic void onProgress(int progress) {// The progress is not called back for the emoji message.}@Overridepublic void onSuccess(V2TIMMessage message) {// The emoji message sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the emoji message}});
// Create an emoji messageV2TIMMessage *message = [[V2TIMManager sharedInstance] createFaceMessage:1 data:[@"tt00" dataUsingEncoding:NSUTF8StringEncoding]];// Send the message[[V2TIMManager sharedInstance] sendMessage:messagereceiver:@"userID"groupID:nilpriority:V2TIM_PRIORITY_DEFAULTonlineUserOnly:NOofflinePushInfo:nilprogress:nilsucc:^{// The emoji message sent successfully} fail:^(int code, NSString *desc) {// Failed to send the emoji message}];
class SendCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendCallback() = default;~SendCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallback progress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};// Create an emoji messageV2TIMString str = u8"tt00";V2TIMBuffer data = {reinterpret_cast<const uint8_t*>(str.CString()), str.Size()};V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateFaceMessage(1, data);// Send the messageauto callback = new SendCallback{};callback->SetCallback([=](const V2TIMMessage& message) {// The emoji message sent successfullydelete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the emoji messagedelete callback;},[=](uint32_t progress) {// The progress is not called back for the emoji message.});V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);
appendElem
method (Android / iOS and macOS / Windows) through the element members of the Message object to add another element member.appendElem
only supports adding V2TIMTextElem
, V2TIMCustomElem
, V2TIMFaceElem
, and V2TIMLocationElem
after the original V2TIMElem
(which can be any type).
Therefore, "image + text", "video + text", and "location + text" are supported, but "image + image" and "text + image" are not supported.// Create a text messageV2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createTextMessage("test");// Create a custom elementV2TIMCustomElem customElem = new V2TIMCustomElem();customElem.setData("Custom message".getBytes());// Add the custom element to `message.textElem`v2TIMMessage.getTextElem().appendElem(customElem);// Send the messageV2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {@Overridepublic void onProgress(int progress) {// The progress is not called back.}@Overridepublic void onSuccess(V2TIMMessage message) {// The message containing multiple elements sent successfully}@Overridepublic void onError(int code, String desc) {// Failed to send the message containing multiple element objects}});
// Create a text messageV2TIMMessage *message = [[V2TIMManager sharedInstance] createTextMessage:@"text"];// Create a custom elementV2TIMCustomElem *customElem = [[V2TIMCustomElem alloc] init];customElem.data = [@"Custom message" dataUsingEncoding:NSUTF8StringEncoding];// Add the custom element to `message.textElem`[message.textElem appendElem:customElem];// Send the message[[V2TIMManager sharedInstance] sendMessage:messagereceiver:@"userID"groupID:nilpriority:V2TIM_PRIORITY_DEFAULTonlineUserOnly:NOofflinePushInfo:nilprogress:nilsucc:^{// The message containing multiple elements sent successfully} fail:^(int code, NSString *desc) {// Failed to send the message containing multiple element objects}];
class SendCallback final : public V2TIMSendCallback {public:using SuccessCallback = std::function<void(const V2TIMMessage&)>;using ErrorCallback = std::function<void(int, const V2TIMString&)>;using ProgressCallback = std::function<void(uint32_t)>;SendCallback() = default;~SendCallback() override = default;void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback,ProgressCallback progress_callback) {success_callback_ = std::move(success_callback);error_callback_ = std::move(error_callback);progress_callback_ = std::move(progress_callback);}void OnSuccess(const V2TIMMessage& message) override {if (success_callback_) {success_callback_(message);}}void OnError(int error_code, const V2TIMString& error_message) override {if (error_callback_) {error_callback_(error_code, error_message);}}void OnProgress(uint32_t progress) override {if (progress_callback_) {progress_callback_(progress);}}private:SuccessCallback success_callback_;ErrorCallback error_callback_;ProgressCallback progress_callback_;};// Create a text messageV2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateTextMessage("test");// Create a custom elementV2TIMCustomElem customElem;V2TIMString str = u8"tt00";customElem.data = {reinterpret_cast<const uint8_t*>(str.CString()), str.Size()};// Add the custom element to `message.textElem`v2TIMMessage.elemList.PushBack(&customElem);// Send the messageauto callback = new SendCallback{};callback->SetCallback([=](const V2TIMMessage& message) {// The message containing multiple elements sent successfullydelete callback;},[=](int error_code, const V2TIMString& error_message) {// Failed to send the message containing multiple element objectsdelete callback;},[=](uint32_t progress) {// The progress is not called back.});V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);
Feature | Limit Item | Description |
One-to-one/group message | Content length | A one-to-one or group message must be no longer than 12KB. |
| Sending frequency | One-to-one message: No limit for sending on the client; sending through the RESTful API is subject to the API frequency limit specified in the API documentation.
Group message: Up to 40 messages can be sent per second per group (regardless of the group type, and this limit applies to each group separately). |
| Receiving frequency | No limit for one-to-one messages or group messages. |
| Size of a single file | SDKs support a maximum file size of 100 MB for any single file to be sent. |
Was this page helpful?