tencent cloud

Android&iOS&Windows&Mac
下载PDF
最后更新时间：2025-09-26 09:59:40
Android&iOS&Windows&Mac
最后更新时间： 2025-09-26 09:59:40
下载PDF

功能描述

发送消息方法在核心类 V2TIMManager 和 V2TIMMessageManager(Java) / V2TIMManager+Message (Swift 、Objective-C) 中。
支持发送文本、自定义、富媒体消息，消息类型都是 V2TIMMessage。
V2TIMMessage 中可以携带 V2TIMElem 的不同类型子类，表示不同类型的消息。

重点接口说明

接口 sendMessage (Java / Swift / Objective-C / C++) 是发送消息中最核心的接口。该接口支持发送所有类型的消息。
说明
下文中提到的发消息高级接口，指的都是 sendMessage。
接口说明如下：
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);
参数说明：
参数
含义
单聊有效
群聊有效
说明
message
消息对象
YES
YES
需要通过对应的 createXxxMessage 接口先行创建，Xxx 表示具体的类型。
receiver
单聊消息接收者 userID
YES
NO
如果是发送 C2C 单聊消息，只需要指定 receiver 即可。
groupID
群聊 groupID
NO
YES
如果是发送群聊消息，只需要指定 groupID 即可。
priority
消息优先级
NO
YES
请把重要消息设置为高优先级（例如红包、礼物消息），高频且不重要的消息设置为低优先级（例如点赞消息）。
onlineUserOnly
是否只有在线用户才能收到
YES
YES
如果设置为 YES，接收方历史消息拉取不到，常被用于实现 “对方正在输入” 或群组里的非重要提示等弱提示功能。
offlinePushInfo
离线推送信息
YES
YES
离线推送时携带的标题和内容。
progress
文件上传进度（IOS）
YES
YES
文件上传进度。当发送消息中包含图片、语音、视频、文件等富媒体消息时才有效，纯文本、表情、定位消息不会回调。
succ
消息发送成功回调
YES
YES
——
fail
消息发送失败回调
YES
YES
回调失败错误码、错误描述。
注意
如果 groupID 和 receiver 同时设置，表示给 receiver 发送定向群消息。详情请参考 群定向消息。

发送文本消息

文本消息区分单聊和群聊，涉及的接口、传参有所区别。
发送文本消息可以采用两种接口：普通接口和高级接口。高级接口比普通接口能设置更多的发送参数（例如优先级、离线推送信息等）。 普通接口参考下文具体描述，高级接口就是上文中提到的 sendMessage。

单聊文本消息

普通接口

调用 sendC2CTextMessage (Java / Swift / Objective-C / C++) 发送单聊文本消息，直接传入消息内容和接收者的 userID 即可。
示例代码如下：
Java
Swift
Objective-C
C++
// API 返回 msgID，按需使用
String msgID = V2TIMManager.getInstance().sendC2CTextMessage("单聊文本消息", "receiver_userID", new V2TIMValueCallback<V2TIMMessage>() {
    @Override
    public void onSuccess(V2TIMMessage message) {
        // 发送单聊文本消息成功
    }

    @Override
    public void onError(int code, String desc) {
        // 发送单聊文本消息失败
    }
});
// API 返回 msgID，按需使用
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)")
    }
// API 返回 msgID，按需使用
NSString *msgID = [[V2TIMManager sharedInstance] sendC2CTextMessage:@"单聊文本消息" 
                                                                 to:@"receiver_userID"
                                                               succ:^{
    // 发送单聊文本消息成功
} fail:^(int code, NSString *msg) {
    // 发送单聊文本消息失败
}];
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) {
        // 发送单聊文本消息成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 发送单聊文本消息失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 文本消息不会回调进度
    });
// API 返回 msgID，按需使用
V2TIMString msgID =
    V2TIMManager::GetInstance()->SendC2CTextMessage("单聊文本消息", "receiver_userID", callback);

高级接口

