SDK

import TencentCloudChat from '@tencentcloud/chat';
import TIMUploadPlugin from 'tim-upload-plugin';

// 创建 SDK 实例，TencentCloudChat.create() 方法对于同一个 SDKAppID 只会返回同一份实例
let options = {
  SDKAppID: 0 // 接入时需要将0替换为您的即时通信应用的 SDKAppID
};
let chat = TencentCloudChat.create(options); // SDK 实例通常用 chat 表示
// 设置 SDK 日志输出级别，详细分级请参见 setLogLevel 接口的说明
chat.setLogLevel(0); // 普通级别，日志量较多，接入时建议使用
// chat.setLogLevel(1); // release级别，SDK 输出关键信息，生产环境时建议使用

// 注册腾讯云即时通信 IM 上传插件，即时通信 IM SDK 发送图片、语音、视频、文件等消息需要使用上传插件，将文件上传到腾讯云对象存储
chat.registerPlugin({'tim-upload-plugin': TIMUploadPlugin});

// 如果您使用 uni-app 开发 app，并有推送需求，请使用 [uni-app 腾讯云推送服务（Push）](https://cloud.tencent.com/document/product/269/103522)
// 如果您使用 react-native 开发 app，并有推送需求，请使用 [react-native 腾讯云推送服务（Push）](https://cloud.tencent.com/document/product/269/104005)

// 监听事件，如：
chat.on(TencentCloudChat.EVENT.SDK_READY, function(event) {
  // 收到离线消息和会话列表同步完毕通知，接入侧可以调用 sendMessage 等需要鉴权的接口
  // event.name - TencentCloudChat.EVENT.SDK_READY
});

chat.on(TencentCloudChat.EVENT.MESSAGE_RECEIVED, function(event) {
  // 收到推送的单聊、群聊、群提示、群系统通知的新消息，可通过遍历 event.data 获取消息列表数据并渲染到页面
  // event.name - TencentCloudChat.EVENT.MESSAGE_RECEIVED
  // event.data - 存储 Message 对象的数组 - [Message]
});

chat.on(TencentCloudChat.EVENT.MESSAGE_MODIFIED, function(event) {
  // 收到消息被第三方回调修改的通知，消息发送方可通过遍历 event.data 获取消息列表数据并更新页面上同 ID 消息的内容
  // event.name - TencentCloudChat.EVENT.MESSAGE_MODIFIED
  // event.data - 存储被第三方回调修改过的 Message 对象的数组 - [Message]
});

chat.on(TencentCloudChat.EVENT.MESSAGE_REVOKED, function(event) {
  // 收到消息被撤回的通知。
  // event.name - TencentCloudChat.EVENT.MESSAGE_REVOKED
  // event.data - 存储 Message 对象的数组 - [Message] - 每个 Message 对象的 isRevoked 属性值为 true
});

chat.on(TencentCloudChat.EVENT.MESSAGE_READ_BY_PEER, function(event) {
  // SDK 收到对端已读消息的通知，即已读回执。
  // event.name - TencentCloudChat.EVENT.MESSAGE_READ_BY_PEER
  // event.data - event.data - 存储 Message 对象的数组 - [Message] - 每个 Message 对象的 isPeerRead 属性值为 true
});

chat.on(TencentCloudChat.EVENT.CONVERSATION_LIST_UPDATED, function(event) {
  // 收到会话列表更新通知，可通过遍历 event.data 获取会话列表数据并渲染到页面
  // event.name - TencentCloudChat.EVENT.CONVERSATION_LIST_UPDATED
  // event.data - 存储 Conversation 对象的数组 - [Conversation]
});

chat.on(TencentCloudChat.EVENT.GROUP_LIST_UPDATED, function(event) {
  // 收到群组列表更新通知，可通过遍历 event.data 获取群组列表数据并渲染到页面
  // event.name - TencentCloudChat.EVENT.GROUP_LIST_UPDATED
  // event.data - 存储 Group 对象的数组 - [Group]
});

chat.on(TencentCloudChat.EVENT.PROFILE_UPDATED, function(event) {
  // 收到自己或好友的资料变更通知
  // event.name - TencentCloudChat.EVENT.PROFILE_UPDATED
  // event.data - 存储 Profile 对象的数组 - [Profile]
});

chat.on(TencentCloudChat.EVENT.BLACKLIST_UPDATED, function(event) {
  // 收到黑名单列表更新通知
  // event.name - TencentCloudChat.EVENT.BLACKLIST_UPDATED
  // event.data - 存储 userID 的数组 - [userID]
});

chat.on(TencentCloudChat.EVENT.SDK_NOT_READY, function(event) {
  // 收到 SDK 进入 not ready 状态通知，此时 SDK 无法正常工作
  // event.name - TencentCloudChat.EVENT.SDK_NOT_READY
});

chat.on(TencentCloudChat.EVENT.KICKED_OUT, function(event) {
  // 收到被踢下线通知
  // event.name - TencentCloudChat.EVENT.KICKED_OUT
  // event.data.type - 被踢下线的原因，例如 :
  //   - TencentCloudChat.TYPES.KICKED_OUT_MULT_ACCOUNT 多实例登录被踢
  //   - TencentCloudChat.TYPES.KICKED_OUT_MULT_DEVICE 多终端登录被踢
  //   - TencentCloudChat.TYPES.KICKED_OUT_USERSIG_EXPIRED 签名过期被踢
  //   - TencentCloudChat.TYPES.KICKED_OUT_REST_API(REST API kick 接口踢出。)
});

chat.on(TencentCloudChat.EVENT.NET_STATE_CHANGE, function(event) {
  // 网络状态发生改变
  // event.name - TencentCloudChat.EVENT.NET_STATE_CHANGE
  // event.data.state 当前网络状态，枚举值及说明如下：
  //   - TencentCloudChat.TYPES.NET_STATE_CONNECTED - 已接入网络
  //   - TencentCloudChat.TYPES.NET_STATE_CONNECTING - 连接中。很可能遇到网络抖动，SDK 在重试。接入侧可根据此状态提示“当前网络不稳定”或“连接中”
  //   - TencentCloudChat.TYPES.NET_STATE_DISCONNECTED - 未接入网络。接入侧可根据此状态提示“当前网络不可用”。SDK 仍会继续重试，若用户网络恢复，SDK 会自动同步消息
});

chat.on(TencentCloudChat.EVENT.FRIEND_LIST_UPDATED, function(event) {
  // 收到好友列表更新通知
  // event.name - TencentCloudChat.EVENT.FRIEND_LIST_UPDATED
  // event.data - 存储 Friend 对象的数组 - [Friend]
});

chat.on(TencentCloudChat.EVENT.FRIEND_APPLICATION_LIST_UPDATED, function(event) {
  // 收到好友申请列表更新通知
  // event.name - TencentCloudChat.EVENT.FRIEND_APPLICATION_LIST_UPDATED
  // friendApplicationList - 好友申请列表 - [FriendApplication]
  // unreadCount - 好友申请的未读数
  // const { friendApplicationList, unreadCount } = event.data;
  // 发送给我的好友申请（即别人申请加我为好友）
  // const applicationSentToMe = friendApplicationList.filter((friendApplication) => friendApplication.type === TencentCloudChat.TYPES.SNS_APPLICATION_SENT_TO_ME);
  // 我发送出去的好友申请（即我申请加别人为好友）
  // const applicationSentByMe = friendApplicationList.filter((friendApplication) => friendApplication.type === TencentCloudChat.TYPES.SNS_APPLICATION_SENT_BY_ME);
});

chat.on(TencentCloudChat.EVENT.FRIEND_GROUP_LIST_UPDATED, function(event) {
  // 收到好友分组列表更新通知
  // event.name - TencentCloudChat.EVENT.FRIEND_GROUP_LIST_UPDATED
  // event.data - 存储 FriendGroup 对象的数组 - [FriendGroup]
});

// 开始登录
chat.login({userID: 'your userID', userSig: 'your userSig'});

Methods

login(options) → {Promise}

Example

let promise = chat.login({userID: 'your userID', userSig: 'your userSig'});
promise.then(function(imResponse) {
  console.log(imResponse.data); // 登录成功
  if (imResponse.data.repeatLogin === true) {
    // 标识账号已登录，本次登录操作为重复登录。
    console.log(imResponse.data.errorInfo);
  }
}).catch(function(imError) {
  console.warn('login error:', imError); // 登录失败的相关信息
});

Parameters:

Returns:

Type

Promise

logout() → {Promise}

Example

let promise = chat.logout();
promise.then(function(imResponse) {
  console.log(imResponse.data); // 登出成功
}).catch(function(imError) {
  console.warn('logout error:', imError);
});

Returns:

Type

Promise

getLoginUser() → {String}

Example

const userID = chat.getLoginUser();

Returns:

Type

String

getServerTime() → {Number}

Example

const serverTime = chat.getServerTime();

Returns:

Type

Number

isReady() → {Boolean}

Example

let isReady = chat.isReady();

Returns:

Type

Boolean

destroy() → {Promise}

Example

let promise = chat.destroy();

Returns:

Type

Promise

on(eventName, handler, contextopt)

Example

let onMessageReceived = function(event) {
  // 收到推送的单聊、群聊、群提示、群系统通知的新消息，可通过遍历 event.data 获取消息列表数据并渲染到页面
  // event.name - TencentCloudChat.EVENT.MESSAGE_RECEIVED
  // event.data - 存储 Message 对象的数组 - [Message]
};
chat.on(TencentCloudChat.EVENT.MESSAGE_RECEIVED, onMessageReceived);

Parameters:

off(eventName, handler, contextopt, onceopt)

Example

let onMessageReceived = function(event) {
  // 收到推送的单聊、群聊、群提示、群系统通知的新消息，可通过遍历 event.data 获取消息列表数据并渲染到页面
  // event.name - TencentCloudChat.EVENT.MESSAGE_RECEIVED
  // event.data - 存储 Message 对象的数组 - [Message]
};
chat.off(TencentCloudChat.EVENT.MESSAGE_RECEIVED, onMessageReceived);

Parameters:

registerPlugin(options)

 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
 <uses-permission android:name="android.permission.RECORD_AUDIO" />

<key>NSCameraUsageDescription</key>
<string>我们需要访问您的相机以拍摄照片</string>
<key>NSPhotoLibraryUsageDescription</key>
<string>我们需要访问您的相册以选择照片</string>
<key>NSMicrophoneUsageDescription</key>
<string>我们需要访问您的麦克风以录制音频</string>

Examples

// 小程序端使用 tim-upload-plugin，在小程序管理后台增加 uploadFile 域名配置 https://cos.ap-shanghai.myqcloud.com，增加 downloadFile 域名配置 https://cos.ap-shanghai.myqcloud.com
chat.registerPlugin({'tim-upload-plugin': TIMUploadPlugin});

// 在 React Native 项目中注册网络状态监听插件[@react-native-community/netinfo](https://www.npmjs.com/package/@react-native-community/netinfo)

npm install @react-native-community/netinfo --save

import NetInfo from "@react-native-community/netinfo";

chat.registerPlugin({'chat-network-monitor': NetInfo});

Parameters:

setLogLevel(level)

Example

chat.setLogLevel(0);

Parameters:

createTextMessage(options) → {Message}

Examples

// 发送文本消息，Web 端与小程序端相同
// 1. 创建消息实例，接口返回的实例可以上屏
let message = chat.createTextMessage({
  to: 'user1',
  conversationType: TencentCloudChat.TYPES.CONV_C2C,
  // 消息优先级，用于群聊。如果某个群的消息超过了频率限制，后台会优先下发高优先级的消息，详细请参考：https://cloud.tencent.com/document/product/269/3663#.E6.B6.88.E6.81.AF.E4.BC.98.E5.85.88.E7.BA.A7.E4.B8.8E.E9.A2.91.E7.8E.87.E6.8E.A7.E5.88.B6)
  // 支持的枚举值：TencentCloudChat.TYPES.MSG_PRIORITY_HIGH, TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL（默认）, TencentCloudChat.TYPES.MSG_PRIORITY_LOW, TencentCloudChat.TYPES.MSG_PRIORITY_LOWEST
  // priority: TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL,
  payload: {
    text: 'Hello world!'
  },
  // 支持C2C消息已读回执功能，如果您发消息需要已读回执，需购买旗舰版套餐，并且创建消息时将 needReadReceipt 设置为 true
  needReadReceipt: true
  // 消息自定义数据（云端保存，会发送到对端，程序卸载重装后还能拉取到）
  // cloudCustomData: 'your cloud custom data'
});
// 2. 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

// 发送群消息
let message = chat.createTextMessage({
  to: 'test',
  conversationType: TencentCloudChat.TYPES.CONV_GROUP,
  payload: {
    text: 'Hello world!'
  },
  // 支持群消息已读回执功能，如果您发消息需要已读回执，需购买旗舰版套餐，并且创建消息时将 needReadReceipt 设置为 true
  needReadReceipt: true
});
// 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

// 向社群（不支持话题）发消息
let message = chat.createTextMessage({
  to: '@TGS#_@TGS#cWWFWHIM62CL', // 社群 ID
  conversationType: TencentCloudChat.TYPES.CONV_GROUP,
  payload: {
    text: 'Hello world!'
  },
  // 如果您发消息需要已读回执，需购买旗舰版套餐，并且创建消息时将 needReadReceipt 设置为 true
  needReadReceipt: true
});
// 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

// 向话题（Topic）发消息
let message = chat.createTextMessage({
  to: '@TGS#_@TGS#cWWFWHIM62CL@TOPIC#_@TOPIC#cXWFWHIM62CR', // 话题 ID
  conversationType: TencentCloudChat.TYPES.CONV_GROUP,
  payload: {
    text: 'Hello world!'
  },
});
// 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

// 发送群定向消息
// 注意：群定向消息不计入会话未读，receiverList 最大支持50个接收者。
let message = chat.createTextMessage({
  to: 'test',
  conversationType: TencentCloudChat.TYPES.CONV_GROUP,
  payload: {
    text: 'Hello world!'
  },
  // 如果您需要发群定向消息，需购买旗舰版套餐，并且创建消息时通过 receiverList 指定消息接收者
  receiverList: ['user0', 'user1']
});
// 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

// 发送支持消息扩展的群消息
let message = chat.createTextMessage({
  to: 'test',
  conversationType: TencentCloudChat.TYPES.CONV_GROUP,
  payload: {
    text: 'Hello world!'
  },
  // 如果您发消息需要支持扩展，需购买旗舰版套餐，并且创建消息时将 isSupportExtension 设置为 true
  isSupportExtension: true
});
// 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

// 自定义消息审核策略
let message = chat.createTextMessage({
  to: 'test',
  conversationType: TencentCloudChat.TYPES.CONV_GROUP,
  payload: {
    text: 'Hello world!'
  },
  customModerationConfigurationID: 'Custom11',
});
// 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

Parameters:

Returns:

Type

Message

createTextAtMessage(options) → {Message}

Example

// 发送文本消息，Web 端与小程序端相同
// 1. 创建消息实例，接口返回的实例可以上屏
let message = chat.createTextAtMessage({
  to: 'group1',
  conversationType: TencentCloudChat.TYPES.CONV_GROUP,
  // 消息优先级，用于群聊。如果某个群的消息超过了频率限制，后台会优先下发高优先级的消息，详细请参考：https://cloud.tencent.com/document/product/269/3663#.E6.B6.88.E6.81.AF.E4.BC.98.E5.85.88.E7.BA.A7.E4.B8.8E.E9.A2.91.E7.8E.87.E6.8E.A7.E5.88.B6)
  // 支持的枚举值：TencentCloudChat.TYPES.MSG_PRIORITY_HIGH, TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL（默认）, TencentCloudChat.TYPES.MSG_PRIORITY_LOW, TencentCloudChat.TYPES.MSG_PRIORITY_LOWEST
  // priority: TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL,
  payload: {
    text: '@denny @lucy @所有人 今晚聚餐，收到的请回复1',
    atUserList: ['denny', 'lucy', TencentCloudChat.TYPES.MSG_AT_ALL] // 'denny' 'lucy' 都是 userID，而非昵称
  },
  // 消息自定义数据（云端保存，会发送到对端，程序卸载重装后还能拉取到）
  // cloudCustomData: 'your cloud custom data'
});
// 2. 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

Parameters:

Returns:

Type

Message

createImageMessage(options) → {Message}

Examples

// Web 端发送图片消息示例1 - 传入 DOM 节点
// 1. 创建消息实例，接口返回的实例可以上屏
let message = chat.createImageMessage({
  to: 'user1',
  conversationType: TencentCloudChat.TYPES.CONV_C2C,
  // 消息优先级，用于群聊。如果某个群的消息超过了频率限制，后台会优先下发高优先级的消息，详细请参考：https://cloud.tencent.com/document/product/269/3663#.E6.B6.88.E6.81.AF.E4.BC.98.E5.85.88.E7.BA.A7.E4.B8.8E.E9.A2.91.E7.8E.87.E6.8E.A7.E5.88.B6)
  // 支持的枚举值：TencentCloudChat.TYPES.MSG_PRIORITY_HIGH, TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL（默认）, TencentCloudChat.TYPES.MSG_PRIORITY_LOW, TencentCloudChat.TYPES.MSG_PRIORITY_LOWEST
  // priority: TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL,
  payload: {
    file: document.getElementById('imagePicker'),
  },
  // 消息自定义数据（云端保存，会发送到对端，程序卸载重装后还能拉取到）
  // cloudCustomData: 'your cloud custom data'
  onProgress: function(event) { console.log('file uploading:', event) }
});

