tencent cloud

Android&iOS&Windows&Mac
Download PDF
Last updated: 2025-09-26 09:59:40
Android&iOS&Windows&Mac
Last updated: 2025-09-26 09:59:40
Download PDF

Basic Feature Description

The method for sending a message is in the core classes V2TIMManager and V2TIMMessageManager (Java) / V2TIMManager+Message (Swift and Objective-C).
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 (Java / Swift / Objective-C / C++) 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:
Java
Swift
Objective-C
C++
// V2TIMMessageManager
public abstract String sendMessage(
    V2TIMMessage message,
    String receiver,
    String groupID,
    int priority,
    boolean onlineUserOnly,
    V2TIMOfflinePushInfo offlinePushInfo,
    V2TIMSendCallback<V2TIMMessage> callback);
public func sendMessage(message: V2TIMMessage,
                        receiver: String?,groupID: String?,
                        priority: V2TIMMessagePriority,
                        onlineUserOnly: Bool,
                        offlinePushInfo: V2TIMOfflinePushInfo?,
                        progress: V2TIMProgress?,
                        succ: V2TIMSucc?,
                        fail: V2TIMFail?) -> String?
// V2TIMManager+Message.h
- (NSString *)sendMessage:(V2TIMMessage *)message
                 receiver:(NSString *)receiver
                  groupID:(NSString *)groupID
                 priority:(V2TIMMessagePriority)priority
           onlineUserOnly:(BOOL)onlineUserOnly
          offlinePushInfo:(V2TIMOfflinePushInfo *)offlinePushInfo
                 progress:(V2TIMProgress)progress
                     succ:(V2TIMSucc)succ
                     fail:(V2TIMFail)fail;
// V2TIMMessageManager
virtual 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 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.
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 (Java / Swift / Objective-C / C++) to send a one-to-one text message simply by passing in the message content and receiver's userID.
Sample code:
Java
Swift
Objective-C
C++
// `msgID` returned by the API for on-demand use
String msgID = V2TIMManager.getInstance().sendC2CTextMessage("One-to-one text message", "receiver_userID", new V2TIMValueCallback<V2TIMMessage>() {
    @Override
    public void onSuccess(V2TIMMessage message) {
        // The one-to-one text message sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the one-to-one text message
    }
});
// `msgID` returned by the API for on-demand use
let msgID = V2TIMManager.shared.sendC2CTextMessage(text: "this is c2c message", to: "receiver_userID") {
        print("send c2c text message succ.")
    } fail: { code, desc in
        print("send c2c text message fail, code: \\(code), desc: \\(desc)")
    }
// `msgID` returned by the API for on-demand use
NSString *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 successfully
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // Failed to send the one-to-one text message
        delete callback;
    },
    [=](uint32_t progress) {
        // The progress is not called back for the text message.
    });
// `msgID` returned by the API for on-demand use
V2TIMString 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 (Java / Swift / Objective-C / C++) to create a text message.
2. Call sendMessage (Java / Swift / Objective-C / C++) to send the message.
Sample code:
Java
Swift
Objective-C
C++
// Create a text message
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createTextMessage("content");
// Send the message
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // The progress is not called back for the text message.
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // The text message sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the text message
    }
});
// Create a text message
let msg = V2TIMManager.shared.createTextMessage(text: "content") {
// Send the message
    _ = V2TIMManager.shared.sendMessage(message: msg, receiver: "userID", groupID: nil, priority:     
        .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in
    } succ: {
        print("createTextMessage & send succ.")
    } fail: { code, desc in
        print("createTextMessage &send c2c text message fail, code: \\(code), desc: \\(desc)")
    }
}