调用高级接口发送单聊文本消息分两步：
1. 调用 createTextMessage (Java / Swift / Objective-C / C++) 创建文本消息。
2. 调用 sendMessage (Java / Swift / Objective-C / C++) 发送消息。
示例代码如下：
Java
Swift
Objective-C
C++
// 创建文本消息
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createTextMessage("content");
// 发送消息
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // 文本消息不会回调进度
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // 文本消息发送成功
    }

    @Override
    public void onError(int code, String desc) {
        // 文本消息发送失败
    }
});
// 创建文本消息
let msg = V2TIMManager.shared.createTextMessage(text: "content") {
      // 发送消息
    _ = 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)")
    }
}

// 创建文本消息
V2TIMMessage *message = [[V2TIMManager sharedInstance] createTextMessage:@"content"];
// 发送消息
[V2TIMManager.sharedInstance sendMessage:message
                                receiver:@"userID"
                                 groupID:nil
                                priority:V2TIM_PRIORITY_NORMAL
                          onlineUserOnly:NO
                         offlinePushInfo:nil
                                progress:nil
                                succ:^{
    // 文本消息发送成功
}
                                fail:^(int code, NSString *desc) {
    // 文本消息发送失败
}];
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_;
};

// 创建文本消息
V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateTextMessage("content");
// 发送消息
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // 文本消息发送成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 文本消息发送失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 文本消息不会回调进度
    });
V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(
    v2TIMMessage, "userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);

群聊文本消息

普通接口

调用 sendGroupTextMessage (Java / Swift / Objective-C / C++) 发送群聊文本消息，直接传递消息内容、群聊的 groupID 和消息优先级即可。
消息优先级可参考 V2TIMMessagePriority 定义。
示例代码如下：
Java
Swift
Objective-C
C++
// API 返回 msgID，按需使用
String msgID = V2TIMManager.getInstance().sendGroupTextMessage("群聊文本消息", "groupID", V2TIMMessage.V2TIM_PRIORITY_NORMAL, new V2TIMValueCallback<V2TIMMessage>() {
    @Override
    public void onSuccess(V2TIMMessage message) {
        // 发送群聊文本消息成功
    }

    @Override
    public void onError(int code, String desc) {
        // 发送群聊文本消息失败
    }
});
// API 返回 msgID，按需使用
let msgID =  V2TIMManager.shared.sendGroupTextMessage(text: "this is group text message", to: "groupID", priority: .V2TIM_PRIORITY_DEFAULT, succ: nil, fail: nil)
// API 返回 msgID，按需使用
NSString *msgID = [[V2TIMManager sharedInstance] sendGroupTextMessage:@"群聊文本消息" 
                                                                   to:@"groupID"  // 群聊的 groupID
                                                             priority:V2TIM_PRIORITY_NORMAL // 消息优先级
                                                                 succ:^{
    // 群聊文本消息发送成功
} fail:^(int code, NSString *msg) {
    // 群聊文本消息发送失败
}];
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) {
        // 发送群聊文本消息成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 发送群聊文本消息失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 文本消息不会回调进度
    });
// API 返回 msgID，按需使用
V2TIMString msgID = V2TIMManager::GetInstance()->SendGroupTextMessage(
    "群聊文本消息", "groupID", V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, callback);

高级接口

调用高级接口发送群聊文本消息分两步：
1. 调用 createTextMessage (Java / Swift / Objective-C / C++) 创建文本消息。
2. 调用 sendMessage (Java / Swift / Objective-C / C++) 发送消息。
示例代码如下：
Java
Swift
Objective-C
C++
// 创建文本消息
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createTextMessage("content");
// 发送消息
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, null, "receiver_groupID", V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // 文本消息不会回调进度
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // 发送群聊文本消息成功
    }

    @Override
    public void onError(int code, String desc) {
        // 发送群聊文本消息失败
    }
});
// 创建文本消息
let msg = V2TIMManager.shared.createTextMessage(text: "content") {
      // 发送消息
    _ = 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)")
    }
}
// 创建文本消息
V2TIMMessage *message = [[V2TIMManager sharedInstance] createTextMessage:content];
// 发送消息
[V2TIMManager.sharedInstance sendMessage:message
                                receiver:nil
                                 groupID:@"receiver_groupID"  // 群聊的 groupID
                                priority:V2TIM_PRIORITY_NORMAL // 消息优先级
                          onlineUserOnly:NO   // 仅在线用户接收
                         offlinePushInfo:nil  // 离线推送自定义信息
                                progress:nil
                                    succ:^{
    // 文本消息发送成功
}
                                fail:^(int code, NSString *desc) {
    // 文本消息发送失败
}];
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_;
};