// 2. 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

// Web 端发送图片消息示例2- 传入 File 对象
// 先在页面上添加一个 id 为 "testPasteInput" 的消息输入框，如 <input type="text" id="testPasteInput" placeholder="截图后粘贴到输入框中" size="30" />
document.getElementById('testPasteInput').addEventListener('paste', function(e) {
  let clipboardData = e.clipboardData;
  let file;
  let fileCopy;
  if (clipboardData && clipboardData.files && clipboardData.files.length > 0) {
    file = clipboardData.files[0];
    // 图片消息发送成功后，file 指向的内容可能被浏览器清空，如果接入侧有额外的渲染需求，可以提前复制一份数据
    fileCopy = file.slice();
  }

  if (typeof file === 'undefined') {
    console.warn('file 是 undefined，请检查代码或浏览器兼容性！');
    return;
  }

  // 1. 创建消息实例，接口返回的实例可以上屏
  let message = chat.createImageMessage({
    to: 'user1',
    conversationType: TencentCloudChat.TYPES.CONV_C2C,
    payload: {
      file: file
    },
    onProgress: function(event) { console.log('file uploading:', event) }
  });

  // 2. 发送消息
  let promise = chat.sendMessage(message);
  promise.then(function(imResponse) {
    // 发送成功
    console.log(imResponse);
  }).catch(function(imError) {
    // 发送失败
    console.warn('sendMessage error:', imError);
  });
});

// 小程序端发送图片（微信小程序从基础库 2.21.0 开始，wx.chooseImage 接口停止维护，请使用 wx.chooseMedia 代替）
// 1. 选择图片
wx.chooseMedia({
  mediaType: ['image'], // 图片
  sourceType: ['album'], // 从相册选择
  count: 1, // 只选一张，目前 SDK 不支持一次发送多张图片
  success: function (res) {
    // 2. 创建消息实例，接口返回的实例可以上屏
    let message = chat.createImageMessage({
      to: 'user1',
      conversationType: TencentCloudChat.TYPES.CONV_C2C,
      payload: { file: res },
      onProgress: function(event) { console.log('file uploading:', event) }
    });
    // 3. 发送图片
    let promise = chat.sendMessage(message);
    promise.then(function(imResponse) {
      // 发送成功
      console.log(imResponse);
    }).catch(function(imError) {
      // 发送失败
      console.warn('sendMessage error:', imError);
    });
  }
})

// uni-app 发送图片
// 微信小程序从基础库 2.21.0 开始， wx.chooseImage 停止维护，请使用 uni.chooseMedia 代替
// 1. 选择图片
uni.chooseMedia({
  count: 1,
  mediaType: ['image'], // 图片
  sizeType: ['original', 'compressed'], // 可以指定是原图还是压缩图，默认二者都有
  sourceType: ['album'], // 从相册选择
  success: function(res) {
    let message = chat.createImageMessage({
      to: 'user1',
      conversationType: TencentCloudChat.TYPES.CONV_C2C,
      payload: { file: res },
      onProgress: function(event) { console.log('file uploading:', event) }
    });
    // 2. 发送消息
    let promise = chat.sendMessage(message);
    promise.then(function(imResponse) {
      // 发送成功
      console.log(imResponse);
    }).catch(function(imError) {
      // 发送失败
      console.warn('sendMessage error:', imError);
    });
  }
});