// Create a text message
V2TIMMessage *message = [[V2TIMManager sharedInstance] createTextMessage:@"content"];
// Send the message
[V2TIMManager.sharedInstance sendMessage:message
                                receiver:@"userID"
                                 groupID:nil
                                priority:V2TIM_PRIORITY_NORMAL
                          onlineUserOnly:NO
                         offlinePushInfo:nil
                                progress:nil
                                succ:^{
    // 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 message
V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateTextMessage("One-to-one text message");
// Send the message
auto 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 message
        delete 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); false, {}, callback);

Group text message

Basic API

Call sendGroupTextMessage (Java / Swift / Objective-C / C++) 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:
Java
Swift
Objective-C
C++
// `msgID` returned by the API for on-demand use
String msgID = V2TIMManager.getInstance().sendGroupTextMessage("Group text message", "groupID", V2TIMMessage.V2TIM_PRIORITY_NORMAL, new V2TIMValueCallback<V2TIMMessage>() {
    @Override
    public void onSuccess(V2TIMMessage message) {
        // The group text message sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the group text message
    }
});
// `msgID` returned by the API for on-demand use
let msgID =  V2TIMManager.shared.sendGroupTextMessage(text: "this is group text message", to: "groupID", priority: .V2TIM_PRIORITY_DEFAULT, succ: nil, fail: nil)
// `msgID` returned by the API for on-demand use
NSString *msgID = [[V2TIMManager sharedInstance] sendGroupTextMessage:@"Group text message" 
                                                                   to:@"groupID"  // `groupID` of the group chat
                                                             priority:V2TIM_PRIORITY_NORMAL // Message priority
                                                                 succ:^{
    // 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 successfully
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // Failed to send the group text message
        delete callback;
    },
    [=](uint32_t progress) {
        // The progress is not called back for the text message.
    });
