TencentIM(Instant messaging) C2C chat in Flutter

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

class IMHelper {
  static V2TIMManager v2TIMManager = V2TIMManager();
  static V2TimAdvancedMsgListener messageListener = V2TimAdvancedMsgListener();
  static V2TimGroupListener groupListener = V2TimGroupListener();
  static V2TimConversationListener conversationListener = V2TimConversationListener();
  static V2TimFriendshipListener friendshipListener = V2TimFriendshipListener();
  static V2TIMFriendshipManager friendshipManager = V2TIMFriendshipManager();
  static V2TIMConversationManager conversationManager = V2TIMConversationManager();

  static Future<void> initSDK() async {
    V2TimSDKListener sdkListener = V2TimSDKListener(
      onConnectFailed: (int code, String error) {
        // 连接失败的回调函数
        // code 错误码
        // error 错误信息
        print("code $code  error $error");
      },
      onConnectSuccess: () {
        // SDK 已经成功连接到腾讯云服务器
      },
      onConnecting: () {
        // SDK 正在连接到腾讯云服务器
      },
      onKickedOffline: () {
        // 当前用户被踢下线，此时可以 UI 提示用户，并再次调用 V2TIMManager 的 login() 函数重新登录。
      },
      onSelfInfoUpdated: (V2TimUserFullInfo info) {
        // 登录用户的资料发生了更新
        // info登录用户的资料
        print("info登录用户资料");
      },
      onUserSigExpired: () {
        // 在线时票据过期：此时您需要生成新的 userSig 并再次调用 V2TIMManager 的 login() 函数重新登录。
        // login(IMConfig.userid);
      },
      onUserStatusChanged: (List<V2TimUserStatus> userStatusList) {
        //用户状态变更通知
        //userStatusList 用户状态变化的用户列表
        //收到通知的情况：订阅过的用户发生了状态变更（包括在线状态和自定义状态），会触发该回调
        //在 IM 控制台打开了好友状态通知开关，即使未主动订阅，当好友状态发生变更时，也会触发该回调
        //同一个账号多设备登录，当其中一台设备修改了自定义状态，所有设备都会收到该回调
      },
    );

    V2TimValueCallback<bool> initSDKRes = await v2TIMManager.initSDK(
      sdkAppID: int.parse(IMConfig.sdkappid),
      loglevel: LogLevelEnum.V2TIM_LOG_ALL, // Log
      listener: sdkListener,
    );

    if (initSDKRes.code == 0) {
      //初始化成功
      // login(IMConfig.userid);
    }
  }