// 微信小程序、uni-app 使用 chooseMedia 同时选择图片和视频
uni.chooseMedia({
  count: 9,
  mediaType: ['mix'], // 图片和视频
  sizeType: ['original', 'compressed'], // 可以指定是否压缩
  sourceType: ['album'], // 从相册选择
  success: function(res) {
    res.tempFiles.forEach(function(file) {
      const _file = { tempFiles: [file] };
      if (file.fileType === 'image') {
        let message = chat.createImageMessage({
           to: 'user1',
           conversationType: TencentCloudChat.TYPES.CONV_C2C,
           payload: { file: _file },
           onProgress: function(event) { console.log('file uploading:', event) }
        });
        // 发送消息
        let promise = chat.sendMessage(message);
        promise.then(function(imResponse) {
           // 发送成功
           console.log(imResponse);
        }).catch(function(imError) {
           // 发送失败
           console.warn('sendMessage error:', imError);
        });
      };
      if (file.fileType === 'video') {
        let message = chat.createVideoMessage({
           to: 'user1',
           conversationType: TencentCloudChat.TYPES.CONV_C2C,
           payload: { file: _file },
           onProgress: function(event) { console.log('file uploading:', event) }
        });
        // 发送消息
        let promise = chat.sendMessage(message);
        promise.then(function(imResponse) {
           // 发送成功
           console.log(imResponse);
        }).catch(function(imError) {
           // 发送失败
           console.warn('sendMessage error:', imError);
        });
      };
   }
});

// React Native 项目中发送图片需要使用 [react-native-image-picker](https://www.npmjs.com/package/react-native-image-picker)
import {launchCamera, launchImageLibrary} from 'react-native-image-picker';

// 1. 选择图片
launchImageLibrary({
  mediaType: 'photo',
  selectionLimit: 1,
}).then((result) => {
 const file = result.assets[0];
 // 2. 创建消息实例，接口返回的实例可以上屏
 let message = chat.createImageMessage({
    to: 'user1',
    conversationType: TencentCloudChat.TYPES.CONV_C2C,
    payload: { file: file },
    // React Native 不支持上传进度回调
    // onProgress: function(event) { console.log('file uploading:', event) }
  });
  // 3. 发送图片
  let promise = chat.sendMessage(message);
  promise.then(function(imResponse) {
    // 发送成功
    console.log(imResponse);
  }).catch(function(imError) {
    // 发送失败
    console.warn('sendMessage error:', imError);
  });
});

// 1. 拍照
launchCamera({
  mediaType: 'photo',
  cameraType: 'back',
}).then((result) => {
 const file = result.assets[0];
 // 2. 创建消息实例，接口返回的实例可以上屏
 let message = chat.createImageMessage({
    to: 'user1',
    conversationType: TencentCloudChat.TYPES.CONV_C2C,
    payload: { file: file },
    // React Native 不支持上传进度回调
    // onProgress: function(event) { console.log('file uploading:', event) }
  });
  // 3. 发送图片
  let promise = chat.sendMessage(message);
  promise.then(function(imResponse) {
    // 发送成功
    console.log(imResponse);
  }).catch(function(imError) {
    // 发送失败
    console.warn('sendMessage error:', imError);
  });
});

Parameters:

Returns:

Type

Message

createAudioMessage(options) → {Message}

Examples

// 示例：使用微信官方的 RecorderManager 进行录音，参考 https://developers.weixin.qq.com/minigame/dev/api/media/recorder/RecorderManager.start.html
// 1. 获取全局唯一的录音管理器 RecorderManager
const recorderManager = wx.getRecorderManager();

// 录音部分参数
const recordOptions = {
  duration: 60000, // 录音的时长，单位 ms，最大值 600000（10 分钟）
  sampleRate: 44100, // 采样率
  numberOfChannels: 1, // 录音通道数
  encodeBitRate: 192000, // 编码码率
  format: 'aac' // 音频格式，选择此格式创建的音频消息，可以在即时通信 IM 全平台（Android、iOS、微信小程序和Web）互通
};

// 2.1 监听录音错误事件
recorderManager.onError(function(errMsg) {
  console.warn('recorder error:', errMsg);
});
// 2.2 监听录音结束事件，录音结束后，调用 createAudioMessage 创建音频消息实例
recorderManager.onStop(function(res) {
  console.log('recorder stop', res);

  // 4. 创建消息实例，接口返回的实例可以上屏
  const message = chat.createAudioMessage({
    to: 'user1',
    conversationType: TencentCloudChat.TYPES.CONV_C2C,
    // 消息优先级，用于群聊。如果某个群的消息超过了频率限制，后台会优先下发高优先级的消息，详细请参考：https://cloud.tencent.com/document/product/269/3663#.E6.B6.88.E6.81.AF.E4.BC.98.E5.85.88.E7.BA.A7.E4.B8.8E.E9.A2.91.E7.8E.87.E6.8E.A7.E5.88.B6)
    // 支持的枚举值：TencentCloudChat.TYPES.MSG_PRIORITY_HIGH, TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL（默认）, TencentCloudChat.TYPES.MSG_PRIORITY_LOW, TencentCloudChat.TYPES.MSG_PRIORITY_LOWEST
    // priority: TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL,
    payload: {
      file: res
    },
    // 消息自定义数据（云端保存，会发送到对端，程序卸载重装后还能拉取到）
    // cloudCustomData: 'your cloud custom data'
    // 音频上传进度回调
    onProgress: function(event) { console.log('file uploading:', event) }
  });

  // 5. 发送消息
  let promise = chat.sendMessage(message);
  promise.then(function(imResponse) {
    // 发送成功
    console.log(imResponse);
  }).catch(function(imError) {
    // 发送失败
    console.warn('sendMessage error:', imError);
  });
});

// 3. 开始录音
recorderManager.start(recordOptions);

// 在 Web 端创建语音消息并发送
// 示例：使用第三方库 js-audio-recorder 录制音频
// 1. 开始录制
let recorder = new Recorder({
  sampleBits: 16,                 // 采样位数，支持 8 或 16，默认是16
  sampleRate: 16000,              // 采样率，支持 11025、16000、22050、24000、44100、48000，根据浏览器默认值，我的chrome是48000
  numChannels: 1,                 // 声道，支持 1 或 2， 默认是1
});
let startTs;
recorder.start().then(() => {
  // 开始录音，记录起始时间戳
  startTs = Date.now();
}, (error) => {
  // 出错了
  console.log(`${error.name} : ${error.message}`);
});

// 2. 结束录制
recorder.stop();

// 3. 计算录音时长，获取 WAV 数据
let duration = Date.now() - startTs; // 单位：ms
let wavBlob = recorder.getWAVBlob();

// 4. blob 数据转成 File 对象
let audioFile = new File([wavBlob], 'hello.wav', { type: 'wav' });
audioFile.uri = window.URL.createObjectURL(audioFile);
audioFile.duration = duration;

// 5. 创建音频消息
let message = chat.createAudioMessage({
  to: 'user1',
  conversationType: 'C2C',
  payload: {
    file: audioFile
  },
  // 音频上传进度回调
  onProgress: function(event) { console.log('file uploading:', event) }
});

// 6. 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

// React Native 项目中发送语音需要使用 [react-native-audio-recorder-player](https://www.npmjs.com/package/react-native-audio-recorder-player) 录制语音。
import AudioRecorderPlayer from 'react-native-audio-recorder-player';

// 记录录音时长，单位：ms
let duration = 0;
// 记录录音文件路径
let uri = '';

// 1. 开始录音
const onStartRecord = async () => {
  await audioRecorderPlayer.startRecorder();
  audioRecorderPlayer.addRecordBackListener((e: any) => {
    duration = e.currentPosition;
  });
};
// 2. 结束录音
const onStopRecord = async () => {
  uri = await audioRecorderPlayer.stopRecorder();
  audioRecorderPlayer.removeRecordBackListener();
};
// 3. 发送语音
const file = {
  uri: uri,
  duration: duration,
};
let message = chat.createAudioMessage({
  to: 'user1',
  conversationType: 'C2C',
  payload: {
    file: file,
  },
  // React Native 不支持上传进度回调
  // onProgress: function(event) { console.log('file uploading:', event) }
});
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

Parameters:

Returns:

Type

Message

createVideoMessage(options) → {Message}

Examples

// 小程序端发送视频消息示例（微信小程序从基础库 2.21.0 开始， wx.chooseVideo 停止维护，请使用 wx.chooseMedia 代替）：
// 1. 调用小程序接口选择视频，接口详情请查阅 https://developers.weixin.qq.com/miniprogram/dev/api/media/video/wx.chooseMedia.html
wx.chooseMedia({
  mediaType: ['video'], // 视频
  sourceType: ['album', 'camera'], // 来源相册或者拍摄
  maxDuration: 60, // 设置最长时间60s
  camera: 'back', // 后置摄像头
  success (res) {
    // 2. 创建消息实例，接口返回的实例可以上屏
    let message = chat.createVideoMessage({
      to: 'user1',
      conversationType: TencentCloudChat.TYPES.CONV_C2C,
      // 消息优先级，用于群聊。如果某个群的消息超过了频率限制，后台会优先下发高优先级的消息，详细请参考：https://cloud.tencent.com/document/product/269/3663#.E6.B6.88.E6.81.AF.E4.BC.98.E5.85.88.E7.BA.A7.E4.B8.8E.E9.A2.91.E7.8E.87.E6.8E.A7.E5.88.B6)
      // 支持的枚举值：TencentCloudChat.TYPES.MSG_PRIORITY_HIGH, TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL（默认）, TencentCloudChat.TYPES.MSG_PRIORITY_LOW, TencentCloudChat.TYPES.MSG_PRIORITY_LOWEST
      // priority: TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL,
      payload: {
        file: res
      },
      // 消息自定义数据（云端保存，会发送到对端，程序卸载重装后还能拉取到）
      // cloudCustomData: 'your cloud custom data'
      // 支持小程序端视频上传进度回调
      onProgress: function(event) { console.log('file uploading:', event) }
    })
    // 3. 发送消息
    let promise = chat.sendMessage(message);
    promise.then(function(imResponse) {
      // 发送成功
      console.log(imResponse);
    }).catch(function(imError) {
      // 发送失败
      console.warn('sendMessage error:', imError);
    });
  }
})

// web 端发送视频消息示例：
// 1. 获取视频：传入 DOM 节点
// 2. 创建消息实例
const message = chat.createVideoMessage({
  to: 'user1',
  conversationType: TencentCloudChat.TYPES.CONV_C2C,
  payload: {
    file: document.getElementById('videoPicker') // 或者用event.target
  },
  onProgress: function(event) { console.log('file uploading:', event) }
});
// 3. 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

// uni-app 发送视频
// 微信小程序从基础库 2.21.0 开始， wx.chooseVideo 停止维护，请使用 uni.chooseMedia 代替
// 1. 选择视频
uni.chooseMedia({
  mediaType: ['video'], // 视频
  count: 1,
  sourceType: ['camera', 'album'], // album 从相册选视频，camera 使用相机拍摄，默认为：['album', 'camera']
  maxDuration: 60, // 设置最长时间60s
  camera: 'back', // 后置摄像头
  success: function(res) {
    let message = chat.createVideoMessage({
      to: 'user1',
      conversationType: TencentCloudChat.TYPES.CONV_C2C,
      payload: { file: res },
      onProgress: function(event) { console.log('file uploading:', event) }
    });
    // 2. 发送消息
    let promise = chat.sendMessage(message);
    promise.then(function(imResponse) {
      // 发送成功
      console.log(imResponse);
    }).catch(function(imError) {
      // 发送失败
      console.warn('sendMessage error:', imError);
    });
  }
})

// React Native 项目中发送视频需要使用 [react-native-image-picker](https://www.npmjs.com/package/react-native-image-picker)
import {launchCamera, launchImageLibrary} from 'react-native-image-picker';

// 1. 选择视频
launchImageLibrary({
  mediaType: 'video',
  selectionLimit: 1,
}).then((result) => {
 const file = result.assets[0];
 // 2. 创建消息实例，接口返回的实例可以上屏
 let message = chat.createVideoMessage({
    to: 'user1',
    conversationType: TencentCloudChat.TYPES.CONV_C2C,
    payload: { file: file },
    // React Native 不支持上传进度回调
    // onProgress: function(event) { console.log('file uploading:', event) }
  });
  // 3. 发送视频
  let promise = chat.sendMessage(message);
  promise.then(function(imResponse) {
    // 发送成功
    console.log(imResponse);
  }).catch(function(imError) {
    // 发送失败
    console.warn('sendMessage error:', imError);
  });
});

// 1. 拍摄视频
launchCamera({
  mediaType: 'video',
  cameraType: 'back',
}).then((result) => {
 const file = result.assets[0];
 // 2. 创建消息实例，接口返回的实例可以上屏
 let message = chat.createVideoMessage({
    to: 'user1',
    conversationType: TencentCloudChat.TYPES.CONV_C2C,
    payload: { file: file },
    // React Native 不支持上传进度回调
    // onProgress: function(event) { console.log('file uploading:', event) }
  });
  // 3. 发送视频
  let promise = chat.sendMessage(message);
  promise.then(function(imResponse) {
    // 发送成功
    console.log(imResponse);
  }).catch(function(imError) {
    // 发送失败
    console.warn('sendMessage error:', imError);
  });
});

Parameters:

Returns:

Type

Message

createCustomMessage(options) → {Message}

Example

// 示例：利用自定义消息实现投骰子功能
// 1. 定义随机函数
function random(min, max) {
  return Math.floor(Math.random() * (max - min + 1) + min);
}
// 2. 创建消息实例，接口返回的实例可以上屏
let message = chat.createCustomMessage({
  to: 'user1',
  conversationType: TencentCloudChat.TYPES.CONV_C2C,
  // 消息优先级，用于群聊。如果某个群的消息超过了频率限制，后台会优先下发高优先级的消息，详细请参考：https://cloud.tencent.com/document/product/269/3663#.E6.B6.88.E6.81.AF.E4.BC.98.E5.85.88.E7.BA.A7.E4.B8.8E.E9.A2.91.E7.8E.87.E6.8E.A7.E5.88.B6)
  // 支持的枚举值：TencentCloudChat.TYPES.MSG_PRIORITY_HIGH, TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL（默认）, TencentCloudChat.TYPES.MSG_PRIORITY_LOW, TencentCloudChat.TYPES.MSG_PRIORITY_LOWEST
  // priority: TencentCloudChat.TYPES.MSG_PRIORITY_HIGH,
  payload: {
    data: 'dice', // 用于标识该消息是骰子类型消息
    description: String(random(1,6)), // 获取骰子点数
    extension: ''
  }
});
// 3. 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

Parameters:

Returns:

Type

Message

createFaceMessage(options) → {Message}

Example

// 发送表情消息，Web端与小程序端相同。
// 1. 创建消息实例，接口返回的实例可以上屏
let message = chat.createFaceMessage({
  to: 'user1',
  conversationType: TencentCloudChat.TYPES.CONV_C2C,
  // 消息优先级，用于群聊。如果某个群的消息超过了频率限制，后台会优先下发高优先级的消息，详细请参考：https://cloud.tencent.com/document/product/269/3663#.E6.B6.88.E6.81.AF.E4.BC.98.E5.85.88.E7.BA.A7.E4.B8.8E.E9.A2.91.E7.8E.87.E6.8E.A7.E5.88.B6)
  // 支持的枚举值：TencentCloudChat.TYPES.MSG_PRIORITY_HIGH, TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL（默认）, TencentCloudChat.TYPES.MSG_PRIORITY_LOW, TencentCloudChat.TYPES.MSG_PRIORITY_LOWEST
  // priority: TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL,
  payload: {
    index: 1, // Number 表情索引，用户自定义
    data: 'tt00' // String 额外数据
  },
  // 消息自定义数据（云端保存，会发送到对端，程序卸载重装后还能拉取到）
  // cloudCustomData: 'your cloud custom data'
});
// 2. 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

Parameters:

Returns:

Type

Message

createFileMessage(options) → {Message}

Examples

// Web 端发送文件消息示例1 - 传入 DOM 节点
// 1. 创建文件消息实例，接口返回的实例可以上屏
let message = chat.createFileMessage({
  to: 'user1',
  conversationType: TencentCloudChat.TYPES.CONV_C2C,
  // 消息优先级，用于群聊。如果某个群的消息超过了频率限制，后台会优先下发高优先级的消息，详细请参考：https://cloud.tencent.com/document/product/269/3663#.E6.B6.88.E6.81.AF.E4.BC.98.E5.85.88.E7.BA.A7.E4.B8.8E.E9.A2.91.E7.8E.87.E6.8E.A7.E5.88.B6)
  // 支持的枚举值：TencentCloudChat.TYPES.MSG_PRIORITY_HIGH, TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL（默认）, TencentCloudChat.TYPES.MSG_PRIORITY_LOW, TencentCloudChat.TYPES.MSG_PRIORITY_LOWEST
  // priority: TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL,
  payload: {
    file: document.getElementById('filePicker'),
  },
  // 消息自定义数据（云端保存，会发送到对端，程序卸载重装后还能拉取到）
  // cloudCustomData: 'your cloud custom data'
  onProgress: function(event) { console.log('file uploading:', event) }
});

// 2. 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

// Web 端发送文件消息示例2- 传入 File 对象
// 先在页面上添加一个 id 为 "testPasteInput" 的消息输入框，如 <input type="text" id="testPasteInput" placeholder="截图后粘贴到输入框中" size="30" />
document.getElementById('testPasteInput').addEventListener('paste', function(e) {
  let clipboardData = e.clipboardData;
  let file;
  let fileCopy;
  if (clipboardData && clipboardData.files && clipboardData.files.length > 0) {
    file = clipboardData.files[0];
    // 图片消息发送成功后，file 指向的内容可能被浏览器清空，如果接入侧有额外的渲染需求，可以提前复制一份数据
    fileCopy = file.slice();
  }

  if (typeof file === 'undefined') {
    console.warn('file 是 undefined，请检查代码或浏览器兼容性！');
    return;
  }

  // 1. 创建消息实例，接口返回的实例可以上屏
  let message = chat.createFileMessage({
    to: 'user1',
    conversationType: TencentCloudChat.TYPES.CONV_C2C,
    payload: {
      file: file
    },
    onProgress: function(event) { console.log('file uploading:', event) }
  });

  // 2. 发送消息
  let promise = chat.sendMessage(message);
  promise.then(function(imResponse) {
    // 发送成功
    console.log(imResponse);
  }).catch(function(imError) {
    // 发送失败
    console.warn('sendMessage error:', imError);
  });
});

// uni-app 发送文件
// 1. 选择文件
uni.chooseFile({
  count: 1,
  extension:['.zip','.doc'],
  success: function(res) {
    let message = chat.createFileMessage({
      to: 'user1',
      conversationType: TencentCloudChat.TYPES.CONV_C2C,
      payload: { file: res },
      onProgress: function(event) { console.log('file uploading:', event) }
    });
    // 2. 发送消息
    let promise = chat.sendMessage(message);
    promise.then(function(imResponse) {
      // 发送成功
      console.log(imResponse);
    }).catch(function(imError) {
      // 发送失败
      console.warn('sendMessage error:', imError);
    });
  }
});

// 手机端微信小程序或 QQ 小程序法发送文件
// wx.chooseMessageFile 基础库 2.5.0 开始支持，低版本需做兼容处理
// qq.chooseMessageFile 基础库 1.18.0 开始支持，低版本需做兼容处理
// 1. 从客户端会话选择文件
wx.chooseMessageFile({
  count: 1,
  type: 'all', // 从所有文件选择
  success: (res) => {
    const message = chat.createFileMessage({
      to: 'user1',
      conversationType: TencentCloudChat.TYPES.CONV_C2C,
      payload: { file: res },
      onProgress: function(event) { console.log('file uploading:', event) }
    });
    // 2. 发送消息
    let promise = chat.sendMessage(message);
    promise.then(function(imResponse) {
      // 发送成功
      console.log(imResponse);
    }).catch(function(imError) {
      // 发送失败
      console.warn('sendMessage error:', imError);
    });
  }
});

// React Native 项目中发送文件需要使用 [react-native-document-picker](https://www.npmjs.com/package/react-native-document-picker)
import DocumentPicker from 'react-native-document-picker';

// 1. 选择文件
DocumentPicker.pick({
  type: [DocumentPicker.types.allFiles],
}).then((result) => {
 const file = result[0];
 // 2. 创建消息实例，接口返回的实例可以上屏
 let message = chat.createFileMessage({
    to: 'user1',
    conversationType: TencentCloudChat.TYPES.CONV_C2C,
    payload: { file: file },
    // React Native 不支持上传进度回调
    // onProgress: function(event) { console.log('file uploading:', event) }
  });
  // 3. 发送文件
  let promise = chat.sendMessage(message);
  promise.then(function(imResponse) {
    // 发送成功
    console.log(imResponse);
  }).catch(function(imError) {
    // 发送失败
    console.warn('sendMessage error:', imError);
  });
});

Parameters:

Returns:

Type

Message

createLocationMessage(options) → {Message}

Example

// 发送地理位置消息，Web 端与小程序端相同
// 1. 创建消息实例，接口返回的实例可以上屏
let message = chat.createLocationMessage({
  to: 'user1',
  conversationType: TencentCloudChat.TYPES.CONV_C2C,
  // 消息优先级，用于群聊。如果某个群的消息超过了频率限制，后台会优先下发高优先级的消息，详细请参考：https://cloud.tencent.com/document/product/269/3663#.E6.B6.88.E6.81.AF.E4.BC.98.E5.85.88.E7.BA.A7.E4.B8.8E.E9.A2.91.E7.8E.87.E6.8E.A7.E5.88.B6)
  // 支持的枚举值：TencentCloudChat.TYPES.MSG_PRIORITY_HIGH, TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL（默认）, TencentCloudChat.TYPES.MSG_PRIORITY_LOW, TencentCloudChat.TYPES.MSG_PRIORITY_LOWEST
  // priority: TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL,
  payload: {
    description: '深圳市深南大道10000号腾讯大厦',
    longitude: 113.941079, // 经度
    latitude: 22.546103 // 纬度
  }
});
// 2. 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

Parameters:

Returns:

Type

Message

createMergerMessage(options) → {Message}

Example

// 1. 将群聊消息转发到 c2c 会话
// message1 message2 message3 是群聊消息
let mergerMessage = chat.createMergerMessage({
  to: 'user1',
  conversationType: TencentCloudChat.TYPES.CONV_C2C,
  payload: {
    messageList: [message1, message2, message3],
    title: '大湾区前端人才中心的聊天记录',
    abstractList: ['allen: 666', 'iris: [图片]', 'linda: [文件]'],
    compatibleText: '请升级IMSDK到v2.10.1或更高版本查看此消息'
  },
  // 消息自定义数据（云端保存，会发送到对端，程序卸载重装后还能拉取到）
  // cloudCustomData: 'your cloud custom data'
});

// 2. 发送消息
let promise = chat.sendMessage(mergerMessage);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

Parameters:

Returns:

Type

Message

downloadMergerMessage(message) → {Promise}

Example

// downloadKey 存在说明收到的合并消息存储在云端，需要先下载
if (message.type === TencentCloudChat.TYPES.MSG_MERGER && message.payload.downloadKey !== '') {
  let promise = chat.downloadMergerMessage(message);
  promise.then(function(imResponse) {
    // 下载成功后，SDK会更新 message.payload.messageList 等信息
    console.log(imResponse.data);
  }).catch(function(imError) {
    // 下载失败
    console.warn('downloadMergerMessage error:', imError);
  });
}

Parameters:

Returns:

Type

Promise

createForwardMessage(options) → {Message}

Example

let forwardMessage = chat.createForwardMessage({
  to: 'user1',
  conversationType: TencentCloudChat.TYPES.CONV_C2C,
  // 消息优先级，用于群聊，如果某个群的消息超过了频率限制，后台会优先下发高优先级的消息，详细请参考：https://cloud.tencent.com/document/product/269/3663#.E6.B6.88.E6.81.AF.E4.BC.98.E5.85.88.E7.BA.A7.E4.B8.8E.E9.A2.91.E7.8E.87.E6.8E.A7.E5.88.B6)
  // 支持的枚举值：TencentCloudChat.TYPES.MSG_PRIORITY_HIGH, TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL（默认）, TencentCloudChat.TYPES.MSG_PRIORITY_LOW, TencentCloudChat.TYPES.MSG_PRIORITY_LOWEST
  // priority: TencentCloudChat.TYPES.MSG_PRIORITY_NORMAL,
  payload: message, // 消息实例，已收到的或自己已发出的消息
  // 消息自定义数据（云端保存，会发送到对端，程序卸载重装后还能拉取到）
  // cloudCustomData: 'your cloud custom data'
});
// 2. 发送消息
let promise = chat.sendMessage(forwardMessage);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

Parameters:

Returns:

Type

Message

sendMessage(message, optionsopt) → {Promise}

发送消息的接口，需先调用下列的创建消息实例的接口获取消息实例后，再调用该接口发送消息实例。

• 创建文本消息
• 创建图片消息
• 创建音频消息
• 创建视频消息
• 创建自定义消息
• 创建表情消息
• 创建文件消息
• 创建转发消息
• 创建合并消息

注意1：调用该接口发送消息实例，需要 SDK 处于 ready 状态，否则将无法发送消息实例。sdk 状态，可通过监听以下事件得到：

• TencentCloudChat.EVENT.SDK_READY - SDK 处于 ready 状态时触发
• TencentCloudChat.EVENT.SDK_NOT_READY - SDK 处于 not ready 状态时触发

注意2：接收推送的单聊、群聊、群提示、群系统通知的新消息，需监听事件 TencentCloudChat.EVENT.MESSAGE_RECEIVED
注意3：本实例发送的消息，不会触发事件 TencentCloudChat.EVENT.MESSAGE_RECEIVED。同账号从其他端（或通过 REST API）发送的消息，会触发事件 TencentCloudChat.EVENT.MESSAGE_RECEIVED
注意4：离线推送仅适用于终端（Android 或 iOS)，Web 和 微信小程序不支持。
注意5：onlineUserOnly 和 messageControlInfo 不能同时使用。
注意6：支持普通社群和话题消息不计未读。
注意7：向【系统会话】发消息，SDK 返回错误码 2106。
注意8：消息包体大小限制为12KB，且不可调整，超出会导致消息发送失败，错误码 80002。
注意9：启用好友关系检查后（【IM 控制台】>【应用配置】>【功能配置】>【登录与消息】>【好友关系检查】），IM 会在发起单聊时检查好友关系，仅允许好友之间发送单聊消息，陌生人发送单聊消息时 SDK 返回错误码 20009。

接收端集成 uni-app 腾讯云推送服务（Push）或 react- native 腾讯云推送服务（Push）时，发送端 offlinePushInfo 中的功能，各个厂商支持情况：

厂商	自定义铃音	小图标	通知图片	长文本
华为	支持	支持	支持	支持
荣耀	-	默认使用应用图标	支持	支持
OPPO	支持	默认使用应用图标	-	支持
vivo	-	默认使用应用图标	-	title:40字符,description:108字符 (中文字符计算为2,英文字符计算为1)
小米	支持	默认使用应用图标	-	title:50字符,description:128字符 (中英文字符均计算为1)
魅族	-	默认使用应用图标	-	title:32字符,description:100字符 (中文字符计算为2,英文字符计算为1)
FCM	支持	支持	支持	支持
apns	支持	-	支持	-

效果示例:

自定义小图标	自定义右侧图标	长文本

Examples

// 如果接收方不在线，则消息将存入漫游，且进行离线推送（在接收方 App 退后台或者进程被 kill 的情况下）。离线推送的标题和内容使用默认值。
// uni-app 腾讯云推送服务（Push）推送的说明请参考 https://cloud.tencent.com/document/product/269/103522
// react-native 腾讯云推送服务（Push）推送的说明请参考 https://cloud.tencent.com/document/product/269/104005
chat.sendMessage(message);

// 消息发送选项
chat.sendMessage(message, {
  onlineUserOnly: true // 如果接收方不在线，则消息不存入漫游，且不会进行离线推送
});

// 消息发送选项
chat.sendMessage(message, {
  offlinePushInfo: {
    disablePush: true // 如果接收方不在线，则消息将存入漫游，但不进行离线推送
  }
});

// 消息发送选项
chat.sendMessage(message, {
  // 如果接收方不在线，则消息将存入漫游，且进行离线推送（在接收方 App 退后台或者进程被 kill 的情况下）。接入侧可自定义离线推送的标题及内容
  offlinePushInfo: {
    title: '', // 离线推送标题
    description: '', // 离线推送内容
    // v3.3.2 起支持
    androidInfo: {
       OPPOChannelID: '' // 离线推送设置 OPPO 手机 8.0 系统及以上的渠道 ID
    }
  }
});

// 消息控制选项
chat.sendMessage(message, {
  messageControlInfo: {
    excludedFromUnreadCount: true, // 消息不更新会话 unreadCount（消息存漫游）
    excludedFromLastMessage: true // 消息不更新会话 lastMessage（消息存漫游）
  }
});

// 普通社群消息不计未读
chat.sendMessage(message, {
  messageControlInfo: {
    excludedFromUnreadCount: true, // 消息不更新会话 unreadCount（消息存漫游）
  }
});

// 话题消息不计未读
chat.sendMessage(message, {
  messageControlInfo: {
    excludedFromUnreadCount: true, // 消息不更新话题 unreadCount（消息存漫游）
  }
});

// 支持 voip 推送
chat.sendMessage(message, {
  offlinePushInfo: {
    disablePush: false, // 如果接收方不在线，则进行离线推送
    disableVoipPush: false // 开启 voip 推送需要同时开启离线推送
  }
});

// 消息不过内容审核
// 只有在开通【云端审核】功能后，excludedFromContentModeration 设置才有效，设置为 true，消息不过内容审核，设置为 false 消息过内容审核
//【云端审核】开通流程请参考 [云端审核功能](https://cloud.tencent.com/document/product/269/83795#.E4.BA.91.E7.AB.AF.E5.AE.A1.E6.A0.B8.E5.8A.9F.E8.83.BD)
chat.sendMessage(message, {
  messageControlInfo: {
    excludedFromContentModeration: true,
  }
});

// 离线推送自定义铃音
chat.sendMessage(message, {
  offlinePushInfo: {
    androidInfo: {
       sound: '' // Android 离线推送声音设置。只支持华为、小米和谷歌，v3.3.2 起支持
    }
  }
});

// 离线推送通知栏通知图片
chat.sendMessage(message, {
  offlinePushInfo: {
    androidInfo: {
       HuaWeiImage: '' // 华为推送通知栏通知图片 url，v3.4.1 起支持
    }
  }
});

let message = chat.createTextMessage({
  to: 'test',
  conversationType: TencentCloudChat.TYPES.CONV_GROUP,
  payload: {
    text: 'Hello world!'
  }
});
// 发送消息，关闭消息回调开关，仅对本条消息有效
let promise = chat.sendMessage(message, { webhookInfo: {
  disableCloudMessagePreHook: true,
  disableCloudMessagePostHook: true
}});
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

Parameters:

Returns:

Type

Promise

revokeMessage(message) → {Promise}

Examples

// 主动撤回消息
let promise = chat.revokeMessage(message);
promise.then(function(imResponse) {
  // 消息撤回成功
}).catch(function(imError) {
  // 消息撤回失败
  console.warn('revokeMessage error:', imError);
});

// 收到消息被撤回的通知
chat.on(TencentCloudChat.EVENT.MESSAGE_REVOKED, function(event) {
  // event.name - TencentCloudChat.EVENT.MESSAGE_REVOKED
  // event.data - 存储 Message 对象的数组 - [Message] - 每个 Message 对象的 isRevoked 属性值为 true
});

// 获取会话的消息列表时遇到被撤回的消息
let promise = chat.getMessageList({conversationID: 'C2Ctest'});
promise.then(function(imResponse) {
  const messageList = imResponse.data.messageList; // 消息列表
  messageList.forEach(function(message) {
    if (message.isRevoked) {
      // 处理被撤回的消息
    } else {
      // 处理普通消息
    }
  });
});

Parameters:

Returns:

Type

Promise

resendMessage(message, optionsopt) → {Promise}

Examples

// 重发消息
let promise = chat.resendMessage(message); // 传入需要重发的消息实例
promise.then(function(imResponse) {
  // 重发成功
  console.log(imResponse);
}).catch(function(imError) {
  // 重发失败
  console.warn('resendMessage error:', imError);
});

// 重发消息时带上消息控制选项
chat.resendMessage(message, {
  messageControlInfo: {
    excludedFromUnreadCount: true, // 消息不更新会话 unreadCount（消息存漫游）
    excludedFromLastMessage: true // 消息不更新会话 lastMessage（消息存漫游）
  }
});

Parameters:

Returns:

Type

Promise

deleteMessage(messageList) → {Promise}

Example

// 删除消息
let promise = chat.deleteMessage([message1, message2, message3, ...]);
promise.then(function(imResponse) {
  // 删除消息成功
}).catch(function(imError) {
  // 删除消息失败
  console.warn('deleteMessage error:', imError);
});

Parameters:

Returns:

Type

Promise

translateText(options) → {Promise}

Examples

// 将阿拉伯文翻译成英文
let promise = chat.translateText({
  sourceTextList: ['مرحبًا'],
  sourceLanguage: 'auto',
  targetLanguage: 'en'
});
promise.then(function(imResponse) {
  // 翻译成功 translatedTextList 和 sourceTextList 的元素一一对应
  const { translatedTextList } = imResponse.data;
}).catch(function(imError) {
  // 翻译失败，错误码2117
  console.warn('translateText error:', imError);
});

// 将英文翻译成中文
let promise = chat.translateText({
  sourceTextList: ['Hello Tencent', 'Build in-app chat with Tencent Cloud Chat'],
  sourceLanguage: 'auto',
  targetLanguage: 'zh'
});
promise.then(function(imResponse) {
  // 翻译成功 translatedTextList 和 sourceTextList 的元素一一对应
  const { translatedTextList } = imResponse.data;
}).catch(function(imError) {
  // 翻译失败，错误码2117
  console.warn('translateText error:', imError);
});

Parameters:

Returns:

Type

Promise

convertVoiceToText(options) → {Promise}

Examples

// 最常用的中英粤语音转文字，language 参数可缺省
let promise = chat.convertVoiceToText({ message: audioMessage });
promise.then(function(imResponse)) {
  // 语音转文字成功
  const { result } = imResponse.data;
}).catch(function(imError) {
  // 语音转文字失败
  console.warn('convertVoiceToText error:', imError);
});