// 创建文本消息
V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateTextMessage("content");
// 发送消息
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // 发送群聊文本消息成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 发送群聊文本消息失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 文本消息不会回调进度
    });
V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(
    v2TIMMessage, {}, "receiver_groupID", V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);

发送自定义消息

自定义消息区分单聊和群聊，涉及的接口或者传参有所区别。发送自定义消息可以采用两种接口：普通接口和高级接口。 高级接口即上文中已介绍过的 sendMessage (Java / Swift / Objective-C / C++)，比普通接口能设置更多的发送参数（例如优先级、离线推送信息等）。

单聊自定义消息

普通接口

调用 sendC2CCustomMessage (Java / Swift / Objective-C / C++) 发送单聊自定义消息，直接传递消息二进制内容、单聊接收者 userID 即可。
示例代码如下：
Java
Swift
Objective-C
C++
String msgID = V2TIMManager.getInstance().sendC2CCustomMessage("单聊自定义消息".getBytes(), "receiver_userID", new V2TIMValueCallback<V2TIMMessage>() {
    @Override
    public void onSuccess(V2TIMMessage message) {
        // 发送单聊自定义消息成功
    }

    @Override
    public void onError(int code, String desc) {
        // 发送单聊自定义消息失败
    }
});
let customData = "单聊自定义消息".data(using: .utf8) ?? Data()
let msgID = V2TIMManager.shared.sendC2CCustomMessage(customData: customData, to: "receiver_userID", succ: {
    // 单聊自定义消息发送成功
}) { code, desc in
    // 单聊自定义消息发送失败
}
NSData *customData = [@"单聊自定义消息"  dataUsingEncoding:NSUTF8StringEncoding];
NSString *msgID = [[V2TIMManager sharedInstance] sendC2CCustomMessage:customData
                                                                   to:@"receiver_userID"  // 接收者 userID
                                                                 succ:^{
    // 单聊自定义消息发送成功
} 
                                                                fail:^(int code, NSString *msg) {
    // 单聊自定义消息发送失败
}];
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) {
        // 发送单聊自定义消息成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 发送单聊自定义消息失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 自定义消息不会回调进度
    });
V2TIMString str = u8"单聊自定义消息";
V2TIMBuffer customData = {reinterpret_cast<const uint8_t*>(str.CString()), str.Size()};
V2TIMString msgID = V2TIMManager::GetInstance()->SendC2CCustomMessage(customData, "receiver_userID", callback);

高级接口

调用高级接口发送单聊自定义消息分两步：
1. 调用 createCustomMessage (Java / Swift / Objective-C / C++) 创建自定义消息。
2. 调用 sendMessage (Java / Swift / Objective-C / C++) 发送消息。
示例代码如下：
Java
Swift
Objective-C
C++
// 创建自定义消息
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createCustomMessage("单聊自定义消息".getBytes());
// 发送消息
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // 自定义消息不会回调进度
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // 发送单聊自定义消息成功
    }

    @Override
    public void onError(int code, String desc) {
        // 发送单聊自定义消息失败
    }
});
if let msg = V2TIMManager.shared.createCustomMessage(data: "单聊自定义消息".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: {
        // 单聊自定义消息发送成功
    } fail: { code, desc in
        // 单聊自定义消息发送失败
    }
}
V2TIMMessage *message = [[V2TIMManager sharedInstance] createCustomMessage:data];
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:@"receiver_userID"  // 接收者 userID
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT  // 消息优先级
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:nil
                                      succ:^{
    // 单聊自定义消息发送成功
} fail:^(int code, NSString *desc) {
    // 单聊自定义消息发送失败
}];
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_;
};

// 创建自定义消息
V2TIMString str = u8"单聊自定义消息";
V2TIMBuffer customData = {reinterpret_cast<const uint8_t*>(str.CString()), str.Size()};
V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateCustomMessage(customData);
// 发送消息
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // 发送单聊自定义消息成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 发送单聊自定义消息失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 自定义消息不会回调进度
    });
