tencent cloud

Feedback

Android&iOS&Windows&Mac

Last updated: 2024-04-23 17:59:45

    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 macOSWindows) 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:
    Android
    iOS and macOS
    Windows
    API prototype:
    // V2TIMMessageManager
    public 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 *)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;
    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:
    // 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 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 macOSWindows) to send a one-to-one text message simply by passing in the message content and receiver's userID.
    Sample code:
    Android
    iOS and macOS
    Windows
    // `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
    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 (Android / iOS and macOSWindows) to create a text message.
    2. Call sendMessage (Android / iOS and macOSWindows) to send the message.
    Sample code:
    Android
    iOS and macOS
    Windows
    // 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
    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);

    Group text message

    Basic API

    Call sendGroupTextMessage (Android / iOS and macOSWindows) 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:
    Android
    iOS and macOS
    Windows
    // `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
    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 (Android / iOS and macOSWindows) to create a text message.
    2. Call sendMessage (Android / iOS and macOSWindows) to send the message.
    Sample code:
    Android
    iOS and macOS
    Windows
    // 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
    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 (Android / iOS and macOSWindows), 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 macOSWindows) to send a custom one-to-one message simply by passing in the binary content and receiver's userID.
    Sample code:
    Android
    iOS and macOS
    Windows
    
    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
    }
    });
    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 (Android / iOS and macOSWindows) to create a custom message.
    2. Call sendMessage (Android / iOS and macOSWindows) to send the message.
    Sample code:
    Android
    iOS and macOS
    Windows
    // 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
    }
    });
    V2TIMMessage *message = [[V2TIMManager sharedInstance] createCustomMessage:data];
    [[V2TIMManager sharedInstance] sendMessage:message
    receiver:@"receiver_userID" // Receiver's `userID`
    groupID:nil
    priority:V2TIM_PRIORITY_DEFAULT // Message priority
    onlineUserOnly:NO
    offlinePushInfo:nil
    progress:nil
    succ:^{
    // 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 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 (Android / iOS and macOSWindows) 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:
    Android
    iOS and macOS
    Windows
    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
    }
    });
    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 (Android / iOS and macOSWindows) to create a custom message.
    2. Call sendMessage (Android / iOS and macOSWindows) to send the message.
    Sample code:
    Android
    iOS and macOS
    Windows
    // Create a custom message
    V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createCustomMessage("Custom group 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 group message sent successfully
    }
    
    @Override
    public void onError(int code, String desc) {
    // 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 (Android / iOS and macOSWindows) 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:
    Android
    iOS and macOS
    Windows
    // 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
    }
    });
    // 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
    }]