// `msgID` returned by the API for on-demand use
V2TIMString 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 (Java / Swift / Objective-C / C++) to create a text message.
2. Call sendMessage (Java / Swift / Objective-C / C++) to send the message.
Sample code:
Java
Swift
Objective-C
C++
// Create a text message
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createTextMessage("content");
// Send the message
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, null, "receiver_groupID", V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // The progress is not called back for the text message.
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // The group text message sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the group text message
    }
});
// Create a text message
let msg = V2TIMManager.shared.createTextMessage(text: "content") {
// Send the message
    _ = V2TIMManager.shared.sendMessage(message: msg, receiver: nil, groupID: "receiver_groupID", priority:     
        .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in
    } succ: {
        print("createTextMessage & send succ.")
    } fail: { code, desc in
        print("createTextMessage &send c2c text message fail, code: \\(code), desc: \\(desc)")
    }
}
// Create a text message
V2TIMMessage *message = [[V2TIMManager sharedInstance] createTextMessage:content];
// Send the message
[V2TIMManager.sharedInstance sendMessage:message
                                receiver:nil
                                 groupID:@"receiver_groupID"  // `groupID` of the group chat
                                priority:V2TIM_PRIORITY_NORMAL // Message priority
                          onlineUserOnly:NO   // For online users only
                         offlinePushInfo:nil  // Custom information for offline push
                                progress:nil
                                    succ:^{
    // 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 message
V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateTextMessage("Group text message");
// Send the message
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // The group text message sent successfully
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // Failed to send the group text message
        delete 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 (Java / Swift / Objective-C / C++), 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 (Java / Swift / Objective-C / C++) to send a custom one-to-one message simply by passing in the binary content and receiver's userID.
Sample code:
Java
Swift
Objective-C
C++
String msgID = V2TIMManager.getInstance().sendC2CCustomMessage("Custom one-to-one message".getBytes(), "receiver_userID", new V2TIMValueCallback<V2TIMMessage>() {
    @Override
    public void onSuccess(V2TIMMessage message) {
        // The custom one-to-one message sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the custom one-to-one message
    }
});
let msgID = V2TIMManager.shared.sendC2CCustomMessage(text: "this is c2c message", to: "receiver_userID") {
      // The custom one-to-one message sent successfully
        print("send c2c text message succ.")
    } fail: { code, desc in
        // Failed to send the custom one-to-one message
        print("send c2c text message fail, code: \\(code), desc: \\(desc)")
    }
NSData *customData = [@"Custom one-to-one message"  dataUsingEncoding:NSUTF8StringEncoding];
NSString *msgID = [[V2TIMManager sharedInstance] sendC2CCustomMessage:customData
                                                                   to:@"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 successfully
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // Failed to send the custom one-to-one message
        delete 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 (Java / Swift / Objective-C / C++) to create a custom message.
2. Call sendMessage (Java / Swift / Objective-C / C++) to send the message.
Sample code:
Java
Swift
Objective-C
C++
// Create a custom message
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createCustomMessage("Custom one-to-one message".getBytes());
// Send the message
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // The progress is not called back for the custom message.
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // The custom one-to-one message sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the custom one-to-one message
    }
});
if let msg = V2TIMManager.shared.createCustomMessage(data: "CustomMessage".data(using: .utf8) ?? Data()) {
    _ = V2TIMManager.shared.sendMessage(message: msg, receiver: "receiver_userID", groupID: nil, priority: .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in
    } succ: {
        // The custom one-to-one message sent successfully
    } fail: { code, desc in
        // Failed to send the custom one-to-one message
    }
}
// Create a custom message
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createCustomMessage("Custom one-to-one message".getBytes());
// Send the message
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // The progress is not called back for the custom message.
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // The custom one-to-one message sent successfully
    }

    @Override
    public void onError(int code, String 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 message
V2TIMString 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 message
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // The custom one-to-one message sent successfully
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // Failed to send the custom one-to-one message
        delete 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 (Java / Swift / Objective-C / C++) 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:
Java
Swift
Objective-C
C++
String msgID = V2TIMManager.getInstance().sendGroupCustomMessage("Custom group message".getBytes(), "groupID", V2TIMMessage.V2TIM_PRIORITY_NORMAL, new V2TIMValueCallback<V2TIMMessage>() {
    @Override
    public void onSuccess(V2TIMMessage message) {
        // The custom group message sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the custom group message
    }
});
let customData = "customText".data(using: .utf8) ?? Data()
let msgID = V2TIMManager.shared.sendGroupCustomMessage(customData: customData, to: "receiver_groupID",
                                                        priority: .V2TIM_PRIORITY_DEFAULT,
 succ: {
        // The custom group message sent successfully
}) { code, desc in
        // Failed to send the custom group message
}
NSData *customData = [@"Custom group message"  dataUsingEncoding:NSUTF8StringEncoding];
NSString *msgID = [[V2TIMManager sharedInstance] sendGroupCustomMessage:customData
                                                                     to:@"receiver_groupID"  // `groupID` of the group chat
                                                               priority:V2TIM_PRIORITY_HIGH  // Message priority
                                                                   succ:^{
    // 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 successfully
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // Failed to send the custom group message
        delete 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 (Java / Swift / Objective-C / C++) to create a custom message.
2. Call sendMessage (Java / Swift / Objective-C / C++) to send the message.
Sample code:
Java
Swift
Objective-C
C++
// Create a custom message
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createCustomMessage("Custom group message".getBytes());
// Send the message
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_groupID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // The progress is not called back for the custom message.
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // The custom group message sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the custom group message
    }
});
if let msg = V2TIMManager.shared.createCustomMessage(data: "customdata".data(using: .utf8) ?? Data()) {
    _ = V2TIMManager.shared.sendMessage(message: msg, receiver: nil, groupID: "receiver_groupID", priority: .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in
    } succ: {
    // The custom group message sent successfully
    } fail: { code, desc in
    // Failed to send the custom group message
    }
}
V2TIMMessage *message = [[V2TIMManager sharedInstance] createCustomMessage:data];
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:nil
                                   groupID:@"receiver_groupID"  // `groupID` of the group chat
                                  priority:V2TIM_PRIORITY_DEFAULT  // Message priority
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:nil
                                      succ:^{
    // 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 message
V2TIMString 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 message
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // The custom group message sent successfully
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // Failed to send the custom group message
        delete 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 (Java / Swift / Objective-C / C++) 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.
SDKs support a maximum image size of 28 MB for any single file to be sent.
Sample code:
Java
Swift
Objective-C
C++
// Create an image message
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createImageMessage("/sdcard/xxx");
// Send the message
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // Image upload progress in the range of [0, 100]
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // The image message sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the image message
    }
});
if  let path = Bundle.main.path(forResource: "test", ofType: "png"),
    // Create an image message
    let msg = V2TIMManager.shared.createImageMessage(imagePath: path) {
    // Send the message
    _ = V2TIMManager.shared.sendMessage(message: msg, receiver: "userID", groupID: nil, priority: .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in
    // Image upload progress in the range of [0, 100]
    } succ: {
    // The image message sent successfully
    } fail: { code, desc in
    // Failed to send the image message
    }
}
// Get the local image path
NSString *imagePath = [[NSBundle mainBundle] pathForResource:@"test" ofType:@"png"];
// Create an image message
V2TIMMessage *message = [[V2TIMManager sharedInstance] createImageMessage:imagePath];
// Send the message
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:@"userID"
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:^(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 message
V2TIMMessage v2TIMMessage =
    V2TIMManager::GetInstance()->GetMessageManager()->CreateImageMessage("./File/Xxx.jpg");
// Send the message
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // The image message sent successfully
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // Failed to send the image message
        delete 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:
Java
Swift
Objective-C
C++
// Create an audio message
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createSoundMessage("/sdcard/xxx", 5);
// Send the message
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // Audio upload progress in the range of [0, 100]
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // The audio message sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the audio message
    }
});
// Get the local audio file path
func createSound() -> String? {
    let numberOne: Int = Int(arc4random())
    if let path = Bundle.main.path(forResource: "00", ofType: "caf"),
        let url = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true).first?.appending("/\\(Date().timeIntervalSince1970)_\\(numberOne).caf"),
        let data = try? Data(contentsOf: URL(fileURLWithPath: path)) {
        try? data.write(to: URL(fileURLWithPath: url))
        return url
    }
    
    return nil
}