V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(
    v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);

群聊自定义消息

普通接口

调用 sendGroupCustomMessage (Java / Swift / Objective-C / C++) 发送群聊自定义消息，直接传递消息二进制内容、群聊 groupID 和优先级即可。 消息优先级可参考 V2TIMMessagePriority 定义。
代码示例如下：
Java
Swift
Objective-C
C++
String msgID = V2TIMManager.getInstance().sendGroupCustomMessage("群聊自定义消息".getBytes(), "groupID", V2TIMMessage.V2TIM_PRIORITY_NORMAL, new V2TIMValueCallback<V2TIMMessage>() {
    @Override
    public void onSuccess(V2TIMMessage message) {
        // 发送群聊自定义消息成功
    }

    @Override
    public void onError(int code, String desc) {
        // 发送群聊自定义消息失败
    }
});
let customData = "群聊自定义消息".data(using: .utf8) ?? Data()
let msgID = V2TIMManager.shared.sendGroupCustomMessage(customData: customData, to: "receiver_groupID",
                                                        priority: .V2TIM_PRIORITY_DEFAULT,
 succ: {
    // 单聊自定义消息发送成功
}) { code, desc in
    // 单聊自定义消息发送失败
}
NSData *customData = [@"群聊自定义消息"  dataUsingEncoding:NSUTF8StringEncoding];
NSString *msgID = [[V2TIMManager sharedInstance] sendGroupCustomMessage:customData
                                                                     to:@"receiver_groupID"  // 群聊的 groupID
                                                               priority:V2TIM_PRIORITY_HIGH  // 消息优先级
                                                                   succ:^{
    // 群聊自定义消息发送成功
} fail:^(int code, NSString *msg) {
    // 群聊自定义消息发送失败
}];
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) {
        // 发送群聊自定义消息成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 发送群聊自定义消息失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 自定义消息不会回调进度
    });
V2TIMString str = u8"群聊自定义消息";
V2TIMBuffer customData = {reinterpret_cast<const uint8_t*>(str.CString()), str.Size()};
V2TIMString msgID = V2TIMManager::GetInstance()->SendGroupCustomMessage(
    customData, "groupID", V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, callback);

高级接口

调用高级接口发送群聊自定义消息分两步：
1. 调用 createCustomMessage (Java / Swift / Objective-C / C++) 创建自定义消息。
2. 调用 sendMessage (Java / Swift / Objective-C / C++) 发送消息。
代码示例如下：
Java
Swift
Objective-C
C++
// 创建自定义消息
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createCustomMessage("群聊自定义消息".getBytes());
// 发送消息
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, null, "receiver_groupID", V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // 自定义消息不会回调进度
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // 发送群聊自定义消息成功
    }

    @Override
    public void onError(int code, String desc) {
        // 发送群聊自定义消息失败
    }
});
if let msg = V2TIMManager.shared.createCustomMessage(data: "自定义消息".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: {
        // 群聊自定义消息发送成功
    } fail: { code, desc in
        // 群聊自定义消息发送失败
    }
}
V2TIMMessage *message = [[V2TIMManager sharedInstance] createCustomMessage:data];
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:nil
                                   groupID:@"receiver_groupID"  // 群聊的 groupID
                                  priority:V2TIM_PRIORITY_DEFAULT  // 消息优先级
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:nil
                                      succ:^{
    // 群聊自定义消息发送成功
} fail:^(int code, NSString *desc) {
    // 群聊自定义消息发送失败
}];
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_;
};

// 创建自定义消息
V2TIMString str = u8"群聊自定义消息";
V2TIMBuffer customData = {reinterpret_cast<const uint8_t*>(str.CString()), str.Size()};
V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateCustomMessage(customData);
// 发送消息
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // 发送群聊自定义消息成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 发送群聊自定义消息失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 自定义消息不会回调进度
    });
V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(
    v2TIMMessage, {}, "receiver_groupID", V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);;

发送富媒体消息

富媒体消息的发送步骤如下：
1. 调用 createXxxMessage 创建指定类型的富媒体消息对象，其中 Xxx 表示具体的消息类型。
2. 调用 sendMessage (Java / Swift / Objective-C / C++) 发送消息。
3. 在消息回调中获取消息是否发送成功或失败。