// 日语语音转文字
let promise = chat.convertVoiceToText({ message: audioMessage, language: 'ja-JP'});
promise.then(function(imResponse)) {
  // 语音转文字成功
  const { result } = imResponse.data;
}).catch(function(imError) {
  // 语音转文字失败
  console.warn('convertVoiceToText error:', imError);
});

Parameters:

Returns:

Type

Promise

setMessageExtensions(message, extensions) → {Promise}

Examples

// 发送支持消息扩展的群消息
let message = chat.createTextMessage({
  to: 'test',
  conversationType: TencentCloudChat.TYPES.CONV_GROUP,
  payload: {
    text: 'Hello world!'
  },
  // 如果您发消息需要支持扩展，需购买旗舰版套餐，并且创建消息时将 isSupportExtension 设置为 true
  isSupportExtension: true
});
// 发送消息
let promise = chat.sendMessage(message);
promise.then(function(imResponse) {
  // 发送成功
  console.log(imResponse);
}).catch(function(imError) {
  // 发送失败
  console.warn('sendMessage error:', imError);
});

let promise = chat.setMessageExtensions(message, [{ key: 'a', value: '1' }, { key: 'b', value: '2' }]);
promise.then(function(imResponse) {
  // 设置消息扩展成功
   const { extensions } = imResponse.data;
   extensions.forEach((item) => {
     const { code, key, value } = item;
     if (code === 23001) {
       // 设置 key 冲突，请根据返回的最新扩展信息，按需进行重试
     }
   });
}).catch(function(imError) {
  // 设置消息扩展失败
  console.warn('setMessageExtensions error:', imError);
});

Parameters:

Returns:

Type

Promise

getMessageExtensions(message) → {Promise}

Example

let promise = chat.getMessageExtensions(message);
promise.then(function(imResponse) {
  // 获取消息扩展成功
   const { extensions } = imResponse.data;
   extensions.forEach((item) => {
     const { key, value } = item;
     // key - 消息扩展 key
     // value - 消息扩展 key 对应的 value 值
   });
}).catch(function(imError) {
  // 获取消息扩展失败
  console.warn('getMessageExtensions error:', imError);
});

Parameters:

Returns:

Type

Promise

deleteMessageExtensions(message, keyList) → {Promise}

Examples

// 删除消息扩展 key
let promise = chat.deleteMessageExtensions(message, ['a', 'b']);
promise.then(function(imResponse) {
   // 删除消息扩展成功
   const { extensions } = imResponse.data;
   extensions.forEach((item) => {
     const { code, key, value } = item;
     if (code === 23001) {
       // 删除 key 冲突，请根据返回的最新扩展信息，按需进行重试
     }
   });
}).catch(function(imError) {
  // 删除消息扩展失败
  console.warn('deleteMessageExtensions error:', imError);
});

// 清空所有消息扩展 key
let promise = chat.deleteMessageExtensions(message);
promise.then(function(imResponse) {
   // 清空消息扩展成功
   console.log('deleteMessageExtensions ok:', imResponse)
}).catch(function(imError) {
  // 清空消息扩展失败
  console.warn('deleteMessageExtensions error:', imError);
});

Parameters:

Returns:

Type

Promise

addMessageReaction(message, reactionID) → {Promise}

Examples

emoji 表情回应功能是指对某条消息通过表情符号进行互动回应，我们可以看到每种表情的回应人数和回应人列表。
目前常见的消息回应展示方式会有如下两种风格：
风格一：
 ----------------------------
 | lucy, happy birthday!  |
 ----------------------------
 | 😄 1 💐 2 👍🏻 10 |
 ----------------------------
风格二：
 ----------------------------
 | lucy, happy birthday! |
 -----------------------------
 | 😁 bob 💐 olivia 🎂 david |
 | 👍🏻 denny、james、lucy、linda、thomas 等10人 |
 ---------------------------------------------—
当用户点击某个表情后，会跳转到表情回应详情界面，用户可以根据某个表情分页拉取使用该表情的用户信息。

let promise = chat.addMessageReaction(message, '[TUIEmoji_Smile]');
promise.then(function(imResponse) {
  // 添加消息回应成功
}).catch(function(imError) {
  // 添加消息回应失败
  console.warn('addMessageReaction error:', imError);
});

Parameters:

Returns:

Type

Promise

removeMessageReaction(message, reactionID) → {Promise}

Example

let promise = chat.removeMessageReaction(message, '[TUIEmoji_Smile]');
promise.then(function(imResponse) {
  // 删除消息回应成功
}).catch(function(imError) {
  // 删除消息回应失败
  console.warn('removeMessageReaction error:', imError);
});

Parameters:

Returns:

Type

Promise

getMessageReactions(options) → {Promise}

Example

let promise = chat.getMessageReactions({
  messageList: [message1, message2],
  maxUserCountPerReaction: 10,
});
promise.then(function(imResponse) {
  // 批量拉取成功
   const { resultList } = imResponse.data;
   resultList.forEach((item) => {
     const { messageID, reactionList } = item;
     // reactionList 返回的信息如下：
     // reactionID - 消息回应 ID
     // reactedByMyself - 是否我的回应
     // totalUserCount - 同一个 reactionID 回应消息的总的用户个数
     // partialUserList - 同一个 reactionID 的部分用户列表，包含用户的 userID、nick、avatar 信息
   });
}).catch(function(imError) {
  // 批量拉取失败
  console.warn('getMessageReactions error:', imError);
});

Parameters:

Returns:

Type

Promise

getAllUserListOfMessageReaction(options) → {Promise}

Example

let promise = chat.getAllUserListOfMessageReaction({
  message: message,
  reactionID: '[TUIEmoji_Smile]',
  nextSeq: 0,
  count: 100,
});
promise.then(function(imResponse) {
  // 获取成功
  const { userList, nextSeq, isCompleted } = imResponse.data;
  // userList - 用户信息列表，包含用户的 userID、nick、avatar 信息
  // nextSeq - 用于续拉，分页续拉时需传入该字段
  // isCompleted - 表示是否已经拉完所有的用户信息。isCompleted 为 true 时，nextSeq 为 0
}).catch(function(imError) {
  // 获取失败
  console.warn('getAllUserListOfMessageReaction error:', imError);
});

Parameters:

Returns:

Type

Promise

modifyMessage(message) → {Promise}

Example

// 监听 MESSAGE_MODIFIED 事件，当修改消息成功后，SDK 会派发此事件
let onMessageModified = function(event) {
  // event.data - 存储被修改过的 Message 对象的数组 - [Message]
};
chat.on(TencentCloudChat.EVENT.MESSAGE_MODIFIED, onMessageModified);

// 将 txtMessage 的文本内容改为 "Hello Tencent"
txtMessage.payload.text = "Hello Tencent";

let promise = chat.modifyMessage(txtMessage);
promise.then(function(imResponse) {
  const { message } = imResponse.data;
  // 修改消息成功，message 是最新的消息
}).catch(function(imError) {
  // 修改消息失败
  const { code, data } = imError;
  if (code === 2480) {
    // 修改消息发生冲突，data.message 是最新的消息
  } else if (code === 2481) {
    // 不支持修改直播群消息
  } else if (code === 20026) {
    // 消息不存在
  }
});

Parameters:

Returns:

Type

Promise

getMessageList(options) → {Promise}

See:

• 漫游消息存储

• Message

Examples

// 打开某个会话时，第一次拉取消息列表，注意！第一次拉取时不要传入 nextReqMessageID
let promise = chat.getMessageList({conversationID: 'C2Ctest'});
promise.then(function(imResponse) {
  const messageList = imResponse.data.messageList; // 消息列表。
  const nextReqMessageID = imResponse.data.nextReqMessageID; // 用于续拉，分页续拉时需传入该字段。
  const isCompleted = imResponse.data.isCompleted; // 表示是否已经拉完所有消息。isCompleted 为 true 时，nextReqMessageID 为 ""。
});

// 下拉查看更多消息
let promise = chat.getMessageList({conversationID: 'C2Ctest', nextReqMessageID});
promise.then(function(imResponse) {
  const messageList = imResponse.data.messageList; // 消息列表。
  const nextReqMessageID = imResponse.data.nextReqMessageID; // 用于续拉，分页续拉时需传入该字段。
  const isCompleted = imResponse.data.isCompleted; // 表示是否已经拉完所有消息。isCompleted 为 true 时，nextReqMessageID 为 ""。
});

Parameters:

Returns:

Type

Promise

getMessageListHopping(options) → {Promise}

See:

• 漫游消息存储

• Message

Examples

// 根据 sequence 拉群漫游消息，direction 0 向上拉，拉更旧的消息，direction 1 向下拉，拉更新的消息
let promise = chat.getMessageListHopping({conversationID: 'GROUPtest', sequence: xxx, count: 15, direction: 0});
promise.then(function(imResponse) {
  const { messageList, isCompleted, nextMessageSeq } = imResponse.data;
  // messageList - 消息列表
  // isCompleted - 拉取完成标识， true 已拉完，false 未拉完，可以通过 nextMessageSeq 的返回值进行续拉
  // nextMessageSeq - 续拉起始 sequence，当 isCompleted 返回 true 时，nextMessageSeq 返回空字符串
});

// 根据时间拉 C2C 会话漫游消息，direction 0 向上拉，拉更旧的消息，direction 1 向下拉，拉更新的消息
let promise = chat.getMessageListHopping({conversationID: 'C2Ctest', time: xxx, count: 15, direction: 0});
promise.then(function(imResponse) {
  const { messageList, isCompleted, nextMessageTime } = imResponse.data;
  // messageList - 消息列表
  // isCompleted - 拉取完成标识，true 已拉完，false 未拉完，可以通过 nextMessageTime 的返回值进行续拉
  // nextMessageTime - 续拉起始时间，当 isCompleted 返回 true 时，nextMessageTime 返回空字符串
});

Parameters:

Returns:

Type

Promise

sendMessageReadReceipt(messageList) → {Promise}

Examples

// 拉取群消息列表
let messageList = null;
chat.getMessageList({conversationID: 'GROUPtest'}).then(function(imResponse) {
  messageList = imResponse.data.messageList; // 消息列表
  chat.sendMessageReadReceipt(messageList).then(function() {
    // 发送群消息已读回执成功
  }).catch(function(imError) {
    // 发送群消息已读回执失败
  });
});

// 拉取C2C消息列表
let messageList = null;
chat.getMessageList({conversationID: 'C2Ctest'}).then(function(imResponse) {
  messageList = imResponse.data.messageList; // 消息列表
  chat.sendMessageReadReceipt(messageList).then(function() {
    // 发送C2C消息已读回执成功
  }).catch(function(imError) {
    // 发送C2C消息已读回执失败
  });
});

Parameters:

Returns:

Type

Promise

getMessageReadReceiptList(messageList) → {Promise}

Examples

// 拉取群消息列表
let messageList = null;
chat.getMessageList({conversationID: 'GROUPtest'}).then(function(imResponse) {
  messageList = imResponse.data.messageList; // 消息列表
  chat.getMessageReadReceiptList(messageList).then(function(imResponse) {
    messageList = imResponse.data.messageList; // 消息列表
    // 成功后，Message.readReceiptInfo 包含消息的已读回执信息
    // Message.readReceiptInfo.readCount - 消息的已读数，如果想要查询哪些群成员已读了此消息，请使用 [getGroupMessageReadMemberList] 接口
    // Message.readReceiptInfo.unreadCount - 消息的未读数，当为0的时候，表示“全部已读”。
  }).catch(function(imError) {
    // 拉取已读回执列表失败
  });
});

// 拉取 C2C 消息列表
let messageList = null;
chat.getMessageList({conversationID: 'C2Ctest'}).then(function(imResponse) {
  messageList = imResponse.data.messageList; // 消息列表
  chat.getMessageReadReceiptList(messageList).then(function(imResponse) {
    messageList = imResponse.data.messageList; // 消息列表
    // 成功后，Message.readReceiptInfo 包含消息的已读回执信息
    // Message.readReceiptInfo.isPeerRead - 对端是否已发送已读回执
  }).catch(function(imError) {
    // 拉取已读回执列表失败
  });
});

Parameters:

Returns:

Type

Promise

getGroupMessageReadMemberList(options) → {Promise}

Examples

// 拉取群消息已读成员列表
let promise = chat.getGroupMessageReadMemberList({
  message,
  filter: 0,
  cursor: '', // 第一次拉取传''
  count: 30,
});
promise.then(function(imResponse) {
  const { isCompleted, cursor, messageID, readUserIDList } = imResponse.data;
  // isCompleted - true，拉取完成；false 未完成
  // cursor - 当 isCompleted 为 false 的时候用于续拉
  // messageID - 群消息的 ID
  // readUserIDList - 已读的群成员 userID 列表。接入侧可调用 getGroupMemberProfile 接口查询群成员的资料，如群名片、头像、昵称等
}).catch(function(imError) {
  // 拉取群消息已读群成员列表失败
});

// 拉取群消息未读成员列表
let promise = chat.getGroupMessageReadMemberList({
  message,
  filter: 1,
  cursor: '', // 第一次拉取传''
  count: 30,
});
promise.then(function(imResponse) {
  const { isCompleted, cursor, messageID, unreadUserIDList } = imResponse.data;
  // isCompleted - true，拉取完成；false 未完成
  // cursor - 当 isCompleted 为 false 的时候用于续拉
  // messageID - 群消息的 ID
  // unreadUserIDList - 未读的群成员 userID 列表。接入侧可调用 getGroupMemberProfile 接口查询群成员的资料，如群名片、头像、昵称等
}).catch(function(imError) {
  // 拉取群消息未读群成员列表失败
  // 10062 - 找不到群消息的已读回执信息
});