  ......
}  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

  static Future<void> login(MemberInfoModel? memberInfoModel) async {
    String key = IMConfig.key;
    String userId = memberInfoModel!.id.toString();
    UserSigGenerateUtils generateTestUserSig = UserSigGenerateUtils(sdkappid: int.parse(IMConfig.sdkappid), key: key);
    String userSig = generateTestUserSig.genSig(identifier: userId, expire: 99999);

    V2TimCallback res = await v2TIMManager.login(
      userID: userId,
      userSig: userSig,
    );

    if (res.code == 0) {
      // 登录成功逻辑
      IMHelper.getLoginUser(memberInfoModel);
      print("登录成功逻辑 ${res.desc}");
    } else {
      print("登录失败 ${res.code}");
    }
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

  static Future<void> getLoginUser(MemberInfoModel memberInfoModel) async {
    V2TimValueCallback<String> getLoginUserRes = await v2TIMManager.getLoginUser();
    if (getLoginUserRes.code == 0) {
      //获取成功
      V2TimUserFullInfo defaultUserInfo = V2TimUserFullInfo(
        nickName: memberInfoModel.userName,
        allowType: 0,
        role: 0,
        faceUrl: memberInfoModel.userPhoto,
        gender: 2,
        selfSignature: memberInfoModel.introduction,
      );
      v2TIMManager.setSelfInfo(userFullInfo: defaultUserInfo);
    }
  }

1
2
3
4
5
6
7
8

  List<V2TimConversation?>? _allConversations = [];
  List<V2TimConversation?>? get allConversations => _allConversations;

  Future<void> getAllConversations() async {
    _allConversations = [];
    _allConversations = await IMHelper.getConversationList();
    notifyListeners();
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

  static Future<V2TimValueCallback<V2TimConversationResult>> getConversations(String nextSeq) async {
    return await v2TIMManager.getConversationManager().getConversationList(
        count: 100, // Number of conversations to fetch per request
        nextSeq: nextSeq // Cursor for pagination
        );
  }

  static Future<List<V2TimConversation?>> getConversationList(
      {String nextSeq = "0", List<V2TimConversation?>? accumulatedList}) async {
    // Initialize the accumulated list if it's null
    accumulatedList ??= [];

    // Fetch conversations
    V2TimValueCallback<V2TimConversationResult> getConversationListRes = await getConversations(nextSeq);

    if (getConversationListRes.code == 0) {
      // If fetching is successful, accumulate the conversation list
      accumulatedList.addAll(getConversationListRes.data?.conversationList ?? []);

      // Check if the fetching is finished
      bool? isFinished = getConversationListRes.data?.isFinished;
      String? nextSeq = getConversationListRes.data?.nextSeq;

      // If not finished, recursively fetch the next set of conversations
      if (isFinished != true) {
        return getConversationList(nextSeq: nextSeq ?? "0", accumulatedList: accumulatedList);
      }
    }

    // Return the accumulated list of conversations
    return accumulatedList;
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

  static Future<bool> pinConversation(bool isPinned, String conversationID) async {
    V2TimCallback callback =
        await conversationManager.pinConversation(conversationID: conversationID, isPinned: isPinned);
    if (callback.code == 0) {
      ToastUtils.showSuccessToast("success");
      return true;
    } else {
      ToastUtils.showErrorToast("fail");
      return false;
    }
  }

1
2
3
4
5
6

  static Future<void> deleteConversation(String conversationID) async {
    V2TimCallback deleteConversationRes = await conversationManager.deleteConversation(conversationID: conversationID);
    if (deleteConversationRes.code == 0) {
      ToastUtils.showSuccessToast("delete success");
    }
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

  static Future<void> sendTextMessage(String message, Function(V2TimMessage) onMessageSent,
      {String? receiverId, String? groupId}) async {
    V2TimValueCallback<V2TimMsgCreateInfoResult> createTextMessageRes =
        await v2TIMManager.getMessageManager().createTextMessage(text: message);
    if (createTextMessageRes.code == 0) {
      // 文本信息创建成功
      String? id = createTextMessageRes.data?.id;
      // 发送文本消息
      // 在sendMessage时，若只填写receiver则发个人用户单聊消息
      //                 若只填写groupID则发群组消息
      //                 若填写了receiver与groupID则发群内的个人用户，消息在群聊中显示，只有指定receiver能看见
      V2TimValueCallback<V2TimMessage> sendMessageRes = await v2TIMManager.getMessageManager().sendMessage(
          id: id!,
          // 创建的messageid
          receiver: receiverId ?? "",
          // 接收人id
          groupID: groupId ?? "",
          // 接收群组id
          priority: MessagePriorityEnum.V2TIM_PRIORITY_DEFAULT,
          // 消息优先级
          onlineUserOnly: false,
          // 是否只有在线用户才能收到，如果设置为 true ，接收方历史消息拉取不到，常被用于实现“对方正在输入”或群组里的非重要提示等弱提示功能，该字段不支持 AVChatRoom。
          isExcludedFromUnreadCount: false,
          // 发送消息是否计入会话未读数
          isExcludedFromLastMessage: false,
          // 发送消息是否计入会话 lastMessage
          needReadReceipt: false,
          // 消息是否需要已读回执（只有 Group 消息有效，6.1 及以上版本支持，需要您购买旗舰版套餐）
          offlinePushInfo: OfflinePushInfo(),
          // 离线推送时携带的标题和内容
          cloudCustomData: "",
          // 消息云端数据，消息附带的额外的数据，存云端，消息的接收者可以访问到
          localCustomData: "" // 消息本地数据，消息附带的额外的数据，存本地，消息的接收者不可以访问到，App 卸载后数据丢失
          );
      print("sendMessageRes.code   ${sendMessageRes.code} ${sendMessageRes.desc}");
      if (sendMessageRes.code == 0) {
        onMessageSent(sendMessageRes.data!);
      }
    }
  }

1
2
3
4
5
6

  void sendMessage(String text) async {
    await IMHelper.sendTextMessage(text, receiverId: userId, (sentMessage) {
      Provider.of<MessageProvider>(context, listen: false).clearSearchSection();
      insertMessage(sentMessage);
    });
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

  Future<void> openAlbum() async {
    final pickedFile = await FileHelper.pickImageFromGalleryPath(_picker);
    if (pickedFile != null) {
      String path = pickedFile.path;
      if (FileHelper.isImage(path) == true) {
        await IMHelper.sendImageMessage(path, (sentMessage) {
          insertMessage(sentMessage);
        }, receiverId: userId);
      }
    }
  }



  Future<void> openCamera() async {
    String? path = await FileHelper.pickImageFromCameraPath(_picker);
    if (path != null) {
      await IMHelper.sendImageMessage(path, (sentMessage) {
        insertMessage(sentMessage);
      }, receiverId: userId);
    }
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

  static Future<void> sendImageMessage(String imagePath, Function(V2TimMessage) onMessageSent,
      {String? receiverId, String? groupId}) async {
    V2TimValueCallback<V2TimMsgCreateInfoResult> createImageMessageRes =
        await v2TIMManager.getMessageManager().createImageMessage(
              imagePath: imagePath,
            );
    if (createImageMessageRes.code == 0) {
      String? id = createImageMessageRes.data?.id;

      V2TimValueCallback<V2TimMessage> sendMessageRes = await v2TIMManager
          .getMessageManager()
          .sendMessage(id: id!, receiver: receiverId ?? "", groupID: groupId ?? "");
      if (sendMessageRes.code == 0) {
        onMessageSent(sendMessageRes.data!);
      }
    }
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

  final AudioRecorder _audioRecorder = AudioRecorder();
  late int _recordDuration = 0;
  Timer? _timer;
  //record voice
  void startTimer() {
    _timer?.cancel();
    _timer = Timer.periodic(const Duration(seconds: 1), (Timer t) {
      _recordDuration++;
    });
    notifyListeners();
  }

  // record voice sound ===========start==============
  Future<void> startRecord() async {
    _timer?.cancel();
    _recordDuration = 0;
    try {
      if (await _audioRecorder.hasPermission()) {
        const encoder = AudioEncoder.aacLc;
        if (!await AudioHelper.isEncoderSupported(encoder, _audioRecorder)) {
          return;
        }
        const config = RecordConfig(encoder: encoder, numChannels: 1);
        await AudioHelper.recordFile(_audioRecorder, config);
        _recordDuration = 0;
        startTimer();
      }
    } catch (e) {
      print("error $e");
    }
  }

  Future<void> cancelRecord() async {
    ToastUtils.showSuccessToast("cancel");
    await _audioRecorder.stop();
    _timer?.cancel();
    _recordDuration = 0;
    notifyListeners();
  }

  Future<void> stopRecord(Function(String path, int duration) sendVoiceMessage) async {
    final path = await _audioRecorder.stop();
    if (_recordDuration < 1) {
      ToastUtils.showErrorToast("too short");
      _timer?.cancel();
      _recordDuration = 0;
      return;
    }

    if (path != null) {
      sendVoiceMessage(path, _recordDuration);
    }
    _timer?.cancel();
    _recordDuration = 0;
  }
  // record voice sound ============end===============

1
2
3
4
5
6
7
8

  Future<void> sendVoiceMessage(String path, int duration) async {
    ToastUtils.showLoading();

    await IMHelper.sendVoiceMessage(path, (sentMessage) {
      insertMessage(sentMessage);
      ToastUtils.closeLoading();
    }, duration, receiverId: userId);
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

  static Future<void> sendVoiceMessage(String soundPath, Function(V2TimMessage) onMessageSent, int duration,
      {String? receiverId, String? groupId}) async {
    V2TimValueCallback<V2TimMsgCreateInfoResult> createSoundMessageRes =
        await v2TIMManager.getMessageManager().createSoundMessage(soundPath: soundPath, duration: duration);

    if (createSoundMessageRes.code == 0) {
      String? id = createSoundMessageRes.data?.id;

      V2TimValueCallback<V2TimMessage> sendMessageRes = await v2TIMManager
          .getMessageManager()
          .sendMessage(id: id!, receiver: receiverId ?? "", groupID: groupId ?? "");
      if (sendMessageRes.code == 0) {
        onMessageSent(sendMessageRes.data!);
      }
    }
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

  static Future<XFile?> pickImageFromGalleryPath(ImagePicker picker) async {
    // final pickedFile = await picker.pickImage(source: ImageSource.gallery);
    final pickedFile = await picker.pickMedia(
      maxWidth: 1920,
      maxHeight: 1080,
    );
    if (pickedFile != null) {
      return pickedFile;
    } else {
      return null;
    }
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

  Future<void> openAlbum() async {
    final pickedFile = await FileHelper.pickImageFromGalleryPath(_picker);
    if (pickedFile != null) {
      String path = pickedFile.path;
      if (FileHelper.isImage(path) == true) {
        // send image
      } else {
        String? thumbnailPath = await FileHelper.generateSnapshot(path); // get preview image
        double? duration = await FileHelper.getVideoDuration(path);
        String? mineType = await FileHelper.getVideoMimetype(path);
        int intDuration = (duration ?? 0).toInt();
        if (thumbnailPath != null) {
          await IMHelper.sendVideoMessage(path, mineType ?? "mov", intDuration, thumbnailPath, (sentMessage) {
            insertMessage(sentMessage);
          }, receiverId: userId);
        }
      }
    }
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

  // video message
  static Future<void> sendVideoMessage(
      String videoFilePath, String type, int duration, String snapshotPath, Function(V2TimMessage) onMessageSent,
      {String? receiverId, String? groupId}) async {
    V2TimValueCallback<V2TimMsgCreateInfoResult> createVideoMessageRes =
        await v2TIMManager.getMessageManager().createVideoMessage(
              videoFilePath: videoFilePath,
              type: type,
              duration: duration,
              snapshotPath: snapshotPath,
            );

    if (createVideoMessageRes.code == 0) {
      String? id = createVideoMessageRes.data?.id;

      V2TimValueCallback<V2TimMessage> sendMessageRes = await v2TIMManager
          .getMessageManager()
          .sendMessage(id: id!, receiver: receiverId ?? "", groupID: groupId ?? "");
      if (sendMessageRes.code == 0) {
        onMessageSent(sendMessageRes.data!);
      }
    }
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

  void setupMessageListener() async {
    await IMHelper.createMessageListener(
      ....
      onSendMessageProgress: (V2TimMessage message, int progress) {
        print("文件上传进度回调 $progress");

        String messageId = message.msgID!;
        String path = "";
        if (message.elemType == MessageElemType.V2TIM_ELEM_TYPE_VIDEO) {
          path = message.videoElem!.snapshotPath!;
        } else if (message.elemType == MessageElemType.V2TIM_ELEM_TYPE_SOUND) {
        } else if (message.elemType == MessageElemType.V2TIM_ELEM_TYPE_IMAGE) {
          path = message.imageElem!.path!;
        }
        if (path == "") return;
        if (progress == 100) {
          //  delete
          removeMessage(messageId);
          return;
        }
        V2TimCustomElem progressMessage = V2TimCustomElem(data: messageId, desc: path, extension: progress.toString());
        V2TimMessage newItem = V2TimMessage(
            msgID: messageId,
            sender: message.sender,
            elemType: MessageElemType.V2TIM_ELEM_TYPE_CUSTOM,
            customElem: progressMessage,
            timestamp: message.timestamp);

        insertMessage(newItem, isUpload: true);
      },
    );
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

  static Future<List<V2TimMessage>> processMessages(List<V2TimMessage> messages) async {
    if (messages.isEmpty) return messages;

    List<V2TimMessage> processedMessages = [];

    for (var i = 0; i < messages.length; i++) {
      var orgMessage = messages[i];
      var message = orgMessage;
      message = await handleDownloadNetworkMessage(message);

      processedMessages.add(message);
      bool isLastMessageInMinuteBlock =
          (i + 1 == messages.length) || !DateHelper.isSameMinute(message.timestamp!, messages[i + 1].timestamp!);

      if (isLastMessageInMinuteBlock) {
        String formatTime = DateHelper.formatTime(message.timestamp!);
        var timeMessage = V2TimMessage(
          msgID: 'time_${message.msgID}',
          timestamp: message.timestamp,
          sender: null,
          customElem: V2TimCustomElem(data: "time", desc: formatTime),
          elemType: MessageElemType.V2TIM_ELEM_TYPE_CUSTOM,
        );
        // Check if the last added message is a duplicate time message
        if (processedMessages.isNotEmpty &&
            processedMessages.last.customElem?.desc == timeMessage.customElem?.desc &&
            processedMessages.last.elemType == MessageElemType.V2TIM_ELEM_TYPE_CUSTOM) {
          processedMessages.removeLast();
        }
        processedMessages.add(timeMessage);
      }

    }
 
    return processedMessages;
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

  static bool isSameMinute(int a, int b) {
    DateTime dateTimeA = DateTime.fromMillisecondsSinceEpoch(a * 1000);
    DateTime dateTimeB = DateTime.fromMillisecondsSinceEpoch(b * 1000);

    return dateTimeA.year == dateTimeB.year &&
        dateTimeA.month == dateTimeB.month &&
        dateTimeA.day == dateTimeB.day &&
        dateTimeA.hour == dateTimeB.hour &&
        dateTimeA.minute == dateTimeB.minute;
  }