• UIKit
  • SDK
  • 服务端 API
Chat/
SDK/
Android/
消息/
SDK
  • 概述
    • 产品概述
    • 定价
      • 账单概览
      • Chat 包月套餐
      • Chat 增值计费说明
  • 快速开始
    • 集成 SDK
    • 初始化 SDK
    • 登录登出
  • 消息
    • 介绍
    • 发送消息
    • 接收消息
    • 历史消息
    • 转发消息
    • 消息变更
    • 插入消息
    • 删除消息
    • 清空消息
    • 撤回消息
    • 在线消息
    • 已读回执
    • 查询消息
    • 群 @ 消息
    • 群定向消息
    • 消息免打扰
    • 消息扩展
    • 消息回应
    • 消息翻译
    • 消息置顶
  • 会话
    • 介绍
    • 会话列表
    • 获取会话
    • 会话未读数
    • 置顶会话
    • 删除会话
    • 会话草稿
    • 会话标记
    • 会话分组
  • 群组
    • 介绍
    • 管理群组
    • 群资料
    • 管理群成员
    • 群成员资料
    • 自定义属性
    • 群计数器
  • 社群话题
    • 管理社群
    • 权限组
  • 用户
    • 用户资料
    • 用户状态
    • 管理好友
    • 好友分组
    • 黑名单
    • 关注与粉丝
  • 本地搜索
    • 搜索消息
    • 搜索好友
    • 搜索群组
    • 搜索群成员
  • 信令
  • 客户端 API
    • Java
  • 更新日志
  • 生成 UserSig
  • 控制台指南
    • New Console Introduction
    • 创建和升级应用
    • 基本配置
    • 功能配置
    • 账号管理
    • 群组管理
    • 回调配置
    • 用量统计
    • 实时监控
    • 开发辅助工具
  • 产品介绍
    • 消息管理
      • 单聊消息
      • 消息存储
      • 离线推送
      • 群消息
      • 消息格式
    • 账号系统
      • 登陆验证
      • 在线状态管理
    • 群相关
      • 群组系统
      • 群组管理
    • 用户资料和关系链
      • 资料管理
      • 关系链管理
  • 推送服务（Push）
    • 服务概述
    • 开通服务
    • 快速跑通
    • 厂商通道
      • 厂商配置
        • Android
        • iOS
        • Flutter
        • React-Native
      • 快速接入
        • Android
        • iOS
        • Flutter
        • React-Native
    • 数据统计
    • 排查工具
    • 客户端 API
      • Android
      • iOS
      • Flutter
      • React Native
    • 服务端 API
      • 发起全员/标签推送
      • 单发推送
      • 获取应用属性名称
      • 设置应用属性名称
      • 获取用户属性
      • 设置用户属性
      • 删除用户属性
      • 获取用户标签
      • 添加用户标签
      • 删除用户标签
      • 清空用户标签
      • 推送撤回
    • 推送回调
      • 全员/标签/单发回调
      • 其他推送回调
    • 高级功能
      • 自定义角标
      • 自定义铃音
      • 自定义小图标
      • 自定义点击跳转
      • 推送消息分类
    • 更新日志
      • Android
      • iOS
      • Flutter
      • React Native
    • 常见问题
  • 错误码
文档概览/
Chat/
SDK/
Android/
消息/
发送消息/

发送消息

功能描述

发送消息方法在核心类 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. 在消息回调中获取消息是否发送成功或失败。

图片消息

创建图片消息需要先获取到本地图片路径。 发送消息过程中，会先将图片文件上传至服务器，同时回调上传进度。上传成功后再发送消息。
示例代码如下：
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 条/秒” 是不同概念，请区分开。
更多限制请参见文档 使用限制。

WebRTC Trtc Logo
Copyright © 2013-2025 Tencent RTC. All Rights Reserved.
  1. 隐私条款
  3. 法律
  5. Cookie政策
  7. 腾讯云
向社区提问！
开始技术讨论并获取即时专家支持！