Parameters:

Returns:

Type

Promise

findMessage(messageID) → {Message|null}

Example

let message = chat.findMessage('144115217363870632-1647417469-77069006');
if (message) {
  // 读取 message 相关属性，如已读回执信息 readReceiptInfo
}

Parameters:

Returns:

Type

Message | null

setMessageRead(options) → {Promise}

Example

// 将某会话下所有未读消息已读上报
let promise = chat.setMessageRead({conversationID: 'C2Cexample'});
promise.then(function(imResponse) {
  // 已读上报成功，指定 ID 的会话的 unreadCount 属性值被置为0
}).catch(function(imError) {
  // 已读上报失败
  console.warn('setMessageRead error:', imError);
});

Parameters:

Returns:

Type

Promise

getConversationList(options) → {Promise}

See:

• Conversation

Examples

// 获取全量的会话列表
let promise = chat.getConversationList();
promise.then(function(imResponse) {
  const conversationList = imResponse.data.conversationList; // 全量的会话列表，用该列表覆盖原有的会话列表
  const isSyncCompleted = imResponse.data.isSyncCompleted; // 从云端同步会话列表是否完成
}).catch(function(imError) {
  console.warn('getConversationList error:', imError); // 获取会话列表失败的相关信息
});

// 获取指定的会话列表
let promise = chat.getConversationList([conversationID1, conversationID2]);
promise.then(function(imResponse) {
  const conversationList = imResponse.data.conversationList; // 缓存中已存在的指定的会话列表
}).catch(function(imError) {
  console.warn('getConversationList error:', imError); // 获取会话列表失败的相关信息
});

// 获取所有的群会话
let promise = chat.getConversationList({ type: TencentCloudChat.TYPES.CONV_GROUP });
promise.then(function(imResponse) {
  const conversationList = imResponse.data.conversationList; // 会话列表
});

// 获取所有的“标星”会话
let promise = chat.getConversationList({ markType: TencentCloudChat.TYPES.CONV_MARK_TYPE_STAR });
promise.then(function(imResponse) {
  const conversationList = imResponse.data.conversationList; // 会话列表
});

// 获取所有的无标记的会话（v3.3.0起支持）
let promise = chat.getConversationList({ markType: 0 });
promise.then(function(imResponse) {
  const conversationList = imResponse.data.conversationList; // 会话列表
});

// 获取指定会话分组下的所有会话
let promise = chat.getConversationList({ groupName: 'Suppliers' });
promise.then(function(imResponse) {
  const conversationList = imResponse.data.conversationList; // 会话列表
});

// 获取不属于任何分组的会话（v3.3.0起支持）
let promise = chat.getConversationList({ groupName: '' });
promise.then(function(imResponse) {
  const conversationList = imResponse.data.conversationList; // 会话列表
});

// 获取有未读数的会话（v3.3.0起支持）
let promise = chat.getConversationList({ hasUnreadCount: true });
promise.then(function(imResponse) {
  const conversationList = imResponse.data.conversationList; // 会话列表
});

// 获取有群 @ 消息的会话（v3.3.0起支持）
let promise = chat.getConversationList({ hasGroupAtInfo: true });
promise.then(function(imResponse) {
  const conversationList = imResponse.data.conversationList; // 会话列表
});

Parameters:

Returns:

Type

Promise

getConversationProfile(conversationID) → {Promise}

See:

• Conversation

Example

let promise = chat.getConversationProfile(conversationID);
promise.then(function(imResponse) {
  // 获取成功
  console.log(imResponse.data.conversation); // 会话资料
}).catch(function(imError) {
  console.warn('getConversationProfile error:', imError); // 获取会话资料失败的相关信息
});

Parameters:

Returns:

Type

Promise

deleteConversation(options) → {Promise}

Examples

// 删除单一会话, 并清空会话历史消息
let promise = chat.deleteConversation('C2CExample');
promise.then(function(imResponse) {
  // 删除会话成功
  const { conversationID } = imResponse.data; // 被删除的会话 ID
}).catch(function(imError) {
  console.warn('deleteConversation error:', imError); // 删除会话失败的相关信息
});

// 删除单一会话, 不清空会话历史消息
let promise = chat.deleteConversation({conversationIDList: ['C2CExample'], clearHistoryMessage: false});
promise.then(function(imResponse) {
  // 删除会话成功
  const { conversationIDList } = imResponse.data; // 被删除的会话 ID 列表
}).catch(function(imError) {
  console.warn('deleteConversation error:', imError); // 删除会话失败的相关信息
});

// 删除多个会话, 并清空会话历史消息
let promise = chat.deleteConversation({conversationIDList: ['C2CExample', 'GROUPExample']});
promise.then(function(imResponse) {
  // 删除会话成功
  const { conversationIDList } = imResponse.data; // 被删除的会话 ID 列表
}).catch(function(imError) {
  console.warn('deleteConversation error:', imError); // 删除会话失败的相关信息
});

// 删除多个会话, 不清空会话历史消息
let promise = chat.deleteConversation({conversationIDList: ['C2CExample', 'GROUPExample'], clearHistoryMessage: false});
promise.then(function(imResponse) {
  // 删除会话成功
  const { conversationIDList } = imResponse.data; // 被删除的会话 ID 列表
}).catch(function(imError) {
  console.warn('deleteConversation error:', imError); // 删除会话失败的相关信息
});

Parameters:

Returns:

Type

Promise

setConversationDraft(options) → {Promise}

Examples

// 设置会话草稿
let promise = chat.setConversationDraft({
   conversationID: 'GROUPpublic1',
   draftText: '123'
});
promise.then(function(imResponse) {
  // 设置会话草稿成功
}).catch(function(imError) {
  console.warn('setConversationDraft error:', imError); // 设置会话草稿失败
});

// 取消会话草稿
let promise = chat.setConversationDraft({
   conversationID: 'GROUPpublic1',
   draftText: ''
});
promise.then(function(imResponse) {
  // 取消 GROUPpublic1 会话草稿成功
}).catch(function(imError) {
  console.warn('setConversationDraft error:', imError); // 取消会话草稿失败
});

Parameters:

Returns:

Type

Promise

clearHistoryMessage(conversationID) → {Promise}

Examples

// 清空单聊的本地及云端的消息
let promise = chat.clearHistoryMessage('C2CExample');
promise.then(function(imResponse) {
  // 清空消息成功
}).catch(function(imError) {
  console.warn('clearHistoryMessage error:', imError); // 清空消息失败的相关信息
});

// 清空群聊的本地及云端的消息
let promise = chat.clearHistoryMessage('GROUPExample');
promise.then(function(imResponse) {
  // 清空消息成功
}).catch(function(imError) {
  console.warn('clearHistoryMessage error:', imError); // 清空消息失败的相关信息
});

Parameters:

Returns:

Type

Promise

pinConversation(options) → {Promise}

Examples

// 置顶会话
let promise = chat.pinConversation({ conversationID: 'C2CExample', isPinned: true });
promise.then(function(imResponse) {
  // 置顶会话成功
  const { conversationID } = imResponse.data; // 被置顶的会话 ID
}).catch(function(imError) {
  console.warn('pinConversation error:', imError); // 置顶会话失败的相关信息
});

// 取消置顶会话
let promise = chat.pinConversation({ conversationID: 'C2CExample', isPinned: false });
promise.then(function(imResponse) {
  // 取消置顶会话成功
  const { conversationID } = imResponse.data; // 被取消置顶的会话 ID
}).catch(function(imError) {
  console.warn('pinConversation error:', imError); // 取消置顶会话失败的相关信息
});

Parameters:

Returns:

Type

Promise

setAllMessageRead(options) → {Promise}

Examples

// 将所有会话的未读消息全部设置为已读
let promise = chat.setAllMessageRead(); // 等同于 chat.setAllMessageRead({scope: TencentCloudChat.TYPES.READ_ALL_MSG})
promise.then(function(imResponse) {
  // 已读上报成功，所有会话的 unreadCount 属性值被置为0
}).catch(function(imError) {
  // 已读上报失败
  console.warn('setAllMessageRead error:', imError);
});

// 将所有 C2C 会话的未读消息全部设置为已读
let promise = chat.setAllMessageRead({scope: TencentCloudChat.TYPES.READ_ALL_C2C_MSG});
promise.then(function(imResponse) {
  // 已读上报成功，所有 C2C 会话的 unreadCount 属性值被置为0
}).catch(function(imError) {
  // 已读上报失败
  console.warn('setAllMessageRead error:', imError);
});

// 将所有群会话的未读消息全部设置为已读
let promise = chat.setAllMessageRead({scope: TencentCloudChat.TYPES.READ_ALL_GROUP_MSG});
promise.then(function(imResponse) {
  // 已读上报成功，所有 C2C 会话的 unreadCount 属性值被置为0
}).catch(function(imError) {
  // 已读上报失败
  console.warn('setAllMessageRead error:', imError);
});

Parameters:

Returns:

Type

Promise

setMessageRemindType(options) → {Promise}

Examples

// 拒收群消息（通过 getMessageList 接口可拉取到其他群成员发送的消息）
let promise = chat.setMessageRemindType({ groupID: 'group1', messageRemindType: TencentCloudChat.TYPES.MSG_REMIND_DISCARD });
promise.then(function(imResponse) {
  // 设置成功后 SDK 会触发 TencentCloudChat.EVENT.CONVERSATION_LIST_UPDATED 事件（遍历列表，并读取 Conversation.messageRemindType）
}).catch(function(imError) {
  console.warn('setMessageRemindType error:', imError);
});

// 拒收群消息后，重新开启新消息提醒
let promise = chat.setMessageRemindType({ groupID: 'group1', messageRemindType: TencentCloudChat.TYPES.MSG_REMIND_ACPT_AND_NOTE });
promise.then(function(imResponse) {
  // 设置成功后 SDK 会触发 TencentCloudChat.EVENT.CONVERSATION_LIST_UPDATED 事件（遍历列表，并读取 Conversation.messageRemindType）
}).catch(function(imError) {
  console.warn('setMessageRemindType error:', imError);
});

// C2C 消息免打扰，一般的实现是在线接收消息，离线不接收消息（在有离线推送的情况下）
let promise = chat.setMessageRemindType({ userIDList: ['user1', 'user2'], messageRemindType: TencentCloudChat.TYPES.MSG_REMIND_ACPT_NOT_NOTE });
promise.then(function(imResponse) {
  // 设置成功后 SDK 会触发 TencentCloudChat.EVENT.CONVERSATION_LIST_UPDATED 事件（遍历列表，并读取 Conversation.messageRemindType）
  const { successUserIDList, failureUserIDList } = imResponse.data;
  // 删除成功的 userIDList
  successUserIDList.forEach((item) => {
    const { userID } = item;
  });
  // 删除失败的 userIDList
  failureUserIDList.forEach((item) => {
    const { userID, code, message } = item;
  });
}).catch(function(imError) {
  console.warn('setMessageRemindType error:', imError);
});

// 群消息免打扰，一般的实现是在线接收消息，离线不接收消息（在有离线推送的情况下）
let promise = chat.setMessageRemindType({ groupID: 'group1', messageRemindType: TencentCloudChat.TYPES.MSG_REMIND_ACPT_NOT_NOTE });
promise.then(function(imResponse) {
  // 设置消息免打扰成功
}).catch(function(imError) {
  // 设置消息免打扰失败
  console.warn('setMessageRemindType error:', imError);
});

// 社群话题消息免打扰，一般的实现是在线接收消息，离线不接收消息（在有离线推送的情况下）
let promise = chat.setMessageRemindType({ groupID: 'topicID', messageRemindType: TencentCloudChat.TYPES.MSG_REMIND_ACPT_NOT_NOTE });
promise.then(function(imResponse) {
  // 设置消息免打扰成功
}).catch(function(imError) {
  // 设置消息免打扰失败
  console.warn('setMessageRemindType error:', imError);
});

// 设置用户在线时，话题仅接收 @消息（@我和@所有人的消息）
let promise = chat.setMessageRemindType({ groupID: 'topicID', messageRemindType: TencentCloudChat.TYPES.NOT_RECEIVE_MSG_EXCEPT_AT });
promise.then(function(imResponse) {
  // 设置成功
}).catch(function(imError) {
  // 设置失败
  console.warn('setMessageRemindType error:', imError);
});

Parameters:

Returns:

Type

Promise

setAllReceiveMessageOpt(options) → {Promise}

Examples

// 设置每天晚上 22 点到第二天早上 10 点重复免打扰
let promise = chat.setAllReceiveMessageOpt({
  messageRemindType: TencentCloudChat.TYPES.MSG_REMIND_ACPT_NOT_NOTE,
  startHour: 22,
  startMinute: 0,
  startSecond: 0,
  duration: 12 * 60 * 60,
  isRepeated: true
});
promise.then(function(imResponse) {
  // 设置全局消息免打扰成功
}).catch(function(imError) {
  // 设置全局消息免打扰失败
  console.warn('setAllReceiveMessageOpt error:', imError);
});

// 设置从当天晚上 22 点开始永久免打扰
let promise = chat.setAllReceiveMessageOpt({
  messageRemindType: TencentCloudChat.TYPES.MSG_REMIND_ACPT_NOT_NOTE,
  startHour: 22,
  startMinute: 0,
  startSecond: 0,
  duration: 24 * 60 * 60,
  isRepeated: true
});
promise.then(function(imResponse) {
  // 设置全局消息免打扰成功
}).catch(function(imError) {
  // 设置全局消息免打扰失败
  console.warn('setAllReceiveMessageOpt error:', imError);
});

// 设置从当天晚上 22 点到第二天早上 8 点消息免打扰(生效一次)
let promise = chat.setAllReceiveMessageOpt({
  messageRemindType: TencentCloudChat.TYPES.MSG_REMIND_ACPT_NOT_NOTE,
  startHour: 22,
  startMinute: 0,
  startSecond: 0,
  duration: 10 * 60 * 60,
  isRepeated: false
});
promise.then(function(imResponse) {
  // 设置全局消息免打扰成功
}).catch(function(imError) {
  // 设置全局消息免打扰失败
  console.warn('setAllReceiveMessageOpt error:', imError);
});

// 取消全局消息免打扰
let promise = chat.setAllReceiveMessageOpt({ messageRemindType: TencentCloudChat.TYPES.MSG_REMIND_ACPT_AND_NOTE });
promise.then(function(imResponse) {
  // 取消全局消息免打扰成功
}).catch(function(imError) {
  // 取消全局消息免打扰失败
  console.warn('setAllReceiveMessageOpt error:', imError);
});

Parameters:

Returns:

Type

Promise

getAllReceiveMessageOpt() → {Promise}

Example

// 获取全局消息免打扰选项
let promise = chat.getAllReceiveMessageOpt();
promise.then(function(imResponse) {
  // 获取全局消息免打扰选项成功
  const { messageRemindType, startTime, endTime, isRepeated } = imResponse.data;
  // messageRemindType - 消息免打扰类型
  // startTime - 消息免打扰开始时间， UNIX 时间戳
  // endTime - 消息免打扰结束时间， UNIX 时间戳
  // isRepeated - 是否每天重复生效
}).catch(function(imError) {
  // 获取全局消息免打扰选项失败
  console.warn('getAllReceiveMessageOpt error:', imError);
});

Returns:

Type

Promise

getTotalUnreadMessageCount() → {Number}

Example

// 获取单聊和群聊会话的未读总数
let totalUnreadCount = chat.getTotalUnreadMessageCount();

Returns:

Type

Number

setConversationCustomData(options) → {Promise}

Examples

// 给 C2C 会话和群会话设置会话自定义数据
let promise = chat.setConversationCustomData({
  conversationIDList: ['GROUPtest', 'C2Cexample'],
  customData: 'your custom data'
});
promise.then(function(imResponse) {
  // 设置会话自定义数据成功
  const { successConversationIDList, failureConversationIDList } = imResponse.data;
  // successConversationIDList - 设置成功的会话 ID 列表
  // 获取会话列表
  const conversationList = chat.getConversationList(successConversationIDList);

  // failureConversationIDList - 设置失败的会话 ID 列表
  failureConversationIDList.forEach((item) => {
    const { conversationID, code, message } = item;
  });
}).catch(function(imError) {
  console.warn('setConversationCustomData error:', imError);
});

// customData 传入空字符串，表示清空会话自定义数据
let promise = chat.setConversationCustomData({
  conversationIDList: ['GROUPtest', 'C2Cexample'],
  customData: ''
});
promise.then(function(imResponse) {
  // 清空会话自定义数据成功
  const { successConversationIDList, failureConversationIDList } = imResponse.data;
  // successConversationIDList - 清空成功的会话 ID 列表
  // 获取会话列表
  const conversationList = chat.getConversationList(successConversationIDList);

  // failureConversationIDList - 清空失败的会话 ID 列表
  failureConversationIDList.forEach((item) => {
    const { conversationID, code, message } = item;
  });
}).catch(function(imError) {
  console.warn('setConversationCustomData error:', imError);
});

Parameters:

Returns:

Type

Promise

markConversation(options) → {Promise}

Examples

