Docs Overview/
Chat/
SDK/
Android/
User/
Manage Friends/

Manage Friends

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.