图片消息

创建图片消息需要先获取到本地图片路径。
发送消息过程中，会先将图片文件上传至服务器，同时回调上传进度。上传成功后再发送消息。
发送图片消息时，SDK 最大支持发送单个图片大小为28MB。
示例代码如下：
Java
Swift
Objective-C
C++
// 创建图片消息
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createImageMessage("/sdcard/xxx");
// 发送消息
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // 图片上传进度，progress 取值 [0, 100]
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // 图片消息发送成功
    }

    @Override
    public void onError(int code, String desc) {
        // 图片消息发送失败
    }
});
if  let path = Bundle.main.path(forResource: "test", ofType: "png"),
    // 创建图片消息
    let msg = V2TIMManager.shared.createImageMessage(imagePath: path) {
    // 发送消息
    _ = V2TIMManager.shared.sendMessage(message: msg, receiver: "userID", groupID: nil, priority: .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in
        // 图片上传进度，progress 取值 [0, 100]
    } succ: {
        // 图片消息发送成功
    } fail: { code, desc in
        // 图片消息发送失败
    }
}
// 获取本地图片路径
NSString *imagePath = [[NSBundle mainBundle] pathForResource:@"test" ofType:@"png"];
// 创建图片消息
V2TIMMessage *message = [[V2TIMManager sharedInstance] createImageMessage:imagePath];
// 发送消息
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:@"userID"
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:^(uint32_t progress) {
    // 图片上传进度，progress 取值 [0, 100]
} succ:^{
    // 图片消息发送成功
} fail:^(int code, NSString *desc) {
    // 图片消息发送失败
}];
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_;
};

// 创建图片消息
V2TIMMessage v2TIMMessage =
    V2TIMManager::GetInstance()->GetMessageManager()->CreateImageMessage("./File/Xxx.jpg");
// 发送消息
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // 图片消息发送成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 图片消息发送失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 图片上传进度，progress 取值 [0, 100]
    });
V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(
    v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);

语音消息

创建语音消息需要先获取到本地语音文件路径和语音时长，其中语音时长可用于接收端 UI 显示。 发送消息过程中，会先将语音文件上传至服务器，同时回调上传进度。上传成功后再发送消息。
示例代码如下：
Java
Swift
Objective-C
C++
// 创建语音消息
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createSoundMessage("/sdcard/xxx", 5);
// 发送消息
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // 语音上传进度，progress 取值 [0, 100]
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // 语音消息发送成功
    }

    @Override
    public void onError(int code, String desc) {
        // 语音消息发送失败
    }
});
//获取音频文件的路径
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(),
        //创建音频消息
        let msg = V2TIMManager.shared.createSoundMessage(audioFilePath: path, duration: 30) {
        //发送音频消息
        _ = V2TIMManager.shared.sendMessage(message: msg, receiver: "userID", groupID: nil, priority: .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in
           // 语音上传进度，progress 取值 [0, 100]
        } succ: {
            print("createSoundMessage & send succ")
        } fail: { code, desc in
            print("createSoundMessage &send c2c text message fail, code: \\(code), desc: \\(desc)")
        }
    }
}

// 获取本地语音文件路径
NSString *soundPath = [[NSBundle mainBundle] pathForResource:@"test" ofType:@"m4a"];
// 获取语音素材的时长（时长仅用于 UI 显示）
AVURLAsset *asset = [AVURLAsset assetWithURL:[NSURL fileURLWithPath:soundPath]];
CMTime time = [asset duration];
int duration = ceil(time.value/time.timescale);
// 创建语音消息
V2TIMMessage *message = [[V2TIMManager sharedInstance] createSoundMessage:soundPath duration:duration];
// 发送消息
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:@"userID"
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:^(uint32_t progress) {
    // 语音上传进度，progress 取值 [0, 100]
} succ:^{
    // 语音消息发送成功
} fail:^(int code, NSString *desc) {
    // 语音消息发送失败
}];
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_;
};

// 创建语音消息
V2TIMMessage v2TIMMessage =
    V2TIMManager::GetInstance()->GetMessageManager()->CreateSoundMessage("./File/Xxx.mp3", 5);