// 会话标星
let promise = chat.markConversation({
  conversationIDList: ['GROUPtest', 'C2Cexample'],
  markType: TencentCloudChat.TYPES.CONV_MARK_TYPE_STAR,
  enableMark: true
});
promise.then(function(imResponse) {
  // 会话标星成功
  const { successConversationIDList, failureConversationIDList } = imResponse.data;
  // successConversationIDList - 标星成功的会话 ID 列表
  // 获取会话列表
  const conversationList = chat.getConversationList(successConversationIDList);

  // failureConversationIDList - 标星失败的会话 ID 列表
  failureConversationIDList.forEach((item) => {
    const { conversationID, code, message } = item;
  });
}).catch(function(imError) {
  console.warn('markConversation error:', imError);
});

// 获取所有标星的会话
let promise = chat.getConversationList({ markType: TencentCloudChat.TYPES.CONV_MARK_TYPE_STAR });
promise.then(function(imResponse) {
  const conversationList = imResponse.data.conversationList; // 会话列表
});

// 获取所有折叠的 C2C 会话
let promise = chat.getConversationList({
  markType: TencentCloudChat.TYPES.CONV_MARK_TYPE_FOLD,
  type: TencentCloudChat.TYPES.CONV_C2C
});
promise.then(function(imResponse) {
  const conversationList = imResponse.data.conversationList; // 会话列表
});

Parameters:

Returns:

Type

Promise

getConversationGroupList() → {Promise}

Examples

let promise = chat.getConversationGroupList();
promise.then(function(imResponse) {
  const groupNameList = imResponse.data; // 会话分组名列表
});

// 获取指定会话分组下的所有会话
let promise = chat.getConversationList({ groupName: 'Suppliers' });
promise.then(function(imResponse) {
  const conversationList = imResponse.data.conversationList; // 会话列表
});

Returns:

Type

Promise

createConversationGroup(options) → {Promise}

Example

let promise = chat.createConversationGroup({
  conversationIDList: ['GROUPtest', 'C2Cexample'],
  groupName: 'Suppliers',
});
promise.then(function(imResponse) {
  // 创建会话分组成功
  const { successConversationIDList, failureConversationIDList } = imResponse.data;
  // successConversationIDList - 成功的会话 ID 列表
  // 获取会话列表
  const conversationList = chat.getConversationList(successConversationIDList);

  // failureConversationIDList - 失败的会话 ID 列表
  failureConversationIDList.forEach((item) => {
    const { conversationID, code, message } = item;
  });
}).catch(function(imError) {
  console.warn('createConversationGroup error:', imError);
});

Parameters:

Returns:

Type

Promise

deleteConversationGroup(groupName) → {Promise}

Example

let promise = chat.deleteConversationGroup('Suppliers');
promise.then(function() {
  // 删除成功
}).catch(function(imError) {
  console.warn('deleteConversationGroup error:', imError);
});

Parameters:

Returns:

Type

Promise

renameConversationGroup(options) → {Promise}

Example

let promise = chat.renameConversationGroup({
  oldName: 'Suppliers_old',
  newName: 'Suppliers_new'
});
promise.then(function(imResponse) {
  // 重命名成功
}).catch(function(imError) {
  console.warn('renameConversationGroup error:', imError);
});

Parameters:

Returns:

Type

Promise

addConversationsToGroup(options) → {Promise}

Example

let promise = chat.addConversationsToGroup({
  conversationIDList: ['GROUPtest', 'C2Cexample'],
  groupName: 'Suppliers_new',
});
promise.then(function(imResponse) {
  // 添加会话到分组成功
  const { successConversationIDList, failureConversationIDList } = imResponse.data;
  // successConversationIDList - 成功的会话 ID 列表
  // 获取会话列表
  const conversationList = chat.getConversationList(successConversationIDList);

  // failureConversationIDList - 失败的会话 ID 列表
  failureConversationIDList.forEach((item) => {
    const { conversationID, code, message } = item;
  });
}).catch(function(imError) {
  console.warn('addConversationsToGroup error:', imError);
});

Parameters:

Returns:

Type

Promise

deleteConversationsFromGroup(options) → {Promise}

Example

let promise = chat.deleteConversationsFromGroup({
  conversationIDList: ['GROUPtest', 'C2Cexample'],,
  groupName: 'Suppliers_new',
});
promise.then(function(imResponse) {
  // 从分组删除会话成功
  const { successConversationIDList, failureConversationIDList } = imResponse.data;
  // successConversationIDList - 成功的会话 ID 列表
  // 获取会话列表
  const conversationList = chat.getConversationList(successConversationIDList);

  // failureConversationIDList - 失败的会话 ID 列表
  failureConversationIDList.forEach((item) => {
    const { conversationID, code, message } = item;
  });
}).catch(function(imError) {
  console.warn('deleteConversationsFromGroup error:', imError);
});

Parameters:

Returns:

Type

Promise

searchCloudMessages(options) → {Promise}

Examples

// 全量搜索，指定关键字
// - 搜索消息里出现 '你好' 或 '在哪里'
let promise = chat.searchCloudMessages({
   keywordList: ['你好', '在哪里'],
});

// 全量搜索，指定关键字和匹配类型搜索
// - 搜索消息里出现了 '你好' 与 '在哪里' 的消息
let promise = chat.searchCloudMessages({
   keywordList: ['你好', '在哪里'],
   keywordListMatchType: 'and',
});

// 全量搜索，指定关键字列表和消息发送者搜索
// - 搜索消息发送者为 'user1' 或 'user2'，且消息里出现了 '你好' 或 '在哪里' 的消息
let promise = chat.searchCloudMessages({
   keywordList: ['你好', '在哪里'],
   senderUserIDList: ['user1', 'user2'],
});

// 全量搜索，指定关键字和消息类型搜索
// - 搜索消息类型为 '文本消息' 或 '自定义消息'，且消息里出现了 '你好' 或 '在哪里' 的消息
let promise = chat.searchCloudMessages({
   keywordList: ['你好', '在哪里'],
   messageTypeList: [TencentCloudChat.TYPES.MSG_TEXT, TencentCloudChat.TYPES.MSG_CUSTOM],
});

// 全量搜索，搜索所有图片消息（当指定发送者或消息类型时，关键字列表可以为空）
let promise = chat.searchCloudMessages({
   messageTypeList: [TencentCloudChat.TYPES.MSG_IMAGE],
});

// 全量搜索，只指定消息发送者和消息类型搜索（当指定发送者或消息类型时，关键字列表可以为空）
// - 搜索消息发送者为 'user1' 或 'user2'，且消息类型为 '文本消息' 或 '自定义消息' 的消息
let promise = chat.searchCloudMessages({
   senderUserIDList: ['user1', 'user2'],
   messageTypeList: [TencentCloudChat.TYPES.MSG_TEXT, TencentCloudChat.TYPES.MSG_CUSTOM],
});

// 全量搜索，指定关键字和时间（过去一天）搜索
// - 搜索过去一天，消息里出现了 '你好' 或 '在哪里'的消息
let promise = chat.searchCloudMessages({
   keywordList: ['你好', '在哪里'],
   timePosition: Number((new Date().getTime()/1000).toFixed(0)),
   timePeriod: 24 * 60 * 60,
});
promise.then(function(imResponse) {
 // 搜索消息成功
   const { totalCount, cursor, searchResultList } = imResponse.data;
   console.log(totalCount); // 满足搜索条件的消息所在的所有会话总数量
   console.log(cursor); // 下一次云端搜索的起始位置, 如果没有表示搜索结果拉取完成
   console.log(searchResultList); // 满足搜索条件的消息根据会话 ID 分组，分页返回分组结果
   for (let i = 0; i < searchResultList.length; i++) {
      const searchResultItem = searchResultList[i];
      const { conversationID, messageCount, messageList } = searchResultItem;
      console.log(conversationID); // 会话 ID
      console.log(messageCount); // 当前会话一共搜索到了多少条符合要求的消息
      // 本次搜索【全部会话】，那么 messageList 中装载的消息条数会有如下两种可能：
      // - 如果某个会话中匹配到的消息条数 > 1，则 messageList 为空，您可以在 UI 上显示“ messageCount 条相关记录”。
      // - 如果某个会话中匹配到的消息条数 = 1，则 messageList 为匹配到的那条消息，您可以在 UI 上显示之，并高亮匹配关键词。
      console.log(messageList);
    }
}).catch(function(imError) {
   console.error(imError); // 搜索消息失败
});

// 指定会话，指定关键字搜索
// - 搜索在 'GROUPPublic001' 会话中，消息里出现 '你好' 或 '在哪里' 的消息。
let promise = chat.searchCloudMessages({
   keywordList: ['你好', '在哪里'],
   conversationID: 'GROUPPublic001'
});

// 指定会话，指定消息类型搜索（当指定发送者或消息类型时，关键字列表可以为空）
// - 在 'GROUPPublic001' 会话中，搜索图片消息。
let promise = chat.searchCloudMessages({
   conversationID: 'GROUPPublic001',
   messageTypeList: [TencentCloudChat.TYPES.MSG_IMAGE],
});

// 指定会话，指定关键字和消息类型搜索
// - 搜索在 'GROUPPublic001' 会话中，消息里出现 '你好' 或 '在哪里'，且消息类型为 '文本消息' 或 '自定义消息' 的消息。
let promise = chat.searchCloudMessages({
   keywordList: ['你好', '在哪里'],
   conversationID: 'GROUPPublic001'
   messageTypeList: [TencentCloudChat.TYPES.MSG_TEXT, TencentCloudChat.TYPES.MSG_CUSTOM],
});

// 指定会话，指定关键字和时间（过去一天）搜索
// - 搜索过去一天，在 'GROUPPublic001' 会话中，消息里出现 '你好' 或 '在哪里' 的消息。
let promise = chat.searchCloudMessages({
   keywordList: ['你好', '在哪里'],
   conversationID: 'GROUPPublic001',
   timePosition: Number((new Date().getTime()/1000).toFixed(0)),
   timePeriod: 24 * 60 * 60,
});
promise.then(function(imResponse) {
   // 搜索消息成功
   const { totalCount, cursor, searchResultList } = imResponse.data;
   console.log(totalCount); // 满足搜索条件的消息总数量
   console.log(cursor); // 下一次云端搜索的起始位置, 如果没有表示搜索结果拉取完成
   console.log(searchResultList); // 当前会话搜索的消息结果
   const { conversationID, messageCount, messageList } = searchResultList[0];
   console.log(conversationID); // 会话ID
   console.log(messageCount); // 当前会话一共搜索到了多少条符合要求的消息
   console.log(messageList); // 本会话中所有满足搜索条件的消息列表
}).catch(function(imError) {
   console.error(imError); // 搜索消息失败
});

Parameters:

Returns:

Type

Promise

searchCloudUsers(options) → {Promise}

Examples

// 搜索指定关键字
// - 搜索用户里出现 'test' 或 'user' 的用户
let promise = chat.searchCloudUsers({
   keywordList: ['test', 'user'],
});

// 搜索指定关键字和匹配类型搜索
// - 搜索用户里同时出现 'test' 与 'user' 的用户
let promise = chat.searchCloudUsers({
   keywordList: ['test', 'user'],
   keywordListMatchType: 'and',
});

// 搜索指定关键字列表和用户性别搜索
// - 搜索用户里出现 'test' 或 'user' ，且用户性别为 '女性' 的用户
let promise = chat.searchCloudUsers({
   keywordList: ['test', 'user'],
   gender: TencentCloudChat.TYPES.GENDER.FEMALE,
});

// 搜索指定关键字列表和出生时间范围搜索
// - 搜索用户里出现 'test' 或 'user' ，且用户出生时间在 19500101 至 20240101 之间的用户
// - 注意，当同时设置 miniBirthday 和 maxBirthday 时，miniBirthday 必须小于 maxBirthday
let promise = chat.searchCloudUsers({
   keywordList: ['test', 'user'],
   miniBirthday: 19500101,
   maxBirthday: 20240101,
});

// 搜索指定关键字列表和出生时间范围搜索
// - 搜索用户里出现 'test' 或 'user' ，且用户出生时间在 19500101 之后的用户
let promise = chat.searchCloudUsers({
   keywordList: ['test', 'user'],
   miniBirthday: 19500101,
});

// 搜索指定关键字列表和出生时间范围搜索
// - 搜索用户里出现 'test' 或 'user' ，且用户出生时间在 20240101 之前的用户
let promise = chat.searchCloudUsers({
   keywordList: ['test', 'user'],
   maxBirthday: 20240101,
});

promise.then(function(imResponse) {
 // 搜索用户成功
   const { totalCount, cursor, searchResultList } = imResponse.data;
   console.log(totalCount); // 满足搜索条件的用户总数量
   console.log(cursor); // 下一次云端搜索的起始位置, 如果没有表示搜索结果拉取完成
   console.log(searchResultList); // 满足搜索条件的用户列表，分页返回分组结果，每页最大返回 100, count 设定
   for (let i = 0; i < searchResultList.length; i++) {
      const profileItem = searchResultList[i];
      const { userID, nick, gender, avatar } = profileItem;
      console.log(userID); // 用户 ID
      console.log(nick); // 用户昵称
      console.log(gender); // 用户性别
      console.log(avatar); // 用户头像
    }
}).catch(function(imError) {
   console.error(imError); // 搜索用户失败
});

Parameters:

Returns:

Type

Promise

searchCloudGroups(options) → {Promise}

Examples

// 搜索指定关键字
// - 搜索群组里出现 'test' 或 'user' 的群组
let promise = chat.searchCloudGroups({
   keywordList: ['test', 'user'],
});

// 搜索指定关键字和匹配类型搜索
// - 搜索群组里同时出现 'test' 与 'user' 的群组
let promise = chat.searchCloudGroups({
   keywordList: ['test', 'user'],
   keywordListMatchType: 'and',
});

// 搜索指定关键字列表和群组类型
// - 搜索用户里出现 'test' 或 'user' ，且群组类型为 '陌生人社交群(TencentCloudChat.TYPES.GRP_PUBLIC)' 或 '好友工作群(TencentCloudChat.TYPES.GRP_WORK)' 的群组
let promise = chat.searchCloudGroups({
   keywordList: ['test', 'user'],
   groupTypeList: [TencentCloudChat.TYPES.GRP_PUBLIC, TencentCloudChat.TYPES.GRP_WORK],
});

promise.then(function(imResponse) {
 // 搜索群组成功
   const { totalCount, cursor, searchResultList } = imResponse.data;
   console.log(totalCount); // 满足搜索条件的群组总数量
   console.log(cursor); // 下一次云端搜索的起始位置, 如果没有表示搜索结果拉取完成
   console.log(searchResultList); // 满足搜索条件的群组列表，分页返回分组结果，每页最大返回 100 条，根据传入 count 设定
   for (let i = 0; i < searchResultList.length; i++) {
      const groupItem = searchResultList[i];
      const { groupID, name, type, avatar, memberCount, introduction, ownerID } = groupItem;
      console.log(groupID); // 群 ID
      console.log(name); // 群名称
      console.log(type); // 群类型
      console.log(avatar); // 群头像
      console.log(memberCount); // 群组当前成员数量
      console.log(introduction); // 群简介
      console.log(ownerID); // 群主 userID
    }
}).catch(function(imError) {
   console.error(imError); // 搜索用户失败
});

Parameters:

Returns:

Type

Promise

searchCloudGroupMembers(options) → {Promise}

Examples

// 搜索指定关键字
// - 搜索当前加入群组的群成员里出现 'test' 或 'user' 的群成员
let promise = chat.searchCloudGroupMembers({
   keywordList: ['test', 'user'],
});

// 搜索指定关键字和匹配类型搜索
// - 搜索当前加入群组的群成员里同时出现 'test' 与 'user' 的群成员
let promise = chat.searchCloudGroupMembers({
   keywordList: ['test', 'user'],
   keywordListMatchType: 'and',
});

// 搜索指定关键字列表和群组类型
// - 搜索当前加入群组的群成员里出现 'test' 或 'user'，且群组类型为 '陌生人社交群' 或 '好友工作群' 的群的群成员
let promise = chat.searchCloudGroupMembers({
   keywordList: ['test', 'user'],
   groupTypeList: [TencentCloudChat.TYPES.GRP_PUBLIC, TencentCloudChat.TYPES.GRP_WORK],
});

// 搜索指定关键字列表和群ID列表
// - 搜索当前加入群组的群成员里出现 'test' 或 'user'，且群ID为 'group1' 或 'group2' 的群的群成员
let promise = chat.searchCloudGroupMembers({
   keywordList: ['test', 'user'],
   groupIDList: ['group1', 'group2'],
});

promise.then(function(imResponse) {
 // 搜索群成员成功
   const { totalCount, cursor, searchResultList } = imResponse.data;
   console.log(totalCount); // 满足搜索条件的群成员总数量
   console.log(cursor); // 下一次云端搜索的起始位置, 如果没有表示搜索结果拉取完成
   console.log(searchResultList); // 满足搜索条件的群成员列表，分页返回分组结果，每页最大返回 100 条，根据传入 count 设定
   for (let i = 0; i < searchResultList.length; i++) {
      const searchResultItem = searchResultList[i];
      const { groupInfo, memberList } = searchResultItem;
      const { groupID, name, type, avatar } = groupInfo;
      // 群 groupID / 群名称 / 群类型 / 群头像
      console.log(groupID, name, type, avatar);
      console.log(memberList); // 该群中满足条件成员列表
      for (let i = 0; i < memberList.length; i++) {
        const memberItem = memberList[i];
        const { userID, nick, nameCard } = memberItem;
        console.log(userID); // 群成员用户 ID
        console.log(nick); // 群成员用户昵称
        console.log(nameCard); // 群成员群名片
      }
    }
}).catch(function(imError) {
   console.error(imError); // 搜索群成员失败
});