func createAndSendSoundMessage() {
    if  let path = self?.createSound(),
        // Create an audio message
        let msg = V2TIMManager.shared.createSoundMessage(audioFilePath: path, duration: 30) {
        // Send the message
        _ = V2TIMManager.shared.sendMessage(message: msg, receiver: "userID", groupID: nil, priority: .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in
        // Audio upload progress in the range of [0, 100]
        } succ: {
            print("createSoundMessage & send succ")
        } fail: { code, desc in
            print("createSoundMessage &send c2c text message fail, code: \\(code), desc: \\(desc)")
        }
    }
}

// Get the local audio file path
NSString *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 message
V2TIMMessage *message = [[V2TIMManager sharedInstance] createSoundMessage:soundPath duration:duration];
// Send the message
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:@"userID"
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:^(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 message
V2TIMMessage v2TIMMessage =
    V2TIMManager::GetInstance()->GetMessageManager()->CreateSoundMessage("./File/Xxx.mp3", 5);
// Send the message
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // The audio message sent successfully
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // Failed to send the audio message
        delete 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:
Java
Swift
Objective-C
C++
// Create a video message
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createVideoMessage("/sdcard/xxx", "mp4", 10, "/sdcard/xxx");
// Send the message
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // Video upload progress in the range of [0, 100]
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // The video message sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the video message
    }
});
// Get the local video file path
if  let snappath = Bundle.main.path(forResource: "testpng", ofType: nil),
    // Get the local video thumbnail path
    let path = Bundle.main.path(forResource: "test", ofType: "mp4"),
    // Get the video duration
    let msg = V2TIMManager.shared.createVideoMessage(videoFilePath: path, type: "mp4", duration: 30, snapshotPath: snappath) {
    // Send the message
    _ = V2TIMManager.shared.sendMessage(message: msg, receiver: "userID", groupID:nil, priority: .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in
        
    } succ: {
        print("createVideoMessage & send succ")
    } fail: { code, desc in
        print("createVideoMessage & send fail, \\(code), \\(desc)")
    }
}
// Get the local video file path
NSString *videoPath = [[NSBundle mainBundle] pathForResource:@"test" ofType:@"mp4"];
// Get the local video thumbnail path
NSString *snapShotPath = [[NSBundle mainBundle] pathForResource:@"testpng" ofType:@""];
// Get the video duration
AVURLAsset *asset = [AVURLAsset assetWithURL:[NSURL fileURLWithPath:path]];
CMTime time = [asset duration];
int duration = ceil(time.value/time.timescale);
// Create a video message
V2TIMMessage *message = [[V2TIMManager sharedInstance] createVideoMessage:videoPath  
                                                                     type:@"mp4" 
                                                                 duration:duration 
                                                             snapshotPath:snapShotPath];