// 发送消息
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // 语音消息发送成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 语音消息发送失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 语音上传进度，progress 取值 [0, 100]
    });
V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(
    v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);

视频消息

创建视频消息需要先获取到本地视频文件路径、视频时长和视频快照，其中时长和快照可用于接收端 UI 显示。 发送消息过程中，会先将视频上传至服务器，同时回调上传进度。上传成功后再发送消息。
示例代码如下：
Java
Swift
Objective-C
C++
// 创建视频消息
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createVideoMessage("/sdcard/xxx", "mp4", 10, "/sdcard/xxx");
// 发送消息
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // 视频上传进度，progress 取值 [0, 100]
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // 视频消息发送成功
    }

    @Override
    public void onError(int code, String desc) {
        // 视频消息发送失败
    }
});
    // 获取本地视频快照路径
if  let snappath = Bundle.main.path(forResource: "testpng", ofType: nil),
    // 获取本地视频文件路径
    let path = Bundle.main.path(forResource: "test", ofType: "mp4"),
    // 创建视频消息
    let msg = V2TIMManager.shared.createVideoMessage(videoFilePath: path, type: "mp4", duration: 30, snapshotPath: snappath) {
    // 发送消息
    _ = 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)")
    }
}
// 获取本地视频文件路径
NSString *videoPath = [[NSBundle mainBundle] pathForResource:@"test" ofType:@"mp4"];
// 获取本地视频快照路径
NSString *snapShotPath = [[NSBundle mainBundle] pathForResource:@"testpng" ofType:@""];
// 获取视频时长
AVURLAsset *asset = [AVURLAsset assetWithURL:[NSURL fileURLWithPath:path]];
CMTime time = [asset duration];
int duration = ceil(time.value/time.timescale);
// 创建视频消息
V2TIMMessage *message = [[V2TIMManager sharedInstance] createVideoMessage:videoPath  
                                                                     type:@"mp4" 
                                                                 duration:duration 
                                                             snapshotPath:snapShotPath];
// 发送消息
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:@"userID"
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:^(uint32_t progress) {
    // 视频上传进度，progress 取值 [0, 100]
} succ:^{
    // 视频消息发送成功
} fail:^(int code, NSString *desc) {
    // 视频消息发送失败
}];
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_;
};

// 创建视频消息
V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateVideoMessage(
    "./File/Xxx.mp4", "mp4", 10, "./File/Xxx.jpg");
// 发送消息
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // 视频消息发送成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 视频消息发送失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 视频上传进度，progress 取值 [0, 100]
    });
V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(
    v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);

文件消息

创建文件消息需要先获取到本地文件路径。 发送消息过程中，会先将文件上传至服务器，同时回调上传进度。上传成功后再发送消息。
示例代码如下：
Java
Swift
Objective-C
C++
// 创建文件消息
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createFileMessage("/sdcard/xxx", "文件名");
// 发送消息
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // 文件上传进度，progress 取值 [0, 100]
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // 文件消息发送成功
    }

    @Override
    public void onError(int code, String desc) {
        // 文件消息发送失败
    }
});
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: {
        // 文件消息发送成功
    } fail: { code, desc in
        // 文件消息发送失败
    }
}
// 获取本地文件路径
NSString *filePath = [[NSBundle mainBundle] pathForResource:@"test" ofType:@"mp4"];
// 创建文件消息
V2TIMMessage *message = [[V2TIMManager sharedInstance] createFileMessage:filePath fileName:@"发送文件消息"];
// 发送消息
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:@"userID"
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:^(uint32_t progress) {
    // 文件上传进度，progress 取值 [0, 100]
} succ:^{
    // 文件消息发送成功
} fail:^(int code, NSString *desc) {
    // 文件消息发送失败
}];
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_;
};

// 创建文件消息
V2TIMMessage v2TIMMessage =
    V2TIMManager::GetInstance()->GetMessageManager()->CreateFileMessage("./File/Xxx.zip", "文件名");
// 发送消息
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // 文件消息发送成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 文件消息发送失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 文件上传进度，progress 取值 [0, 100]
    });
V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(
    v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);

定位消息

