メッセージ送信
Basic Feature Description
The method for sending a message is in the core classes
V2TIMManager
and V2TIMMessageManager (Android)
/ V2TIMManager(Message) (iOS and macOS)
.It supports sending text, custom, and rich media messages, and all of which belong to the
V2TIMMessage
type.V2TIMMessage
can contain V2TIMElem
sub-types to indicate different types of messages.API Description
The
sendMessage
API (Android / iOS and macOS / Windows) is one of the core APIs for message sending. It supports sending messages of all types.Note
The advanced message sending API mentioned below refers to
sendMessage
.The API is as described below:
API prototype:
// V2TIMMessageManagerpublic abstract String sendMessage(V2TIMMessage message,String receiver,String groupID,int priority,boolean onlineUserOnly,V2TIMOfflinePushInfo offlinePushInfo,V2TIMSendCallback<V2TIMMessage> callback);
Parameter description:
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. |
Method prototype:
// V2TIMManager+Message.h- (NSString *)sendMessage:(V2TIMMessage *)messagereceiver:(NSString *)receivergroupID:(NSString *)groupIDpriority:(V2TIMMessagePriority)priorityonlineUserOnly:(BOOL)onlineUserOnlyofflinePushInfo:(V2TIMOfflinePushInfo *)offlinePushInfoprogress:(V2TIMProgress)progresssucc:(V2TIMSucc)succfail:(V2TIMFail)fail;
Parameter description:
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. |
API prototype:
// V2TIMMessageManagervirtual V2TIMString SendMessage(V2TIMMessage& message,const V2TIMString& receiver,const V2TIMString& groupID,V2TIMMessagePriority priority,bool onlineUserOnly,const V2TIMOfflinePushInfo& offlinePushInfo,V2TIMSendCallback* callback);
Parameter description:
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. |
Caution
If both
groupID
and receiver
are set, targeted group messages are sent to receiver
. For more information, see Targeted Group Message.Sending a Text Message
Text messages include one-to-one messages and group messages, which are different in terms of API and parameters.
The ordinary and advanced APIs can be used to send text messages. The latter supports more sending parameters (such as priority and offline push message).
The ordinary API is as described below, while the advanced API is
sendMessage
mentioned above.One-to-one text message
Basic API
Call the
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
.Sample code:
// `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);
Advanced API
The advanced API can be called to send a one-to-one text message in two steps:
1. Call
createTextMessage
(Android / iOS and macOS / Windows) to create a text message.2. Call
sendMessage
(Android / iOS and macOS / Windows) to send the message.Sample code:
// 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);
Group text message
Basic API
Call
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.For message priorities, see the
V2TIMMessagePriority
definition.Sample code:
// `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);
Advanced API
The advanced API can be called to send a group text message in two steps:
1. Call
createTextMessage
(Android / iOS and macOS / Windows) to create a text message.2. Call
sendMessage
(Android / iOS and macOS / Windows) to send the message.Sample code:
// 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);
Sending a Custom Message
Custom messages include one-to-one messages and group messages, which are different in terms of APIs and parameters. The ordinary and advanced APIs can be used to send custom messages.
The advanced API is
sendMessage
mentioned above (Android / iOS and macOS / Windows), which supports more sending parameters (such as priority and offline push message) than the ordinary API.Custom one-to-one message
Basic API
Call
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
.Sample code:
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);
Advanced API
The advanced API can be called to send a custom one-to-one message in two steps:
1. Call
createCustomMessage
(Android / iOS and macOS / Windows) to create a custom message.2. Call
sendMessage
(Android / iOS and macOS / Windows) to send the message.Sample code:
// 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);
Custom group message
Basic API
Call
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.Sample code:
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);
Advanced API
The advanced API can be called to send a custom group message in two steps:
1. Call
createCustomMessage
(Android / iOS and macOS / Windows) to create a custom message.2. Call
sendMessage
(Android / iOS and macOS / Windows) to send the message.Sample code:
// 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);
Sending a Rich Media Message
A rich media message can be sent in the following steps:
1. Call
createXxxMessage
to create a rich media message object of a specified type. Here, Xxx
indicates the specific message type.2. Call
sendMessage
(Android / iOS and macOS / Windows) to send the message.3. Get the callback for message sending success or failure.
Image message
To create an image message, you need to get the local image path first.
During message sending, the image is uploaded to the server, and the upload progress is called back. The message is sent after the image is uploaded successfully.
Sample code:
// 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);
Audio message
To create an audio message, you need to get the local audio file path and audio duration first, the latter of which can be used for display on the receiver UI.
During message sending, the audio is uploaded to the server, and the upload progress is called back. The message is sent after the audio is uploaded successfully.
Sample code:
// 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);
Video message
To create a video message, you need to get the local video file path, video duration, and video thumbnail first, the latter two of which can be used for display on the receiver UI.
During message sending, the video is uploaded to the server, and the upload progress is called back. The message is sent after the video is uploaded successfully.
Below is the sample code:
// 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);
File message
To create a file message, you need to get the local file path first.
During message sending, the file is uploaded to the server, and the upload progress is called back. The message is sent after the file is uploaded successfully.
Sample code:
// 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