// Send the message
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:@"userID"
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:^(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 message
V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateVideoMessage(
    "./File/Xxx.mp4", "mp4", 10, "./File/Xxx.jpg");
// Send the message
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // The video message sent successfully
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // Failed to send the video message
        delete 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:
Java
Swift
Objective-C
C++
// Create a file message
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createFileMessage("/sdcard/xxx", "Filename");
// Send the message
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // File upload progress in the range of [0, 100]
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // The file message sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the file message
    }
});
if  let path = Bundle.main.path(forResource: "test", ofType: "mp4") ,
    let msg = V2TIMManager.shared.createFileMessage(filePath: path, fileName: "name") {
    _ = V2TIMManager.shared.sendMessage(message: msg, receiver: "userID", groupID: nil, priority: .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in
        
    } succ: {
    // The file message sent successfully
    } fail: { code, desc in
    // Failed to send the file message
    }
}
// Get the local file path
NSString *filePath = [[NSBundle mainBundle] pathForResource:@"test" ofType:@"mp4"];
// Create a file message
V2TIMMessage *message = [[V2TIMManager sharedInstance] createFileMessage:filePath fileName:@"Send the file message"];
// Send the message
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:@"userID"
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:^(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 message
V2TIMMessage v2TIMMessage =
    V2TIMManager::GetInstance()->GetMessageManager()->CreateFileMessage("./File/Xxx.zip", "Xxx");
// Send the message
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // The file message sent successfully
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // Failed to send the file message
        delete 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);

Location message

Latitude and longitude information is sent in a location message, which requires a map control for display.
Sample code:
Java
Swift
Objective-C
C++
// Create a location message
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createLocationMessage("Geographical location", 0.5, 0.5);
// Send the message
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // The progress is not called back for the location message.
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // The location message sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the location message
    }
});
if  let msg = V2TIMManager.shared.createLocationMessage(desc: "LocationMessage text", longitude: 2020, latitude: 2020) {
    _ = V2TIMManager.shared.sendMessage(message: msg, receiver: "userID", groupID: nil, priority: .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in
        
    } succ: {
        print("createLocationMessage & send succ")
    } fail: { code, desc in
        print("createLocationMessage & send fail, \\(code), \\(desc)")
    }
}
// Create a location message
V2TIMMessage *message = [[V2TIMManager sharedInstance] createLocationMessage:@"Send the geographical location message" longitude:0.5 latitude:0.5];
// Send the message
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:@"userID"
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:nil
                                      succ:^{
    // 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 message
V2TIMMessage v2TIMMessage =
    V2TIMManager::GetInstance()->GetMessageManager()->CreateLocationMessage("Location", 0.5, 0.5);
// Send the message
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // The location message sent successfully
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // Failed to send the location message
        delete 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);

Emoji message