Parameters:

Returns:

Type

Promise

getMyProfile() → {Promise}

See:

• 资料结构描述

Example

let promise = chat.getMyProfile();
promise.then(function(imResponse) {
  console.log(imResponse.data); // 个人资料 - Profile 实例
}).catch(function(imError) {
  console.warn('getMyProfile error:', imError); // 获取个人资料失败的相关信息
});

Returns:

Type

Promise

getUserProfile(options) → {Promise}

Example

let promise = chat.getUserProfile({
  userIDList: ['user1', 'user2'] // 请注意：即使只拉取一个用户的资料，也需要用数组类型，例如：userIDList: ['user1']
});
promise.then(function(imResponse) {
  console.log(imResponse.data); // 存储用户资料的数组 - [Profile]
}).catch(function(imError) {
  console.warn('getUserProfile error:', imError); // 获取其他用户资料失败的相关信息
});

Parameters:

Returns:

Type

Promise

updateMyProfile(options) → {Promise}

Examples

// 修改个人标配资料
let promise = chat.updateMyProfile({
  nick: '我的昵称',
  avatar: 'http(s)://url/to/image.jpg',
  gender: TencentCloudChat.TYPES.GENDER_MALE,
  selfSignature: '我的个性签名',
  allowType: TencentCloudChat.TYPES.ALLOW_TYPE_ALLOW_ANY
});
promise.then(function(imResponse) {
  console.log(imResponse.data); // 更新资料成功
}).catch(function(imError) {
  console.warn('updateMyProfile error:', imError); // 更新资料失败的相关信息
});

// 修改个人自定义资料
// 自定义资料字段需要预先在控制台配置，详细请参考：https://cloud.tencent.com/document/product/269/1500#.E8.87.AA.E5.AE.9A.E4.B9.89.E8.B5.84.E6.96.99.E5.AD.97.E6.AE.B5
let promise = chat.updateMyProfile({
  // 这里要求您已在即时通信 IM 控制台>【应用配置】>【功能配置】 申请了自定义资料字段 Tag_Profile_Custom_Test1
  // 注意！即使只有一个自定义资料字段，profileCustomField 也需要用数组类型
  profileCustomField: [
    {
      key: 'Tag_Profile_Custom_Test1',
      value: '我的自定义资料1'
    }
  ]
});
promise.then(function(imResponse) {
  console.log(imResponse.data); // 更新资料成功
}).catch(function(imError) {
  console.warn('updateMyProfile error:', imError); // 更新资料失败的相关信息
});

// 修改个人标配资料和自定义资料
let promise = chat.updateMyProfile({
  nick: '我的昵称',
  // 这里要求您已在即时通信 IM 控制台>【应用配置】>【功能配置】 申请了自定义资料字段 Tag_Profile_Custom_Test1 和 Tag_Profile_Custom_Test2
  profileCustomField: [
    {
      key: 'Tag_Profile_Custom_Test1',
      value: '我的自定义资料1'
    },
    {
      key: 'Tag_Profile_Custom_Test2',
      value: '我的自定义资料2'
    },
  ]
});
promise.then(function(imResponse) {
  console.log(imResponse.data); // 更新资料成功
}).catch(function(imError) {
  console.warn('updateMyProfile error:', imError); // 更新资料失败的相关信息
});

Parameters:

Returns:

Type

Promise

getBlacklist() → {Promise}

Example

let promise = chat.getBlacklist();
promise.then(function(imResponse) {
  console.log(imResponse.data); // 我的黑名单列表，结构为包含用户 userID 的数组 - [userID]
}).catch(function(imError) {
  console.warn('getBlacklist error:', imError); // 获取黑名单列表失败的相关信息
});

Returns:

Type

Promise

addToBlacklist(options) → {Promise}

Example

let promise = chat.addToBlacklist({userIDList: ['user1', 'user2']}); // 请注意：即使只添加一个用户账号到黑名单，也需要用数组类型，例如：userIDList: ['user1']
promise.then(function(imResponse) {
  console.log(imResponse.data); // 被拉黑的全量账号列表，结构为包含用户 userID 的数组 - [userID]
}).catch(function(imError) {
  console.warn('addToBlacklist error:', imError); // 添加用户到黑名单列表失败的相关信息
});

Parameters:

Returns:

Type

Promise

removeFromBlacklist(options) → {Promise}

Example

let promise = chat.removeFromBlacklist({userIDList: ['user1', 'user2']}); // 请注意：即使只从黑名单中移除一个用户账号，也需要用数组类型，例如：userIDList: ['user1']
promise.then(function(imResponse) {
  console.log(imResponse.data); // 被拉黑的全量账号列表，结构为包含用户 userID 的数组 - [userID]
}).catch(function(imError) {
  console.warn('removeFromBlacklist error:', imError); // 将用户从黑名单中移除失败的相关信息
});

Parameters:

Returns:

Type

Promise

setSelfStatus(options) → {Promise}

Example

// 设置 customStatus 为空字符串 ''，则清除自己的自定义状态
let promise = chat.setSelfStatus({customStatus: 'xxx'});
promise.then(function(imResponse) {
  console.log(imResponse.data);
  const { userID, statusType, customStatus } = imResponse.data;
  // userID - 用户 ID
  // statusType - 用户状态，枚举值及说明如下：
  // TencentCloudChat.TYPES.USER_STATUS_UNKNOWN - 未知
  // TencentCloudChat.TYPES.USER_STATUS_ONLINE - 在线
  // TencentCloudChat.TYPES.USER_STATUS_OFFLINE - 离线
  // TencentCloudChat.TYPES.USER_STATUS_UNLOGINED - 未登录
  // customStatus - 用户自定义状态
}).catch(function(imError) {
  console.warn('setSelfStatus error:', imError); // 设置用户自己的自定义状态失败的相关信息
});

Parameters:

Returns:

Type

Promise

getUserStatus(options) → {Promise}

Examples

// 查询自己的用户状态
// userIDList 仅包含自己的 userID 时表示查询自己的状态
let promise = chat.getUserStatus({userIDList: [`${myUserID}`]});
promise.then(function(imResponse) {
   const { successUserList } = imResponse.data;
   successUserList.forEach((item) => {
     const { userID, statusType, customStatus } = item;
     // userID - 用户 ID
     // statusType - 用户状态，枚举值及说明如下：
     // TencentCloudChat.TYPES.USER_STATUS_UNKNOWN - 未知
     // TencentCloudChat.TYPES.USER_STATUS_ONLINE - 在线
     // TencentCloudChat.TYPES.USER_STATUS_OFFLINE - 离线
     // TencentCloudChat.TYPES.USER_STATUS_UNLOGINED - 未登录
     // customStatus - 用户自定义状态
   });
}).catch(function(imError) {
  console.warn('getUserStatus error:', imError); // 获取用户状态失败的相关信息
});

// 查询其他用户的状态
let promise = chat.getUserStatus({userIDList: ['user0', 'user1']});
promise.then(function(imResponse) {
   const { successUserList, failureUserList } = imResponse.data;
   // 查询成功的用户列表
   successUserList.forEach((item) => {
     const { userID, statusType, customStatus } = item;
     // userID - 用户 ID
     // statusType - 用户状态，枚举值及说明如下：
     // TencentCloudChat.TYPES.USER_STATUS_UNKNOWN - 未知
     // TencentCloudChat.TYPES.USER_STATUS_ONLINE - 在线
     // TencentCloudChat.TYPES.USER_STATUS_OFFLINE - 离线
     // TencentCloudChat.TYPES.USER_STATUS_UNLOGINED - 未登录
     // customStatus - 用户自定义状态
   });

   // 查询失败的用户列表
   failureUserList.forEach((item) => {
     const { userID, code, message } = item;
     // userID - 查询失败的用户 ID
     // code - 查询失败的错误码
     // message - 查询失败的错误信息
   });
}).catch(function(imError) {
  console.warn('getUserStatus error:', imError); // 获取用户状态失败的相关信息
});

Parameters:

Returns:

Type

Promise

subscribeUserStatus(options) → {Promise}

Example

let promise = chat.subscribeUserStatus({userIDList: ['user0', 'user1']});
promise.then(function(imResponse) {
  const { failureUserList } = imResponse.data;
   // 订阅失败的用户列表
   failureUserList.forEach((item) => {
     const { userID, code, message } = item;
     // userID - 查询失败的用户 ID
     // code - 查询失败的错误码
     // message - 查询失败的错误信息
   });
}).catch(function(imError) {
  console.warn('subscribeUserStatus error:', imError); // 订阅用户状态失败的相关信息
});

Parameters:

Returns:

Type

Promise

unsubscribeUserStatus(options) → {Promise}

Examples

// 取消当前部分用户的订阅
let promise = chat.unsubscribeUserStatus({userIDList: ['user0', 'user1']});
promise.then(function(imResponse) {
  const { failureUserList } = imResponse.data;
   // 取消订阅失败的用户列表
   failureUserList.forEach((item) => {
     const { userID, code, message } = item;
     // userID - 查询失败的用户 ID
     // code - 查询失败的错误码
     // message - 查询失败的错误信息
   });
}).catch(function(imError) {
  console.warn('unsubscribeUserStatus error:', imError); // 取消订阅失败的相关信息
});

// 取消当前所有的订阅
let promise = chat.unsubscribeUserStatus();
promise.then(function(imResponse) {
  const { failureUserList } = imResponse.data;
   // 取消订阅失败的用户列表
   failureUserList.forEach((item) => {
     const { userID, code, message } = item;
     // userID - 查询失败的用户 ID
     // code - 查询失败的错误码
     // message - 查询失败的错误信息
   });
}).catch(function(imError) {
  console.warn('unsubscribeUserStatus error:', imError); // 取消订阅失败的相关信息
});

Parameters:

Returns:

Type

Promise

getFriendList() → {Promise}

Example

let promise = chat.getFriendList();
promise.then(function(imResponse) {
  const friendList = imResponse.data; // 好友列表
}).catch(function(imError) {
  console.warn('getFriendList error:', imError); // 获取好友列表失败的相关信息
});

Returns:

Type

Promise

addFriend(options) → {Promise}

Example

// 添加好友
let promise = chat.addFriend({
  to: 'user1',
  source: 'AddSource_Type_Web',
  remark: '小橙子',
  groupName: '好友',
  wording: '我是 user0',
  type: TencentCloudChat.TYPES.SNS_ADD_TYPE_BOTH,
});
promise.then(function(imResponse) {
  // 添加好友的请求发送成功
  const { code } = imResponse.data;
  if (code === 30539) {
    // 30539 说明 user1 设置了【需要经过自己确认对方才能添加自己为好友】，此时 SDK 会触发 TencentCloudChat.EVENT.FRIEND_APPLICATION_LIST_UPDATED 事件
  } else if (code === 0) {
    // 0 说明 user1 设置了【允许任何人添加自己为好友】，此时 SDK 会触发 TencentCloudChat.EVENT.FRIEND_LIST_UPDATED 事件
  }
}).catch(function(imError) {
  console.warn('addFriend error:', imError); // 添加好友失败的相关信息
});

Parameters:

Returns:

Type

Promise

deleteFriend(options) → {Promise}

Example

let promise = chat.deleteFriend({
  userIDList: ['user1','user2'],
  type: TencentCloudChat.TYPES.SNS_DELETE_TYPE_BOTH
});
promise.then(function(imResponse) {
  const { successUserIDList, failureUserIDList } = imResponse.data;
  // 删除成功的 userIDList
  successUserIDList.forEach((item) => {
    const { userID } = item;
  });
  // 删除失败的 userIDList
  failureUserIDList.forEach((item) => {
    const { userID, code, message } = item;
  });
  // 如果好友列表有变化，则 SDK 会触发 TencentCloudChat.EVENT.FRIEND_LIST_UPDATED 事件
}).catch(function(imError) {
  console.warn('removeFromFriendList error:', imError);
});

Parameters:

Returns:

Type

Promise

checkFriend(options) → {Promise}

Example

let promise = chat.checkFriend({
  userIDList: ['user0','user1'],
  type: TencentCloudChat.TYPES.SNS_CHECK_TYPE_BOTH,
});
promise.then(function(imResponse) {
  const { successUserIDList, failureUserIDList } = imResponse.data;
  // 校验成功的 userIDList
  successUserIDList.forEach((item) => {
    const { userID, code, relation } = item; // 此时 code 始终为0
    // 单向校验好友关系时可能的结果有：
    // - relation: TencentCloudChat.TYPES.SNS_TYPE_NO_RELATION A 的好友表中没有 B，但无法确定 B 的好友表中是否有 A
    // - relation: TencentCloudChat.TYPES.SNS_TYPE_A_WITH_B A 的好友表中有 B，但无法确定 B 的好友表中是否有 A
    // 双向校验好友关系时可能的结果有：
    // - relation: TencentCloudChat.TYPES.SNS_TYPE_NO_RELATION A 的好友表中没有 B，B 的好友表中也没有 A
    // - relation: TencentCloudChat.TYPES.SNS_TYPE_A_WITH_B A 的好友表中有 B，但 B 的好友表中没有 A
    // - relation: TencentCloudChat.TYPES.SNS_TYPE_B_WITH_A A 的好友表中没有 B，但 B 的好友表中有 A
    // - relation: TencentCloudChat.TYPES.SNS_TYPE_BOTH_WAY A 的好友表中有 B，B 的好友表中也有 A
  });
  // 校验失败的 userIDList
  failureUserIDList.forEach((item) => {
    const { userID, code, message } = item;
  });
}).catch(function(imError) {
  console.warn('checkFriend error:', imError);
});

Parameters:

Returns:

Type

Promise

getFriendProfile(options) → {Promise}

Example

// 获取好友标配字段、好友自定义字段、资料标配字段、资料自定义字段
let promise = chat.getFriendProfile({
  userIDList: ['user0','user1']
});
promise.then(function(imResponse) {
  const { friendList, failureUserIDList } = imResponse.data;
  friendList.forEach((friend) => {
    // Friend 对象
  });
  // 失败的 userIDList
  failureUserIDList.forEach((item) => {
    const { userID, code, message } = item;
  });
}).catch(function(imError) {
  console.warn('getFriendProfile error:', imError); // 获取失败
});

Parameters:

Returns:

Type

Promise

updateFriend(options) → {Promise}

Examples

// 更新好友备注
let promise = chat.updateFriend({
  userID: 'user1',
  remark: 'helloworld'
});
promise.then(function(imResponse) {
  console.log(imResponse.data); // Friend 实例
}).catch(function(imError) {
  console.warn('getFriendProfile error:', imError); // 更新失败
});

// 更新好友自定义字段
let promise = chat.updateFriend({
  userID: 'user1',
  friendCustomField: [
    // 好友自定义字段必须以 Tag_SNS_Custom 为前缀
    { key: 'Tag_SNS_Custom_test1', value: 'hello' },
    { key: 'Tag_SNS_Custom_test2', value: 'world' },
  ]
});
promise.then(function(imResponse) {
  console.log(imResponse.data); // Friend 实例
}).catch(function(imError) {
  console.warn('getFriendProfile error:', imError); // 更新失败
});

Parameters:

Returns:

Type

Promise

getFriendApplicationList() → {Promise}

Example

let promise = chat.getFriendApplicationList();
promise.then(function(imResponse) {
  // friendApplicationList - 好友申请列表 - [FriendApplication]
  // FriendApplication 数据结构详情请参考 https://web.sdk.qcloud.com/im/doc/v3/zh-cn/FriendApplication.html
  // unreadCount - 好友申请的未读数
  // const { friendApplicationList, unreadCount } = imResponse.data;
});

Returns:

Type

Promise

acceptFriendApplication(options) → {Promise}

Example

let promise = chat.acceptFriendApplication({
  userID: 'user1',
  remark: '客服小亮',
  type: TencentCloudChat.TYPES.SNS_APPLICATION_AGREE_AND_ADD
});
promise.then(function(imResponse) {
  // 同意好友成功后，SDK 会触发 TencentCloudChat.EVENT.FRIEND_APPLICATION_LIST_UPDATED 事件
}).catch(function(imError) {
  console.warn('acceptFriendApplication error:', imError);
});

Parameters:

Returns:

Type

Promise

refuseFriendApplication(options) → {Promise}

Example

let promise = chat.refuseFriendApplication({
  userID: 'user1',
});
promise.then(function(imResponse) {
// 拒绝成功后，SDK 会触发 TencentCloudChat.EVENT.FRIEND_APPLICATION_LIST_UPDATED 事件
}).catch(function(imError) {
  console.warn('refuseFriendApplication error:', imError);
});

Parameters:

Returns:

Type

Promise

deleteFriendApplication(options) → {Promise}

Example

let promise = chat.deleteFriendApplication({
  userID: 'user1',
  type: TencentCloudChat.TYPES.SNS_APPLICATION_SENT_TO_ME
});
promise.then(function(imResponse) {
  // 删除成功后，SDK 会触发 TencentCloudChat.EVENT.FRIEND_APPLICATION_LIST_UPDATED 事件
}).catch(function(imError) {
  console.warn('deleteFriendApplication error:', imError);
});

