tencent cloud

PrevNext

Feedback

search by keyword

Recent Pages

Documentation
Chat
    Documentation
    Download PDF

    Android&iOS&Windows&Mac

    Last updated: 2023-07-17 15:55:33
    Download PDF

      Feature Description

      The IM SDK supports friend management, and users can add and delete friends and set to send messages only to friends.

      Get friend list

      The IM SDK supports the logic for the friend relationship. You can call the getFriendList API (Android / iOS and Mac / Windows) to get the contacts.
      Sample code:
      Android
      iOS and macOS
      Windows
      V2TIMManager.getFriendshipManager().getFriendList(new V2TIMValueCallback<List<V2TIMFriendInfo>>() {
        @Override
        public void onSuccess(List<V2TIMFriendInfo> v2TIMFriendInfos) {
          // The contacts obtained successfully
        }
      
        @Override
        public void onError(int code, String desc) {
          // Failed to obtain the contacts
        }
      });
      // Obtain the contacts
      [[V2TIMManager sharedInstance] getFriendList:^(NSArray<V2TIMFriendInfo *> *infoList) {
          // The contacts obtained successfully
      } fail:^(int code, NSString *desc) {
          // Failed to obtain the friend list
      }];
      template <class T>
      class ValueCallback final : public V2TIMValueCallback<T> {
      public:
          using SuccessCallback = std::function<void(const T&)>;
          using ErrorCallback = std::function<void(int, const V2TIMString&)>;
      
          ValueCallback() = default;
          ~ValueCallback() override = default;
      
          void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
              success_callback_ = std::move(success_callback);
              error_callback_ = std::move(error_callback);
          }
      
          void OnSuccess(const T& value) override {
              if (success_callback_) {
                  success_callback_(value);
              }
          }
          void OnError(int error_code, const V2TIMString& error_message) override {
              if (error_callback_) {
                  error_callback_(error_code, error_message);
              }
          }
      
      private:
          SuccessCallback success_callback_;
          ErrorCallback error_callback_;
      };
      
      auto callback = new ValueCallback<V2TIMFriendInfoVector>{};
      callback->SetCallback(
          [=](const V2TIMFriendInfoVector& friendInfoList) {
              // The contacts obtained successfully
              delete callback;
          },
          [=](int error_code, const V2TIMString& error_message) {
              // Failed to obtain the contacts
              delete callback;
          });
      
      V2TIMManager::GetInstance()->GetFriendshipManager()->GetFriendList(callback);

      Add friends

      Call the addFriend API (Android / iOS and Mac / Windows) to add a friend.
      Sample code:
      Android
      iOS and macOS
      Windows
      // Add a friend
      V2TIMFriendAddApplication application = new V2TIMFriendAddApplication("userA");
      application.setAddType(V2TIMFriendInfo.V2TIM_FRIEND_TYPE_BOTH);
      V2TIMManager.getFriendshipManager().addFriend(application, new V2TIMValueCallback<V2TIMFriendOperationResult>() {
        @Override
        public void onSuccess(V2TIMFriendOperationResult v2TIMFriendOperationResult) {
          // Added the friend successfully
        }
      
        @Override
        public void onError(int code, String desc) {
          // Failed to add the friend
        }
      });
      // Add a friend
      V2TIMFriendAddApplication *application = [[V2TIMFriendAddApplication alloc] init];
      application.userID = @"userA";
      application.addType = V2TIM_FRIEND_TYPE_BOTH;
      [[V2TIMManager sharedInstance] addFriend:application succ:^(V2TIMFriendOperationResult *result) {
          // Added the friend successfully
      } fail:^(int code, NSString *desc) {
          // Failed to add the friend
      }];
      template <class T>
      class ValueCallback final : public V2TIMValueCallback<T> {
      public:
          using SuccessCallback = std::function<void(const T&)>;
          using ErrorCallback = std::function<void(int, const V2TIMString&)>;
      
          ValueCallback() = default;
          ~ValueCallback() override = default;
      
          void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
              success_callback_ = std::move(success_callback);
              error_callback_ = std::move(error_callback);
          }
      
          void OnSuccess(const T& value) override {
              if (success_callback_) {
                  success_callback_(value);
              }
          }
          void OnError(int error_code, const V2TIMString& error_message) override {
              if (error_callback_) {
                  error_callback_(error_code, error_message);
              }
          }
      
      private:
          SuccessCallback success_callback_;
          ErrorCallback error_callback_;
      };
      
      V2TIMFriendAddApplication application;
      application.userID = u8"userA";
      application.addType = V2TIMFriendType::V2TIM_FRIEND_TYPE_BOTH;
      
      auto callback = new ValueCallback<V2TIMFriendOperationResult>{};
      callback->SetCallback(
          [=](const V2TIMFriendOperationResult& friendOperationResult) {
              // Added the friend successfully
              delete callback;
          },
          [=](int error_code, const V2TIMString& error_message) {
              // Failed to add the friend
              delete callback;
          });
      
      V2TIMManager::GetInstance()->GetFriendshipManager()->AddFriend(application, callback);
      The process has the following variations depending on whether friend verification is required.

      Friend request approval is not required

      1. Users A and B call setFriendListener to set the relationship chain listener.
      2. User B specifies that "friend request approval is not required (V2TIM_FRIEND_ALLOW_ANY)" through the allowType field (Android / iOS and macOS / Windows) in the setSelfInfo function.
      3. User A can add user B as a friend successfully by calling addFriend, after which the addType of the V2TIMFriendAddApplication request parameter can be set to either value as needed:
      If it is set to V2TIM_FRIEND_TYPE_BOTH (two-way friend), both users A and B will receive the onFriendListAdded callback (Android / iOS and macOS / Windows).
      If it is set to V2TIM_FRIEND_TYPE_SINGLE (one-way friend), only user A will receive the onFriendListAdded callback.

      Friend request approval is required

      1. Users A and B call setFriendListener to set the relationship chain listener.
      2. User B specifies that "friend request approval is required (V2TIM_FRIEND_NEED_CONFIRM)" through the allowType field in the setSelfInfo function.
      3. User A calls addFriend to send friend request to user B. The resultCode parameter in the callback for successful API call returns 30539, indicating that the request needs to be approved by user B. In addition, both users A and B will receive the onFriendApplicationListAdded callback (Android / iOS and macOS / Windows).
      4. User B will receive the onFriendApplicationListAdded callback. If type in the V2TIMFriendApplication parameter is V2TIM_FRIEND_APPLICATION_COME_IN, user B can accept or reject the request.
      User B calls acceptFriendApplication (Android / iOS and macOS / Windows) to accept the friend request. If the type is V2TIM_FRIEND_ACCEPT_AGREE (one-way friend):
      User A will receive the onFriendListAdded callback, indicating that the one-way friend was added successfully.
      User B will receive the onFriendApplicationListDeleted callback (Android / iOS and macOS / Windows). At this point, user B has become a friend of user A, but not vice versa.
      User B calls acceptFriendApplication to accept the friend request. If the type is V2TIM_FRIEND_ACCEPT_AGREE_AND_ADD (two-way friend), both users A and B will receive the onFriendListAdded callback, indicating that they added each other as a friend successfully.
      User B calls refuseFriendApplication (Android / iOS and macOS / Windows) to reject the friend request, and both users will receive the onFriendApplicationListDeleted callback.

      Delete friends

      Call the deleteFromFriendList API (Android / iOS and Mac / Windows) to delete a friend.
      Sample code:
      Android
      iOS and macOS
      Windows
      List<String> friendIDList = new ArrayList<>();
      friendIDList.add("userA");
      V2TIMManager.getFriendshipManager().deleteFromFriendList(friendIDList, V2TIMFriendInfo.V2TIM_FRIEND_TYPE_BOTH, new V2TIMValueCallback<List<V2TIMFriendOperationResult>>() {
        @Override
        public void onSuccess(List<V2TIMFriendOperationResult> v2TIMFriendOperationResults) {
          // The friend is deleted successfully
        }
      
        @Override
        public void onError(int code, String desc) {
          // Failed to delete the friend
        }
      });
      // Delete a friend
      [[V2TIMManager sharedInstance] deleteFromFriendList:@[@"userA"] deleteType:V2TIM_FRIEND_TYPE_BOTH succ:^(NSArray<V2TIMFriendOperationResult *> *resultList) {
          // The friend is deleted successfully
      } fail:^(int code, NSString *desc) {
          // Failed to delete the friend
      }];
      template <class T>
      class ValueCallback final : public V2TIMValueCallback<T> {
      public:
          using SuccessCallback = std::function<void(const T&)>;
          using ErrorCallback = std::function<void(int, const V2TIMString&)>;
      
          ValueCallback() = default;
          ~ValueCallback() override = default;
      
          void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
              success_callback_ = std::move(success_callback);
              error_callback_ = std::move(error_callback);
          }
      
          void OnSuccess(const T& value) override {
              if (success_callback_) {
                  success_callback_(value);
              }
          }
          void OnError(int error_code, const V2TIMString& error_message) override {
              if (error_callback_) {
                  error_callback_(error_code, error_message);
              }
          }
      
      private:
          SuccessCallback success_callback_;
          ErrorCallback error_callback_;
      };
      
      V2TIMStringVector userIDList;
      userIDList.PushBack(u8"userA");
      V2TIMFriendType deleteType = V2TIMFriendType::V2TIM_FRIEND_TYPE_BOTH;
      
      auto callback = new ValueCallback<V2TIMFriendOperationResultVector>{};
      callback->SetCallback(
          [=](const V2TIMFriendOperationResultVector& friendOperationResultList) {
              // The friend deleted successfully
              delete callback;
          },
          [=](int error_code, const V2TIMString& error_message) {
              // Failed to delete the friend
              delete callback;
          });
      
      V2TIMManager::GetInstance()->GetFriendshipManager()->DeleteFromFriendList(userIDList, deleteType, callback);

      Check friend relationships

      Call the checkFriend API (Android / iOS and Mac / Windows) to check the friend relationship.
      Sample code:
      Android
      iOS and macOS
      Windows
      V2TIMManager.getFriendshipManager().checkFriend(userIDList, V2TIMFriendInfo.V2TIM_FRIEND_TYPE_BOTH, new V2TIMValueCallback<List<V2TIMFriendCheckResult>>() {
        @Override
        public void onSuccess(List<V2TIMFriendCheckResult> v2TIMFriendCheckResults) {
          // Checked the friend relationship successfully
          for (V2TIMFriendCheckResult checkResult : v2TIMFriendCheckResults) {
            // User ID
            String userID = checkResult.getUserID();
            // Friend relationship between the two users
            int relationType = checkResult.getResultType();
          }
        }
      
        @Override
        public void onError(int code, String desc) {
          // Failed to check the friend relationship
        }
      });
      // Check the friend relationship between `user1` and the current user
      [[V2TIMManager sharedInstance] checkFriend:@[@"user1"] checkType:V2TIM_FRIEND_TYPE_BOTH succ:^(NSArray<V2TIMFriendCheckResult *> *resultList) {
          // Checked the friend relationship successfully
          for (V2TIMFriendCheckResult *result in resultList) {
              // User ID
              NSString *userID = result.userID;
              // Friend relationship between the two users
              V2TIMFriendRelationType relationType = result.relationType;
          }
      } fail:^(int code, NSString *desc) {
          // Failed to check the friend relationship
      }];
      template <class T>
      class ValueCallback final : public V2TIMValueCallback<T> {
      public:
          using SuccessCallback = std::function<void(const T&)>;
          using ErrorCallback = std::function<void(int, const V2TIMString&)>;
      
          ValueCallback() = default;
          ~ValueCallback() override = default;
      
          void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
              success_callback_ = std::move(success_callback);
              error_callback_ = std::move(error_callback);
          }
      
          void OnSuccess(const T& value) override {
              if (success_callback_) {
                  success_callback_(value);
              }
          }
          void OnError(int error_code, const V2TIMString& error_message) override {
              if (error_callback_) {
                  error_callback_(error_code, error_message);
              }
          }
      
      private:
          SuccessCallback success_callback_;
          ErrorCallback error_callback_;
      };
      
      V2TIMStringVector userIDList;
      userIDList.PushBack(u8"userA");
      V2TIMFriendType checkType = V2TIMFriendType::V2TIM_FRIEND_TYPE_BOTH;
      
      auto callback = new ValueCallback<V2TIMFriendCheckResultVector>{};
      callback->SetCallback(
          [=](const V2TIMFriendCheckResultVector& friendCheckResultList) {
              // Checked the friend relationship successfully
              for (size_t i = 0; i < friendCheckResultList.Size(); ++i) {
                  const V2TIMFriendCheckResult& friendCheckResult = friendCheckResultList[i];
                  // User ID
                  V2TIMString userID = friendCheckResult.userID;
                  // User ID
                  V2TIMFriendRelationType relationType = friendCheckResult.relationType;
              }
              delete callback;
          },
          [=](int error_code, const V2TIMString& error_message) {
              // Failed to check the friend relationship
              delete callback;
          });
      
      V2TIMManager::GetInstance()->GetFriendshipManager()->CheckFriend(userIDList, checkType, callback);

      Query and modify a friend's profile

      Call the getFriendsInfo API (Android / iOS and Mac / Windows) to query the profile of the specified friend.
      The relationship between the user and the friend can be obtained through the relation field of the V2TIMFriendInfoResult in the callback:
      V2TIMFriendInfoResult.relation
      Relationship
      V2TIM_FRIEND_RELATION_TYPE_NONE
      Non-friend user
      V2TIM_FRIEND_RELATION_TYPE_BOTH_WAY
      Two-way friend
      V2TIM_FRIEND_RELATION_TYPE_IN_MY_FRIEND_LIST
      User in your contacts
      V2TIM_FRIEND_RELATION_TYPE_IN_OTHER_FRIEND_LIST
      User who has you on their contacts
      Note
      When the profile of a friend is updated, the backend proactively sends a system notification to the SDK so that the friend's profile will be updated in real time.
      Sample code:
      Android
      iOS and macOS
      Windows
      List<String> userIDList = new ArrayList<>();
      userIDList.add("userA");
      V2TIMManager.getFriendshipManager().getFriendsInfo(userIDList, new V2TIMValueCallback<List<V2TIMFriendInfoResult>>() {
        @Override
        public void onSuccess(List<V2TIMFriendInfoResult> v2TIMFriendInfoResults) {
            // Obtained the profile of the friend successfully
        }
      
        @Override
        public void onError(int code, String desc) {
            // Failed to obtain the profile of the friend
        }
      });
      // Get the profile of a friend
      [[V2TIMManager sharedInstance] getFriendsInfo:@[@"userA"] succ:^(NSArray<V2TIMFriendInfoResult *> *resultList) {
          // Obtained the profile of the friend successfully
      } fail:^(int code, NSString *desc) {
          // Failed to obtain the profile of the friend
      }];
      template <class T>
      class ValueCallback final : public V2TIMValueCallback<T> {
      public:
          using SuccessCallback = std::function<void(const T&)>;
          using ErrorCallback = std::function<void(int, const V2TIMString&)>;
      
          ValueCallback() = default;
          ~ValueCallback() override = default;
      
          void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
              success_callback_ = std::move(success_callback);
              error_callback_ = std::move(error_callback);
          }
      
          void OnSuccess(const T& value) override {
              if (success_callback_) {
                  success_callback_(value);
              }
          }
          void OnError(int error_code, const V2TIMString& error_message) override {
              if (error_callback_) {
                  error_callback_(error_code, error_message);
              }
          }
      
      private:
          SuccessCallback success_callback_;
          ErrorCallback error_callback_;
      };
      
      V2TIMStringVector userIDList;
      userIDList.PushBack(u8"userA");
      
      auto callback = new ValueCallback<V2TIMFriendInfoResultVector>{};
      callback->SetCallback(
          [=](const V2TIMFriendInfoResultVector& friendInfoResultList) {
              // Obtained the profile of the friend successfully
              delete callback;
          },
          [=](int error_code, const V2TIMString& error_message) {
              // Obtained the profile of the friend successfully
              delete callback;
          });
      
      V2TIMManager::GetInstance()->GetFriendshipManager()->GetFriendsInfo(userIDList, callback);
      Call the setFriendInfo API (Android / iOS and macOS / Windows) to modify a friend's profile, including the friend remarks, custom friend field, and friend list. For more information, see the definition of the V2TIMFriendInfo class (Android / iOS and macOS / Windows).
      To modify a custom friend field, you must configure it in the IM console in advance as shown below:
      
      
      Caution
      You can set up to 20 custom friend fields, which cannot be deleted and whose name and type cannot be changed.
      Sample code:
      Android
      iOS and macOS
      Windows
      V2TIMFriendInfo friendInfo = new V2TIMFriendInfo();
      // `userA` is a friend.
      friendInfo.setUserID("userA");
      friendInfo.setFriendRemark("friendRemark");
      V2TIMManager.getFriendshipManager().setFriendInfo(friendInfo, new V2TIMCallback() {
        @Override
        public void onSuccess() {
            // Set the friend's profile successfully
        }
      
        @Override
        public void onError(int code, String desc) {
            // Failed to set the friend's profile
        }
      });
      // Set the friend's profile
      V2TIMFriendInfo *friendInfo = [[V2TIMFriendInfo alloc] init];
      friendInfo.userID = @"userA"; // `userA` is a friend.
      friendInfo.friendRemark = @"friendRemark";
      [[V2TIMManager sharedInstance] setFriendInfo:friendInfo succ:^{
          // Set the friend's profile successfully
      } fail:^(int code, NSString *desc) {
          // Failed to set the friend's profile
      }];
      class Callback final : public V2TIMCallback {
      public:
          using SuccessCallback = std::function<void()>;
          using ErrorCallback = std::function<void(int, const V2TIMString&)>;
      
          Callback() = default;
          ~Callback() override = default;
      
          void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
              success_callback_ = std::move(success_callback);
              error_callback_ = std::move(error_callback);
          }
      
          void OnSuccess() override {
              if (success_callback_) {
                  success_callback_();
              }
          }
          void OnError(int error_code, const V2TIMString& error_message) override {
              if (error_callback_) {
                  error_callback_(error_code, error_message);
              }
          }
      
      private:
          SuccessCallback success_callback_;
          ErrorCallback error_callback_;
      };
      
      V2TIMFriendInfo info;
      info.userID = u8"userA";
      info.friendRemark = u8"friendRemark";
      info.modifyFlag = V2TIMFriendInfoModifyFlag::V2TIM_FRIEND_INFO_MODIFY_FLAG_REMARK;
      
      auto callback = new Callback{};
      callback->SetCallback(
          [=]() {
              // Set the friend's profile successfully
              delete callback;
          },
          [=](int error_code, const V2TIMString& error_message) {
              // Failed to set the friend's profile
              delete callback;
          });
      
      V2TIMManager::GetInstance()->GetFriendshipManager()->SetFriendInfo(info, callback);

      Set to send messages to friends only

      In customer service scenarios where having to friend a customer service agent before chatting is inefficient, the IM SDK does not check the relationship when one-to-one messages are sent by default. If you want to implement the interaction mode of "friending before chatting" as in WeChat and QQ, go to the IM console and enable Check Relationship for One-to-One Messages. With this feature enabled, users can only send messages to friends and will receive the 20009 error code from SDK when sending a message to a non-friend user. For the configuration page path, see the figure below:
      
      
      
      Contact Us

      Contact our sales team or business advisors to help your business.

      Contact Us
      Technical Support

      Open a ticket if you're looking for further assistance. Our Ticket is 7x24 avaliable.

      Submit a Ticket
      7x24 Phone Support
      Copyright © 2013-2024 Tencent Cloud. All Rights Reserved.
      Privacy PolicyLegalCookie Policy