Emoji codes are sent in an emoji message and need to be converted into icons by the receiver.
Sample code:
Java
Swift
Objective-C
C++
// Create an emoji message
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createFaceMessage(1, "tt00".getBytes());
// Send the message
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // The progress is not called back for the emoji message.
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // The emoji message sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the emoji message
    }
});
// Create an emoji message
if  let msg = V2TIMManager.shared.createFaceMessage(index: 0, data: nil) {
// Send the message
    _ = V2TIMManager.shared.sendMessage(message: msg, receiver: "userID", groupID: nil, priority: .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in
    } succ: {
    // The emoji message sent successfully
    } fail: { code, desc in
    // Failed to send the emoji message
    }
}
// Create an emoji message
V2TIMMessage *message = [[V2TIMManager sharedInstance] createFaceMessage:1 data:[@"tt00" dataUsingEncoding:NSUTF8StringEncoding]];
// Send the message
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:@"userID"
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:nil
                                      succ:^{
    // 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 message
V2TIMString str = u8"tt00";
V2TIMBuffer data = {reinterpret_cast<const uint8_t*>(str.CString()), str.Size()};
V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateFaceMessage(1, data);
// Send the message
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // The emoji message sent successfully
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // Failed to send the emoji message
        delete 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);

Sending a Message Containing Multiple Element Objects

To include multiple elements in a message, create a Message object and call the appendElem method (Java / Swift / Objective-C / C++) 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.
Sample code for "text message + custom message":
Java
Swift
Objective-C
C++
// Create a text message
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createTextMessage("test");
// Create a custom element
V2TIMCustomElem customElem = new V2TIMCustomElem();
customElem.setData("Custom message".getBytes());
// Add the custom element to `message.textElem`
v2TIMMessage.getTextElem().appendElem(customElem);
// Send the message
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // The progress is not called back.
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // The message containing multiple elements sent successfully
    }

    @Override
    public void onError(int code, String desc) {
        // Failed to send the message containing multiple element objects
    }
});
// Create a text message
guard let message = V2TIMManager.shared.createTextMessage(text: "text") else {
    print("Failed to create text message.")
    return
}
// Create a custom element
let customElem = V2TIMCustomElem()
customElem.data = "Custom message".data(using: .utf8)
// Add the custom element to `message.textElem`
message.textElem?.appendElem(element: customElem)
// Send the message
V2TIMManager.shared.sendMessage(message: message, receiver: "userID", groupID: nil, priority: .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in

} succ: {
    // The message containing multiple elements sent successfully
    print("Custom message sent successfully.")
} fail: { code, desc in
    // Failed to send the message containing multiple element objects
    print("Failed to send custom message: \\(code), \\(desc)")
}
// Create a text message
V2TIMMessage *message = [[V2TIMManager sharedInstance] createTextMessage:@"text"];

// Create a custom element
V2TIMCustomElem *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:message
                                  receiver:@"userID"
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:nil
                                      succ:^{
    // 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 message
V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateTextMessage("test");
// Create a custom element
V2TIMCustomElem 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 message
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // The message containing multiple elements sent successfully
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // Failed to send the message containing multiple element objects
        delete 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.
Note：
1. When the number of sent messages exceeds the limit, the backend will first deliver higher-priority messages, and messages with the same priority will be delivered randomly. However, if the number of high-priority messages sent in a second exceeds 40, high-priority messages will also be discarded.
2. A message that has been restricted by frequency control is not delivered or stored in the message history, but a success response will be returned to the sender. Before Group Message Is Sent webhook is triggered, but After Group Message Is Sent is not triggered.
3. The default rate limit for calling the RESTful API to send group messages is 200 times per second, which is a different concept from the aforementioned "limit of 40 messages per second for each group." Please distinguish it.
Please refer to Use Limits for more limits.
Was this page helpful?
You can also Contact Sales or Submit a Ticket for help.
Yes
No

Feedback