tencent cloud

Feedback

Android&iOS&Windows&Mac

Last updated: 2024-08-20 17:00:38

    Feature Description

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

    Getting the Friend List

    The Chat 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);

    Adding 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 contacts 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 contacts 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.

    Deleting 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 Console in advance, the path is: Applications > Your App > Chat > Configuration > Custom User Field.
    Note:
    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);

    Setting to Send Messages to Friends Only

    In customer service scenarios where having to friend a customer service agent before chatting is inefficient, the SDK does not check the relationship when one-to-one messages are sent by default. If you want to implement the interaction mode of "adding friend then chatting", go to the Console and enable Relationship Check. 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. The path is: Applications > Your App > Chat > Configuration > Login and Message > Relationship Check.
    
    Contact Us

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

    Technical Support

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

    7x24 Phone Support