Parameters:

Returns:

Type

Promise

setFriendApplicationRead() → {Promise}

Example

// 上报好友申请已读
let promise = chat.setFriendApplicationRead();
promise.then(function(imResponse) {
  // 已读上报成功
}).catch(function(imError) {
  console.warn('setFriendApplicationRead error:', imError);
});

Returns:

Type

Promise

getFriendGroupList() → {Promise}

Example

let promise = chat.getFriendGroupList();
promise.then(function(imResponse) {
  const friendGroupList = imResponse.data; // 好友分组列表
}).catch(function(imError) {
  console.warn('getFriendGroupList error:', imError); // 获取好友分组列表失败的相关信息
});

Returns:

Type

Promise

createFriendGroup(options) → {Promise}

Example

let promise = chat.createFriendGroup({
  name: '我的好友分组1',
  userIDList: ['user0','user1']
});
promise.then(function(imResponse) {
  const { friendGroup，failureUserIDList } = imResponse;
  // friendGroup - 好友分组实例
  // failureUserIDList - 失败的 userID 列表
  // 创建成功后，SDK 会触发 TencentCloudChat.EVENT.FRIEND_GROUP_LIST_UPDATED 事件
}).catch(function(imError) {
  console.warn('getFriendGroupInfo error:', imError); // 获取失败
});

Parameters:

Returns:

Type

Promise

deleteFriendGroup(options) → {Promise}

Example

let promise = chat.deleteFriendGroup({
  name: '我的好友分组1',
});
promise.then(function(imResponse) {
  console.log(imResponse.data); // 被删除的分组实例
  // 删除成功后，SDK 会触发 TencentCloudChat.EVENT.FRIEND_GROUP_LIST_UPDATED 事件
}).catch(function(imError) {
  console.warn('deleteFriendGroup error:', imError); // 获取失败
});

Parameters:

Returns:

Type

Promise

addToFriendGroup(options) → {Promise}

Example

let promise = chat.addToFriendGroup({
  name: '我的好友分组1',
  userIDList: ['user1','user2'],
});
promise.then(function(imResponse) {
  const { friendGroup, failureUserIDList } = imResponse.data;
  // friendGroup - 好友分组实例
  // failureUserIDList - 失败的 userID 列表
  // 添加成功后，SDK 会触发 TencentCloudChat.EVENT.FRIEND_GROUP_LIST_UPDATED 事件
}).catch(function(imError) {
  console.warn('addToFriendGroup error:', imError); // 获取失败
});

Parameters:

Returns:

Type

Promise

removeFromFriendGroup(options) → {Promise}

Example

let promise = chat.removeFromFriendGroup({
  name: '我的好友分组1',
  userIDList: ['user1','user2'],
});
promise.then(function(imResponse) {
  const { friendGroup, failureUserIDList } = imResponse.data;
  // friendGroup - 好友分组实例
  // failureUserIDList - 失败的 userID 列表
  // 移除成功后，SDK 会触发 TencentCloudChat.EVENT.FRIEND_GROUP_LIST_UPDATED 事件
}).catch(function(imError) {
  console.warn('addToFriendGroup error:', imError); // 获取失败
});

Parameters:

Returns:

Type

Promise

renameFriendGroup(options) → {Promise}

Example

let promise = chat.renameFriendGroup({
  oldName: '好友',
  newName: '闺蜜'
});
promise.then(function(imResponse) {
  console.log(imResponse.data); // FriendGroup 实例
  // 修改成功后，SDK 会触发 TencentCloudChat.EVENT.FRIEND_GROUP_LIST_UPDATED 事件
}).catch(function(imError) {
  console.warn('updateMyProfile error:', imError);
});

Parameters:

Returns:

Type

Promise

followUser(userIDList) → {Promise}

Example

let promise = chat.followUser(['user1', 'user2']);
promise.then(function(imResponse) {
  console.log(imResponse.data); // 关注的结果信息
}).catch(function(imError) {
  console.warn('followUser error:', imError);
});

Parameters:

Returns:

Type

Promise

unfollowUser(userIDList) → {Promise}

Example

let promise = chat.unfollowUser(['user1', 'user2']);
promise.then(function(imResponse) {
  console.log(imResponse.data); // 取消关注的结果信息
}).catch(function(imError) {
  console.warn('unfollowUser error:', imError);
});

Parameters:

Returns:

Type

Promise

getMyFollowersList(nextCursoropt) → {Promise}

Example

let promise = chat.getMyFollowersList();
promise.then(function(imResponse) {
  const { resultList, nextCursor = '' } = imResponse.data;
  // ressultList - 我的粉丝列表
  // nextCursor - 分页续拉的标识
  if (nextCursor != '') {
    // 需要续拉
  }
}).catch(function(imError) {
  console.warn('getMyFollowersList error:', imError);
});

Parameters:

Returns:

Type

Promise

getMyFollowingList(nextCursoropt) → {Promise}

Example

let promise = chat.getMyFollowingList();
promise.then(function(imResponse) {
  const { resultList, nextCursor = '' } = imResponse.data;
  // ressultList - 我的关注列表
  // nextCursor - 分页续拉的标识
  if (nextCursor != '') {
    // 需要续拉
  }
}).catch(function(imError) {
  console.warn('getMyFollowingList error:', imError);
});

Parameters:

Returns:

Type

Promise

getMutualFollowersList(nextCursoropt) → {Promise}

Example

let promise = chat.getMutualFollowersList();
promise.then(function(imResponse) {
  const { resultList, nextCursor = '' } = imResponse.data;
  // ressultList - 互关列表
  // nextCursor - 分页续拉的标识
  if (nextCursor != '') {
    // 需要续拉
  }
}).catch(function(imError) {
  console.warn('getMutualFollowersList error:', imError);
});

Parameters:

Returns:

Type

Promise

getUserFollowInfo(userIDList) → {Promise}

Examples

// 获取自己的 关注/粉丝/互关 数量信息
let promise = chat.getUserFollowInfo();
promise.then(function(imResponse) {
  console.log(imResponse.data); // 获取成功
}).catch(function(imError) {
  console.warn('getUserFollowInfo error:', imError);
});

// 获取指定用户的 关注/粉丝/互关 数量信息
let promise = chat.getUserFollowInfo(['user1', 'user2']);
promise.then(function(imResponse) {
  console.log(imResponse.data); // 获取成功
}).catch(function(imError) {
  console.warn('getUserFollowInfo error:', imError);
});

Parameters:

Returns:

Type

Promise

checkFollowType(userIDList) → {Promise}

Example

let promise = chat.checkFollowType(['user1', 'user2']);
promise.then(function(imResponse) {
  console.log(imResponse.data); // 校验结果列表
  imResponse.data.forEach((item) => {
    // item.userID - 用户 userID
    // item.followType - 关注关系（0 - 没有关系, 1 - 粉丝, 2 - 关注, 3 - 互关）
  });
}).catch(function(imError) {
  console.warn('checkFollowType error:', imError);
});

Parameters:

Returns:

Type

Promise

getGroupList() → {Promise}

See:

• Group

Example

// 该接口默认只会拉取这些资料：群类型、群名称、群头像、最后一条消息的时间。
let promise = chat.getGroupList();
promise.then(function(imResponse) {
  console.log(imResponse.data.groupList); // 群组列表
}).catch(function(imError) {
  console.warn('getGroupList error:', imError); // 获取群组列表失败的相关信息
});

Returns:

Type

Promise

getGroupProfile(options) → {Promise}

See:

• Group

Example

let promise = chat.getGroupProfile({ groupID: 'group1', groupCustomFieldFilter: ['key1','key2'] });
promise.then(function(imResponse) {
  console.log(imResponse.data.group);
}).catch(function(imError) {
  console.warn('getGroupProfile error:', imError); // 获取群详细资料失败的相关信息
});

Parameters:

Returns:

Type

Promise

createGroup(options) → {Promise}

See:

• Group
• 群组形态介绍

Examples

// 创建好友工作群
let promise = chat.createGroup({
  type: TencentCloudChat.TYPES.GRP_WORK,
  name: 'WebSDK',
  memberList: [{
    userID: 'user1',
    // 群成员维度的自定义字段，默认情况是没有的，需要开通，详情请参阅自定义字段
    memberCustomField: [{key: 'group_member_test', value: 'test'}]
  }, {
    userID: 'user2'
  }] // 如果填写了 memberList，则必须填写 userID
});
promise.then(function(imResponse) { // 创建成功
  console.log(imResponse.data.group); // 创建的群的资料
  // 创建群时指定了成员列表，但是成员中存在超过了“单个用户可加入群组数”限制的情况
  // 一个用户 userX 最多允许加入 N 个群，如果已经加入了 N 个群，此时创建群再指定 userX 为群成员，则 userX 不能正常加群
  // SDK 将 userX 的信息放入 overLimitUserIDList，供接入侧处理
  console.log(imResponse.data.overLimitUserIDList); // 超过了“单个用户可加入群组数”限制的用户列表
}).catch(function(imError) {
  console.warn('createGroup error:', imError); // 创建群组失败的相关信息
});

// 创建支持话题的社群
let promise = chat.createGroup({
  type: TencentCloudChat.TYPES.GRP_COMMUNITY,
  name: 'WebSDK',
  isSupportTopic: true,
});
promise.then(function(imResponse) { // 创建成功
  console.log(imResponse.data.group); // 创建的群的资料
}).catch(function(imError) {
  console.warn('createGroup error:', imError); // 创建群组失败的相关信息
});

// 创建邀请进群需要审批的 TencentCloudChat.TYPES.GRP_PUBLIC 类型群组
let promise = chat.createGroup({
  type: TencentCloudChat.TYPES.GRP_PUBLIC,
  name: 'WebSDK',
  inviteOption: TencentCloudChat.TYPES.INVITE_OPTIONS_NEED_PERMISSION,
});
promise.then(function(imResponse) { // 创建成功
  console.log(imResponse.data.group); // 创建的群的资料
}).catch(function(imError) {
  console.warn('createGroup error:', imError); // 创建群组失败的相关信息
});

Parameters:

Returns:

Type

Promise

dismissGroup(groupID) → {Promise}

See:

• Group
• 群组管理

Example

let promise = chat.dismissGroup('group1');
promise.then(function(imResponse) { // 解散成功
  console.log(imResponse.data.groupID); // 被解散的群组 ID
}).catch(function(imError) {
  console.warn('dismissGroup error:', imError); // 解散群组失败的相关信息
});

Parameters:

Returns:

Type

Promise

updateGroupProfile(options) → {Promise}

See:

• Group
• 群组管理

Examples

let promise = chat.updateGroupProfile({
  groupID: 'group1',
  name: 'new name', // 修改群名称
  introduction: 'this is introduction.', // 修改群简介
  // 群成员能收到群自定义字段变更的群提示消息，且能获取到相关的内容，详见 Message.payload.newGroupProfile.groupCustomField
  groupCustomField: [{ key: 'group_level', value: 'high'}] // 修改群组维度自定义字段
});
promise.then(function(imResponse) {
  console.log(imResponse.data.group) // 修改成功后的群组详细资料
}).catch(function(imError) {
  console.warn('updateGroupProfile error:', imError); // 修改群组资料失败的相关信息
});

let promise = chat.updateGroupProfile({
  groupID: 'group1',
  muteAllMembers: true, // true 表示全体禁言，false表示取消全体禁言
});
promise.then(function(imResponse) {
  console.log(imResponse.data.group) // 修改成功后的群组详细资料
}).catch(function(imError) {
  console.warn('updateGroupProfile error:', imError); // 修改群组资料失败的相关信息
});

// 修改邀请进群选项
let promise = chat.updateGroupProfile({
  groupID: 'group1',
  inviteOption: TencentCloudChat.TYPES.INVITE_OPTIONS_NEED_PERMISSION,
});
promise.then(function(imResponse) {
  console.log(imResponse.data.group) // 修改成功后的群组详细资料
}).catch(function(imError) {
  console.warn('updateGroupProfile error:', imError); // 修改群组资料失败的相关信息
});

Parameters:

Returns:

Type

Promise

joinGroup(options) → {Promise}

See:

• Group

Example

let promise = chat.joinGroup({ groupID: 'group1' });
promise.then(function(imResponse) {
  switch (imResponse.data.status) {
    case TencentCloudChat.TYPES.JOIN_STATUS_WAIT_APPROVAL: // 等待管理员同意
      break;
    case TencentCloudChat.TYPES.JOIN_STATUS_SUCCESS: // 加群成功
      console.log(imResponse.data.group); // 加入的群组资料
      break;
    case TencentCloudChat.TYPES.JOIN_STATUS_ALREADY_IN_GROUP: // 已经在群中
      break;
    default:
      break;
  }
}).catch(function(imError){
  console.warn('joinGroup error:', imError); // 申请加群失败的相关信息
});

Parameters:

Returns:

Type

Promise

quitGroup(groupID) → {Promise}

See:

• Group
• 群组管理

Example

let promise = chat.quitGroup('group1');
promise.then(function(imResponse) {
  console.log(imResponse.data.groupID); // 退出成功的群 ID
}).catch(function(imError){
  console.warn('quitGroup error:', imError); // 退出群组失败的相关信息
});

Parameters:

Returns:

Type

Promise

pinGroupMessage(options) → {Promise}

Examples

// 置顶消息
let promise = chat.pinGroupMessage({
 groupID: 'group1',
 message: message,
 isPinned: true,
});
promise.then(function(imResponse) {
  // 置顶消息成功
}).catch(function(imError){
  console.warn('pinGroupMessage error:', imError); // 置顶消息失败的相关信息
});

// 取消消息置顶
let promise = chat.pinGroupMessage({
 groupID: 'group1',
 message: message,
 isPinned: false,
});
promise.then(function(imResponse) {
  // 取消消息置顶成功
}).catch(function(imError){
  console.warn('pinGroupMessage error:', imError); // 取消消息置顶失败的相关信息
});

Parameters:

Returns:

Type

Promise

getPinnedGroupMessageList(groupID) → {Promise}

Example

let promise = chat.getPinnedGroupMessageList('group1');
promise.then(function(imResponse) {
  console.log(imResponse.data.messageList); // 获取已置顶的消息列表成功
}).catch(function(imError){
  console.warn('getPinnedGroupMessageList error:', imError); // 获取已置顶的消息列表失败的相关信息
});

Parameters:

Returns:

Type

Promise

searchGroupByID(groupID) → {Promise}

See:

• Group

Example

let promise = chat.searchGroupByID('group1');
promise.then(function(imResponse) {
  const group = imResponse.data.group; // 群组信息
}).catch(function(imError) {
  console.warn('searchGroupByID error:', imError); // 搜素群组失败的相关信息
});

Parameters:

Returns:

Type

Promise

getGroupOnlineMemberCount(groupID) → {Promise}

See:

• Group

Example

let promise = chat.getGroupOnlineMemberCount('group1');
promise.then(function(imResponse) {
  console.log(imResponse.data.memberCount);
}).catch(function(imError) {
  console.warn('getGroupOnlineMemberCount error:', imError); // 获取群在线人数失败的相关信息
});

Parameters:

Returns:

Type

Promise

changeGroupOwner(options) → {Promise}

See:

• Group

Example

let promise = chat.changeGroupOwner({
  groupID: 'group1',
  newOwnerID: 'user2'
});
promise.then(function(imResponse) { // 转让成功
  console.log(imResponse.data.group); // 群组资料
}).catch(function(imError) { // 转让失败
  console.warn('changeGroupOwner error:', imError); // 转让群组失败的相关信息
});

Parameters:

Returns:

Type

Promise

getGroupApplicationList() → {Promise}

Example

let promise = chat.getGroupApplicationList();
promise.then(function(imResponse) {
  const { applicationList } = imResponse.data;
  applicationList.forEach((item) => {
    // item.applicant - 申请者 userID
    // item.applicantNick - 申请者昵称
    // item.groupID - 群 ID
    // item.groupName - 群名称
    // item.applicationType - 申请类型：0 加群申请，2 邀请进群申请
    // item.userID - applicationType = 2时，是被邀请用户的 userID
    // item.note - 附言信息，邀请加群暂不支持，返回为空字符串
    // 接入侧可调用 handleGroupApplication 接口同意或拒绝加群申请
    chat.handleGroupApplication({
      handleAction: 'Agree',
      application: {...item},
    });
  });
}).catch(function(imError) {
  console.warn('getGroupApplicationList error:', imError);
});

Returns:

Type

Promise

handleGroupApplication(options) → {Promise}

See:

• Group

Examples

// 通过系统通知处理加群申请
let promise = chat.handleGroupApplication({
  handleAction: 'Agree',
  handleMessage: '欢迎欢迎',
  message: message // 申请加群群系统通知的消息实例
});
promise.then(function(imResponse) {
  console.log(imResponse.data.group); // 群组资料
}).catch(function(imError){
  console.warn('handleGroupApplication error:', imError); // 错误信息
});

// 通过获取未决列表处理加群申请
let promise = chat.getGroupApplicationList();
promise.then(function(imResponse) {
  const { applicationList } = imResponse.data;
  applicationList.forEach((item) => {
    if (item.applicationType === 0) {
      chat.handleGroupApplication({
        handleAction: 'Agree',
        application: {...item},
      });
    }
  });
}).catch(function(imError) {
  console.warn('getGroupApplicationList error:', imError);
});