定位消息会直接发送经纬度，一般需要配合地图控件显示。
示例代码如下：
Java
Swift
Objective-C
C++
// 创建定位消息
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createLocationMessage("地理位置", 0.5, 0.5);
// 发送消息
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // 定位消息不回调进度
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // 定位消息发送成功
    }

    @Override
    public void onError(int code, String desc) {
        // 定位消息发送失败
    }
});
if  let msg = V2TIMManager.shared.createLocationMessage(desc: "发送地理位置消息", 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)")
    }
}
// 创建定位消息
V2TIMMessage *message = [[V2TIMManager sharedInstance] createLocationMessage:@"发送地理位置消息" longitude:0.5 latitude:0.5];
// 发送消息
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:@"userID"
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:nil
                                      succ:^{
    // 定位消息发送成功
} fail:^(int code, NSString *desc) {
    // 定位消息发送失败
}];
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_;
};

// 创建定位消息
V2TIMMessage v2TIMMessage =
    V2TIMManager::GetInstance()->GetMessageManager()->CreateLocationMessage("地理位置", 0.5, 0.5);
// 发送消息
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // 定位消息发送成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 定位消息发送失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 定位消息不回调进度
    });
V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(
    v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);

表情消息

表情消息会直接发送表情编码，通常接收端需要将其转换成对应的表情 icon。
示例代码如下：
Java
Swift
Objective-C
C++
// 创建表情消息
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createFaceMessage(1, "tt00".getBytes());
// 发送消息
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // 表情消息不回调进度
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // 表情消息发送成功
    }

    @Override
    public void onError(int code, String desc) {
        // 表情消息发送失败
    }
});
// 创建表情消息
if  let msg = V2TIMManager.shared.createFaceMessage(index: 0, data: nil) {
    // 发送消息
    _ = V2TIMManager.shared.sendMessage(message: msg, receiver: "userID", groupID: nil, priority: .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in
    } succ: {
        // 表情消息发送成功
    } fail: { code, desc in
        // 表情消息发送失败
    }
}
// 创建表情消息
V2TIMMessage *message = [[V2TIMManager sharedInstance] createFaceMessage:1 data:[@"tt00" dataUsingEncoding:NSUTF8StringEncoding]];
// 发送消息
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:@"userID"
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:nil
                                      succ:^{
    // 表情消息发送成功
} fail:^(int code, NSString *desc) {
    // 表情消息发送失败
}];
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_;
};

// 创建表情消息
V2TIMString str = u8"tt00";
V2TIMBuffer data = {reinterpret_cast<const uint8_t*>(str.CString()), str.Size()};
V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateFaceMessage(1, data);
// 发送消息
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // 表情消息发送成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 表情消息发送失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 表情消息不回调进度
    });
V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(
    v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);

发送多个 Elem 的消息

如果您的消息需要多个 elem，可以在创建 Message 对象后，通过 Message 对象的 Elem 成员调用 appendElem (Java / Swift / Objective-C / C++) 方法添加下一个 elem 成员。
appendElem 仅支持在原有的 V2TIMElem（此 Elem 类型不限）后面追加 V2TIMTextElem、V2TIMCustomElem、V2TIMFaceElem 和 V2TIMLocationElem 四种类型的元素。 因此 “图片 + 文本”、“视频 + 文本”、“位置 + 文本” 这几种形式均可支持，但是 “图片 + 图片”、“文本 + 图片” 等不支持。
以文本消息 + 自定义消息为例，示例代码如下：
Java
Swift
Objective-C
C++
// 创建文本消息
V2TIMMessage v2TIMMessage = V2TIMManager.getMessageManager().createTextMessage("test");
// 创建自定义 elem
V2TIMCustomElem customElem = new V2TIMCustomElem();
customElem.setData("自定义消息".getBytes());
// 将自定义 elem 添加到 message.textElem 中
v2TIMMessage.getTextElem().appendElem(customElem);
// 发送消息
V2TIMManager.getMessageManager().sendMessage(v2TIMMessage, "receiver_userID", null, V2TIMMessage.V2TIM_PRIORITY_NORMAL, false, null, new V2TIMSendCallback<V2TIMMessage>() {
    @Override
    public void onProgress(int progress) {
        // 不回调进度
    }

    @Override
    public void onSuccess(V2TIMMessage message) {
        // 多 elem 消息发送成功
    }

    @Override
    public void onError(int code, String desc) {
        // 多 elem 消息发送失败
    }
});
// 创建文本消息
guard let message = V2TIMManager.shared.createTextMessage(text: "text") else {
    print("Failed to create text message.")
    return
}
// 创建自定义 elem
let customElem = V2TIMCustomElem()
customElem.data = "自定义消息".data(using: .utf8)
// 将自定义 elem 添加到 message.textElem 中
message.textElem?.appendElem(element: customElem)
// 发送消息
V2TIMManager.shared.sendMessage(message: message, receiver: "userID", groupID: nil, priority: .V2TIM_PRIORITY_DEFAULT, onlineUserOnly: false, offlinePushInfo: nil) { progress in
    // 处理发送进度
} succ: {
    // 单聊自定义消息发送成功
    print("Custom message sent successfully.")
} fail: { code, desc in
    // 单聊自定义消息发送失败
    print("Failed to send custom message: \\(code), \\(desc)")
}
// 创建文本消息
V2TIMMessage *message = [[V2TIMManager sharedInstance] createTextMessage:@"text"];

// 创建自定义 elem
V2TIMCustomElem *customElem = [[V2TIMCustomElem alloc] init];
customElem.data = [@"自定义消息" dataUsingEncoding:NSUTF8StringEncoding];

// 将自定义 elem 添加到 message.textElem 中
[message.textElem appendElem:customElem];

// 发送消息
[[V2TIMManager sharedInstance] sendMessage:message
                                  receiver:@"userID"
                                   groupID:nil
                                  priority:V2TIM_PRIORITY_DEFAULT
                            onlineUserOnly:NO
                           offlinePushInfo:nil
                                  progress:nil
                                      succ:^{
    // 多 elem 消息发送成功
} fail:^(int code, NSString *desc) {
    // 多 elem 消息发送失败
}];
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_;
};

// 创建文本消息
V2TIMMessage v2TIMMessage = V2TIMManager::GetInstance()->GetMessageManager()->CreateTextMessage("test");
// 创建自定义 elem
V2TIMCustomElem customElem;
V2TIMString str = u8"tt00";
customElem.data = {reinterpret_cast<const uint8_t*>(str.CString()), str.Size()};
// 将自定义 elem 添加到 message.elemList 中
v2TIMMessage.elemList.PushBack(&customElem);
// 发送消息
auto callback = new SendCallback{};
callback->SetCallback(
    [=](const V2TIMMessage& message) {
        // 多 elem 消息发送成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 多 elem 消息发送失败
        delete callback;
    },
    [=](uint32_t progress) {
        // 不回调进度
    });
V2TIMManager::GetInstance()->GetMessageManager()->SendMessage(
    v2TIMMessage, "receiver_userID", {}, V2TIMMessagePriority::V2TIM_PRIORITY_NORMAL, false, {}, callback);

接口限制

功能特性
限制项
限制说明
单聊/群聊
内容长度
单聊、群聊消息，单条消息最大长度限制为 12K。
发送频率
单聊消息：客户端发送单聊消息无限制；REST API 发送有频率限制，可查看相应接口的文档。
群聊消息：每个群限 40 条/秒（针对所有群类型、所有平台接口）。不同群内发消息，限频互不影响。
接收频率
单聊和群聊均无限制。
单个文件大小
发送文件消息时，SDK 最大支持发送单个文件大小为 100MB。
说明：
1. 消息数量超过限制后，后台优先下发优先级相对较高的消息，同等优先级的消息随机排序。如果同一秒内高优先级消息总数超过 40 条/秒，高优先级消息也会被抛弃。
2. 被频控限制的消息，不会下发，不会存入历史消息，但会给发送人返回成功，会触发 群内发言之前回调，但不会触发 群内发言之后回调。
3. REST API 发送群组消息接口调用限频默认为 200次/秒，与上述 “每个群发送消息限 40 条/秒” 是不同概念，请区分开。
更多限制请参见文档 使用限制。

本页内容是否解决了您的问题？
您也可以 联系销售 或 提交工单 以寻求帮助。
是
否

文档反馈