Javavoid addFriendListener(V2NIMFriendListener listener);

Objective-C- (void)addFriendListener:(id<V2NIMFriendListener>)listener;

C++virtual void addFriendListener(V2NIMFriendListener listener) = 0;

JavaNIMClient.getService(V2NIMFriendService.class).addFriendListener(new V2NIMFriendListener() {
    @Override
    public void onFriendAdded(V2NIMFriend friendInfo) {

    }

    @Override
    public void onFriendDeleted(String accountId, V2NIMFriendDeletionType deletionType) {

    }

    @Override
    public void onFriendAddApplication(V2NIMFriendAddApplication applicationInfo) {

    }

    @Override
    public void onFriendAddRejected(V2NIMFriendAddApplication rejectionInfo) {

    }

    @Override
    public void onFriendInfoChanged(V2NIMFriend friendInfo) {

    }
});

Objective-C[[[NIMSDK sharedSDK] v2FriendService] addFriendListener:self];
- (void)onFriendAdded:(V2NIMFriend *)friendInfo{};
- (void)onFriendDeleted:(NSString *)accountId deletionType:(V2NIMFriendDeletionType)deletionType{}};
- (void)onFriendAddApplication:(V2NIMFriendAddApplication *)application{}};
- (void)onFriendAddRejected:(V2NIMFriendAddApplication *)rejectionInfo{}};
- (void)onFriendInfoChanged:(V2NIMFriend *)friendInfo{}};

C++V2NIMFriendListener listener;
listener.onSyncStarted = []() {
    // sync friend started
};
listener.onSyncFinished = []() {
    // sync friend finished
};
listener.onSyncFailed = [](V2NIMError error) {
    // sync friend failed, handle error
};
listener.onFriendAdded = [](V2NIMFriend friendInfo) {
    // friend added, handle friendInfo
};
listener.onFriendDeleted = [](nstd::string accountId, V2NIMFriendDeletionType deletionType) {
    // friend deleted
};
listener.onFriendAddApplication = [](V2NIMFriendAddApplication applicationInfo) {
    // friend add application, handle applicationInfo
};
listener.onFriendAddRejected = [](V2NIMFriendAddApplication rejectionInfo) {
    // friend add rejected, handle rejectionInfo
};
listener.onFriendInfoChanged = [](V2NIMFriend friendInfo) {
    // friend info changed, handle friendInfo
};
friendService.addFriendListener(listener);

Javavoid removeFriendListener(V2NIMFriendListener listener);

Objective-C- (void)removeFriendListener:(id<V2NIMFriendListener>)listener;

C++virtual void removeFriendListener(V2NIMFriendListener listener) = 0;

JavaNIMClient.getService(V2NIMFriendService.class).removeFriendListener(listener);

Objective-C[[[NIMSDK sharedSDK] v2FriendService] removeFriendListener:self];

C++V2NIMFriendListener listener;
// ...
friendService.addFriendListener(listener);
// ...
friendService.removeFriendListener(listener);

TypeScriptexport interface NIMEBaseServiceInterface<I extends NIMEBaseListener> {
  /**
   * 继承自 eventEmitter3 的监听事件方法
   */
  on<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;
  /**
   * 继承自 eventEmitter3 的监听事件方法
   */
  once<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;
}

TypeScriptexport interface NIMEBaseServiceInterface<I extends NIMEBaseListener> {
  /**
   * 继承自 eventEmitter3 的监听事件方法
   */
  on<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;
  /**
   * 继承自 eventEmitter3 的监听事件方法
   */
  once<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;
}

TypeScriptexport interface NIMEBaseServiceInterface<I extends NIMEBaseListener> {
  /**
   * 继承自 eventEmitter3 的监听事件方法
   */
  on<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void
  /**
   * 继承自 eventEmitter3 的监听事件方法
   */
  once<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void
}

TypeScriptnim.V2NIMFriendService.on("onFriendAdded", function (friend: V2NIMFriend) {})
nim.V2NIMFriendService.on("onFriendDeleted", function (accountId: string, deletionType: V2NIMFriendDeletionType) {})
nim.V2NIMFriendService.on("onFriendAddApplication", function (application: V2NIMFriendAddApplication) {})
nim.V2NIMFriendService.on("onFriendAddRejected", function (rejection: V2NIMFriendAddApplication) {})
nim.V2NIMFriendService.on("onFriendInfoChanged", function (friend: V2NIMFriend) {})

TypeScriptv2.friendService.on("friendAdded", function (friend: V2NIMFriend) {})
v2.friendService.on("friendDeleted", function (accountId: string, deletionType: V2NIMFriendDeletionType) {})
v2.friendService.on("friendAddApplication", function (application: V2NIMFriendAddApplication) {})
v2.friendService.on("friendAddRejected", function (rejection: V2NIMFriendAddApplication) {})
v2.friendService.on("friendInfoChanged", function (friend: V2NIMFriend) {})

TypeScriptnim.friendService.on("onFriendAdded", function (friend: V2NIMFriend) {})
nim.friendService.on("onFriendDeleted", function (accountId: string, deletionType: V2NIMFriendDeletionType) {})
nim.friendService.on("onFriendAddApplication", function (application: V2NIMFriendAddApplication) {})
nim.friendService.on("onFriendAddRejected", function (rejection: V2NIMFriendAddApplication) {})
nim.friendService.on("onFriendInfoChanged", function (friend: V2NIMFriend) {})

TypeScriptexport interface NIMEBaseServiceInterface<I extends NIMEBaseListener> {
  /**
   * 继承自 eventEmitter3 的取消监听方法
   */
  off<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;

  /**
   * 继承自 eventEmitter3 的移除事件方法
   */
  removeAllListeners<T extends keyof I>(eventName?: T): void;
}

TypeScriptexport interface NIMEBaseServiceInterface<I extends NIMEBaseListener> {
  /**
   * 继承自 eventEmitter3 的取消监听方法
   */
  off<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;

  /**
   * 继承自 eventEmitter3 的移除事件方法
   */
  removeAllListeners<T extends keyof I>(eventName?: T): void;
}

TypeScriptexport interface NIMEBaseServiceInterface<I extends NIMEBaseListener> {
  /**
   * 继承自 eventEmitter3 的取消监听方法
   */
  off<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void
  /**
   * 继承自 eventEmitter3 的移除事件方法
   */
  removeAllListeners<T extends keyof I>(eventName?: T): void
}

TypeScriptnim.V2NIMFriendService.off("onFriendAdded", function (friend: V2NIMFriend) {})
nim.V2NIMFriendService.off("onFriendDeleted", function (accountId: string, deletionType: V2NIMFriendDeletionType) {})
nim.V2NIMFriendService.off("onFriendAddApplication", function (application: V2NIMFriendAddApplication) {})
nim.V2NIMFriendService.off("onFriendAddRejected", function (rejection: V2NIMFriendAddApplication) {})
nim.V2NIMFriendService.off("onFriendInfoChanged", function (friend: V2NIMFriend) {})

TypeScriptv2.friendService.off("friendAdded", function (friend: V2NIMFriend) {})
v2.friendService.off("friendDeleted", function (accountId: string, deletionType: V2NIMFriendDeletionType) {})
v2.friendService.off("friendAddApplication", function (application: V2NIMFriendAddApplication) {})
v2.friendService.off("friendAddRejected", function (rejection: V2NIMFriendAddApplication) {})
v2.friendService.off("friendInfoChanged", function (friend: V2NIMFriend) {})

TypeScriptnim.friendService.off("onFriendAdded", function (friend: V2NIMFriend) {})
nim.friendService.off("onFriendDeleted", function (accountId: string, deletionType: V2NIMFriendDeletionType) {})
nim.friendService.off("onFriendAddApplication", function (application: V2NIMFriendAddApplication) {})
nim.friendService.off("onFriendAddRejected", function (rejection: V2NIMFriendAddApplication) {})
nim.friendService.off("onFriendInfoChanged", function (friend: V2NIMFriend) {})

Javavoid addFriend(String accountId, V2NIMFriendAddParams params, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)addFriend:(NSString *)accountId
           params:(V2NIMFriendAddParams *)params
          success:(nullable V2NIMSuccessCallback)success
          failure:(nullable V2NIMFailureCallback)failure;

C++virtual void addFriend(nstd::string accountId, V2NIMFriendAddParams params, V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

TypeScriptaddFriend(accountId: string, params: V2NIMFriendAddParams): Promise<void>

TypeScriptaddFriend(accountId, params): Promise<void>

TypeScriptaddFriend(accountId: string, params: V2NIMFriendAddParams): Promise<void>

JavaV2NIMFriendAddParams addParams = V2NIMFriendAddParams.V2NIMFriendAddParamsBuilder.builder(addMode)
        .withPostscript("xxx")
        .build();
NIMClient.getService(V2NIMFriendService.class).addFriend("accoundId", addParams,
        new V2NIMSuccessCallback<Void>() {
            @Override
            public void onSuccess(Void unused) {
                // addMode == V2NIM_FRIEND_MODE_TYPE_ADD "添加好友成功"
                // addMode == V2NIM_FRIEND_MODE_TYPE_APPLY "添加好友请求发送成功"
            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {

            }
        });

Objective-CV2NIMFriendAddParams *addParams = [V2NIMFriendAddParams new];
addParams.addMode = V2NIM_FRIEND_MODE_TYPE_ADD;
addParams.postscript = @"您好。我是 XXX";
[[[NIMSDK sharedSDK] v2FriendService] addFriend:@"accountId" params:addParams success:^{

} failure:^(V2NIMError * _Nonnull error) {

}];

C++V2NIMFriendAddParams params;
params.addMode = V2NIM_FRIEND_MODE_TYPE_ADD;
params.postscript = "hello";
friendService.addFriend(
    "account",
    params,
    []() {
        // add friend success
    },
    [](V2NIMError error) {
        // add friend failed, handle error
    }
);

TypeScriptnim.V2NIMFriendService.addFriend('accountId', {
    addMode: 2,
    postscript: '您好，我是 xxx'
});

TypeScriptawait v2.friendService.addFriend('accountId', {
    addMode: 1
})

TypeScriptnim.friendService.addFriend('accountId', {
    addMode: 2,
    postscript: '您好，我是 xxx'
})

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。添加好友成功，返回 onFriendAdded 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

添加好友成功，返回 onFriendAdded 回调。

添加好友成功，返回 friendAdded 回调。

Javavoid deleteFriend(String accountId, V2NIMFriendDeleteParams params, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)deleteFriend:(NSString *)accountId
              params:(V2NIMFriendDeleteParams *)params
             success:(nullable V2NIMSuccessCallback)success
             failure:(nullable V2NIMFailureCallback)failure;

C++virtual void deleteFriend(nstd::string accountId,
                          V2NIMFriendDeleteParams params,
                          V2NIMSuccessCallback<void> success,
                          V2NIMFailureCallback failure) = 0;

TypeScriptdeleteFriend(accountId: string, params: V2NIMFriendDeleteParams): Promise<void>

TypeScriptdeleteFriend(accountId, params): Promise<void>

TypeScriptdeleteFriend(accountId: string, params: V2NIMFriendDeleteParams): Promise<void>

JavaV2NIMFriendDeleteParams deleteParams = V2NIMFriendDeleteParams.V2NIMFriendDeleteParamsBuilder.builder()
        .withDeleteAlias(deleteAlias)
        .build();
NIMClient.getService(V2NIMFriendService.class).deleteFriend("accoundId", deleteParams,
        new V2NIMSuccessCallback<Void>() {
            @Override
            public void onSuccess(Void unused) {

            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {

            }
        });

Objective-CV2NIMFriendDeleteParams *deleteParams = [V2NIMFriendDeleteParams new];
deleteParams.deleteAlias = YES;
[[[NIMSDK sharedSDK] v2FriendService] deleteFriend:@"accountId" params:deleteParams success:^{

} failure:^(V2NIMError * _Nonnull error) {

}];

C++V2NIMFriendDeleteParams params;
params.deleteAlias = true;
friendService.deleteFriend(
    "account",
    params,
    []() {
        // delete friend success
    },
    [](V2NIMError error) {
        // delete friend failed, handle error
    }
);

TypeScriptnim.V2NIMFriendService.deleteFriend('accountId', {
    deleteAlias: true
});

TypeScriptawait v2.friendService.deleteFriend('accountId', {
    deleteAlias: true
})

TypeScriptnim.friendService.deleteFriend('accountId', {
    deleteAlias: true
})

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。删除成功，返回 onFriendDeleted 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

更新成功，返回 onFriendDeleted 回调。

更新成功，返回 friendDeleted 回调。

Javavoid acceptAddApplication(V2NIMFriendAddApplication application, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)acceptAddApplication:(V2NIMFriendAddApplication *)application
                     success:(nullable V2NIMSuccessCallback)success
                     failure:(nullable V2NIMFailureCallback)failure;

C++virtual void acceptAddApplication(V2NIMFriendAddApplication application, V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

TypeScriptacceptAddApplication(application: V2NIMFriendAddApplication): Promise<void>

TypeScriptacceptAddApplication(application): Promise<void>

TypeScriptacceptAddApplication(application: V2NIMFriendAddApplication): Promise<void>

Java// V2NIMFriendAddApplication application 无法构造，从查询接口获得
NIMClient.getService(V2NIMFriendService.class).acceptAddApplication(application,
        new V2NIMSuccessCallback<Void>() {
            @Override
            public void onSuccess(Void unused) {

            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {

            }
        });

Objective-C[[[NIMSDK sharedSDK] v2FriendService] acceptAddApplication:application success:^{

} failure:^(V2NIMError * _Nonnull error) {

}];

C++V2NIMFriendAddApplication application;
// get application from listener or query
// ...
friendService.acceptAddApplication(
    application,
    []() {
        // accept friend request success
    },
    [](V2NIMError error) {
        // accept friend request failed, handle error
    }
);

TypeScriptnim.V2NIMFriendService.acceptAddApplication(application);

TypeScriptawait v2.friendService.acceptAddApplication(application)

TypeScriptnim.friendService.acceptAddApplication(application)

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。接受好友申请成功，返回 onFriendAdded 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

接受好友申请成功，返回 onFriendAdded 回调。

接受好友申请成功，返回 friendAdded 回调。

Javavoid rejectAddApplication(V2NIMFriendAddApplication application, String postscript, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)rejectAddApplication:(V2NIMFriendAddApplication *)application
                  postscript:(NSString *)postscript
                     success:(nullable V2NIMSuccessCallback)success
                     failure:(nullable V2NIMFailureCallback)failure;

C++virtual void rejectAddApplication(V2NIMFriendAddApplication application,
                                 std::string postscript,
                                 V2NIMSuccessCallback<void> success,
                                 V2NIMFailureCallback failure) = 0;

TypeScriptrejectAddApplication(application: V2NIMFriendAddApplication, postscript?: string): Promise<void>

TypeScriptrejectAddApplication(application, postscript): Promise<void>

TypeScriptrejectAddApplication(application: V2NIMFriendAddApplication, postscript?: string): Promise<void>

Java// V2NIMFriendAddApplication application 无法构造，从查询接口获得
NIMClient.getService(V2NIMFriendService.class).rejectAddApplication(application,
        new V2NIMSuccessCallback<Void>() {
            @Override
            public void onSuccess(Void unused) {

            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {

            }
        });

Objective-C[[[NIMSDK sharedSDK] v2FriendService] rejectAddApplication:application postscript:@"XXX" success:^{

    } failure:^(V2NIMError * _Nonnull error) {

}];

C++V2NIMFriendAddApplication application;
// get application from listener or query
// ...
friendService.rejectAddApplication(
    application,
    "postscript",
    []() {
        // reject friend request success
    },
    [](V2NIMError error) {
        // reject friend request failed, handle error
    }
);

TypeScriptnim.V2FriendService.rejectAddApplication(application, 'ps');

TypeScriptawait v2.friendService.rejectAddApplication(application, 'reason')

TypeScriptnim.friendService.rejectAddApplication(application, 'ps')

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。拒绝好友申请成功，返回 onFriendAddRejected 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

拒绝好友申请成功，返回 onFriendAddRejected 回调。

拒绝好友申请成功，返回 friendAddRejected 回调。

Javavoid setFriendInfo(String accountId, V2NIMFriendSetParams params, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)setFriendInfo:(NSString *)accountId
               params:(V2NIMFriendSetParams *)params
              success:(nullable V2NIMSuccessCallback)success
              failure:(nullable V2NIMFailureCallback)failure;

C++virtual void setFriendInfo(std::string accountId,
                           V2NIMFriendSetParams params,
                           V2NIMSuccessCallback<void> success,
                           V2NIMFailureCallback failure) = 0;

TypeScriptsetFriendInfo(accountId: string, params: V2NIMFriendSetParams): Promise<void>

TypeScriptsetFriendInfo(accountId, params): Promise<void>

TypeScriptsetFriendInfo(accountId: string, params: V2NIMFriendSetParams): Promise<void>

JavaV2NIMFriendSetParams setParams = V2NIMFriendSetParams.V2NIMFriendSetParamsBuilder.builder()
        .withAlias(alias)
        .withServerExtension(serverExtension)
        .build();
NIMClient.getService(V2NIMFriendService.class).setFriendInfo("accountId", setParams,
        new V2NIMSuccessCallback<Void>() {
            @Override
            public void onSuccess(Void unused) {

            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {

            }
        });

Objective-CV2NIMFriendSetParams *setParams = [V2NIMFriendSetParams new];
setParams.alias = @"XXX";
setParams.serverExtension = @"XXX";
[[[NIMSDK sharedSDK] v2FriendService] setFriendInfo:@"accountId" params:setParams success:^{

} failure:^(V2NIMError * _Nonnull error) {

}];

C++V2NIMFriendSetParams params;
params.alias = "alias";
friendService.setFriendInfo(
    "account",
    params,
    []() {
        // set friend info success
    },
    [](V2NIMError error) {
        // set friend info failed, handle error
    });

TypeScriptnim.V2NIMFriendService.setFriendInfo('accountId', {
    alias: 'alias',
    serverExtension: 'serverExtension'
});

TypeScriptawait v2.friendService.setFriendInfo('accountId', {
    alias: 'alias'
})

TypeScriptnim.friendService.setFriendInfo('accountId', {
    alias: 'alias',
    serverExtension: 'serverExtension'
})

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。设置好友信息成功后，返回 onFriendInfoChanged 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

设置好友信息成功后，返回 onFriendInfoChanged 回调。

设置好友信息成功后，返回 friendInfoChanged 回调。

Javavoid getFriendList(V2NIMSuccessCallback<List<V2NIMFriend>> success, V2NIMFailureCallback failure);

Objective-C- (void)getFriendList:(nullable V2NIMGetFirendListSuccess)success
              failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getFriendList(V2NIMSuccessCallback<nstd::vector<V2NIMFriend>> success, V2NIMFailureCallback failure) = 0;

TypeScriptgetFriendList(): Promise<V2NIMFriend[]>

TypeScriptgetFriendList(): Promise<V2NIMFriend[]>

TypeScriptgetFriendList(): Promise<V2NIMFriend[]>

JavaNIMClient.getService(V2NIMFriendService.class).getFriendList(
        new V2NIMSuccessCallback<List<V2NIMFriend>>() {
            @Override
            public void onSuccess(List<V2NIMFriend> v2NIMFriends) {

            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {

            }
        });

Objective-C[[[NIMSDK sharedSDK] v2FriendService] getFriendList:^(NSArray<V2NIMFriend *> * _Nonnull result) {

} failure:^(V2NIMError * _Nonnull error) {

}];

C++friendService.getFriendList(
    [](std::vector<V2NIMFriend> friends) {
        // get friend list success, handle friends
    },
    [](V2NIMError error) {
        // get friend list failed, handle error
    }
);

TypeScriptconst friends = nim.V2NIMFriendService.getFriendList();

TypeScriptconst friends = await v2.friendService.getFriendList()

TypeScriptconst friends = nim.friendService.getFriendList()

无返回值。

Promise<V2NIMFriend[]>：好友信息列表

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMFriend 列表。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

• 请求成功，，返回 V2NIMGetFirendListSuccess 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

无。

Javavoid getFriendByIds(List<String> accountIds, V2NIMSuccessCallback<List<V2NIMFriend>> success, V2NIMFailureCallback failure);

Objective-C- (void)getFriendByIds:(NSArray <NSString *> *)accountIds
               success:(nullable V2NIMGetFirendListSuccess)success
               failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getFriendByIds(std::vector<std::string> accountIds,
    V2NIMSuccessCallback<std::vector<V2NIMFriend>> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptgetFriendByIds(accountIds: string[]): Promise<V2NIMFriend[]>

TypeScriptgetFriendByIds(accountIds): Promise<V2NIMFriend[]>

TypeScriptgetFriendByIds(accountIds: string[]): Promise<V2NIMFriend[]>

JavaNIMClient.getService(V2NIMFriendService.class).getFriendByIds(accountIds,
        new V2NIMSuccessCallback<List<V2NIMFriend>>() {
            @Override
            public void onSuccess(List<V2NIMFriend> v2NIMFriends) {

            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {

            }
        });

Objective-C[[[NIMSDK sharedSDK] v2FriendService] getFriendByIds:@[@"accountId1",@"accountId2"] success:^(NSArray<V2NIMFriend *> * _Nonnull result) {

    } failure:^(V2NIMError * _Nonnull error) {

    }];

C++friendService.getFriendByIds(
    {"account1", "account2"},
    [](std::vector<V2NIMFriend> friends) {
        // get friend list success, handle friends
    },
    [](V2NIMError error) {
        // get friend list failed, handle error
    });

TypeScriptconst friends = await nim.V2NIMFriendService.getFriendByIds(['accountId1', 'accountId2']);

TypeScriptconst friends = await v2.friendService.getFriendByIds(['accountId1', 'accountId2'])

TypeScriptconst friends = await nim.friendService.getFriendByIds(['accountId1', 'accountId2'])

无返回值。

Promise<V2NIMFriend[]>：好友信息列表

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMFriend 列表。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

• 请求成功，，返回 V2NIMGetFirendListSuccess 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

无。

Javavoid checkFriend(List<String> accountIds, V2NIMSuccessCallback<Map<String, Boolean>> success, V2NIMFailureCallback failure);

Objective-C- (void)checkFriend:(NSArray <NSString *> *)accountIds
            success:(nullable V2NIMCheckFriendSuccess)success
            failure:(nullable V2NIMFailureCallback)failure;

C++virtual void checkFriend(std::vector<std::string> accountIds,
        V2NIMSuccessCallback<std::map<std::string, bool>> success,
        V2NIMFailureCallback failure) = 0;

TypeScriptcheckFriend(accountIds: string[]): Promise<V2NIMCheckFriendResult>

TypeScriptcheckFriend(accountIds): Promise<Map<string, boolean>>

TypeScriptcheckFriend(accountIds: string[]): Promise<V2NIMCheckFriendResult>

JavaNIMClient.getService(V2NIMFriendService.class).checkFriend(accountIds, new V2NIMSuccessCallback<Map<String, Boolean>>() {
    @Override
    public void onSuccess(Map<String, Boolean> stringBooleanMap) {

    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {

    }
});

Objective-C[[[NIMSDK sharedSDK] v2FriendService] checkFriend:@[@"accountId1",@"accountId2"] success:^(NSDictionary<NSString *,NSNumber *> * _Nonnull result) {

    } failure:^(V2NIMError * _Nonnull error) {

}];

C++friendService.checkFriend(
    {"account1", "account2"},
    [](nstd::map<nstd::string, bool> checkList) {
        // check friend success, handle checkList
    },
    [](V2NIMError error) {
        // check friend failed, handle error
    });

TypeScriptconst res = await nim.V2NIMFriendService.checkFriend(['accountId1', 'accountId2']);

TypeScriptconst res = await v2.friendService.checkFriend(['accountId1', 'accountId2'])

TypeScriptconst res = await nim.friendService.checkFriend(['accountId1', 'accountId2'])

无返回值。

Promise<V2NIMCheckFriendResult>：好友状态查询结果

• 请求成功，返回 V2NIMSuccessCallback 回调，包含每个好友账号 ID 的状态值。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

• 请求成功，，返回 V2NIMCheckFriendSuccess 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

无。

Javavoid getAddApplicationList(V2NIMFriendAddApplicationQueryOption option, V2NIMSuccessCallback<V2NIMFriendAddApplicationResult> success, V2NIMFailureCallback failure);

Objective-C- (void)getAddApplicationList:(V2NIMFriendAddApplicationQueryOption *)option
                      success:(nullable V2NIMGetApplicationListSuccess)success
                      failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getAddApplicationList(V2NIMFriendAddApplicationQueryOption option,
                                   V2NIMSuccessCallback<V2NIMFriendAddApplicationResult> success,
                                   V2NIMFailureCallback failure) = 0;

TypeScriptgetAddApplicationList(option: V2NIMFriendAddApplicationQueryOption): Promise<V2NIMFriendAddApplicationResult>

TypeScriptgetAddApplicationList(option): Promise<V2NIMFriendAddApplicationResult>

TypeScriptgetAddApplicationList(option: V2NIMFriendAddApplicationQueryOption): Promise<V2NIMFriendAddApplicationResult>

JavaV2NIMFriendAddApplicationQueryOption option = V2NIMFriendAddApplicationQueryOption.V2NIMFriendAddApplicationQueryOptionBuilder.builder()
        .withLimit(limit)
        .withOffset(offset)
        .withStatus(statuses)
        .build();
NIMClient.getService(V2NIMFriendService.class).getAddApplicationList(option,
        new V2NIMSuccessCallback<V2NIMFriendAddApplicationResult>() {
            @Override
            public void onSuccess(V2NIMFriendAddApplicationResult v2NIMFriendAddApplicationResult) {

            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {

            }
        }
);

Objective-CV2NIMFriendAddApplicationQueryOption *queryOption = [V2NIMFriendAddApplicationQueryOption new];
queryOption.offset = 0;
queryOption.limit = 50;
[[[NIMSDK sharedSDK] v2FriendService] getAddApplicationList:queryOption success:^(V2NIMFriendAddApplicationResult * _Nonnull result) {

} failure:^(V2NIMError * _Nonnull error) {

}];

C++V2NIMFriendAddApplicationQueryOption option;
option.offset = 0;
option.limit = 10;
friendService.getAddApplicationList(
    option,
    [](V2NIMFriendAddApplicationResult result) {
        // 查询添加申请列表成功，处理结果
    },
    [](V2NIMError error) {
        // 查询添加申请列表失败，处理错误
    });

TypeScriptconst applicationList = await nim.V2NIMFriendService.getAddApplicationList({
    offset: 0,
    limit: 50
});

TypeScriptconst applicationList = await v2.friendService.getAddApplicationList({
    offset: 0,
    limit: 50
});

TypeScriptconst applicationList = await nim.friendService.getAddApplicationList({
    offset: 0,
    limit: 50
})

无返回值。

Promise<V2NIMFriendAddApplicationResult>：申请添加好友信息查询结果。

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMFriendAddApplicationResult。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

• 请求成功，，返回 V2NIMGetApplicationListSuccess 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

无。

Javavoid getAddApplicationUnreadCount(V2NIMSuccessCallback<Integer> success, V2NIMFailureCallback failure);

Objective-C- (void)getAddApplicationUnreadCount:(nullable V2NIMGetApplicationUnreadCountSuccess)success
                             failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getAddApplicationUnreadCount(V2NIMSuccessCallback<uint32_t> success, V2NIMFailureCallback failure) = 0;

TypeScriptgetAddApplicationUnreadCount(): Promise<number>

无参数。

TypeScriptgetAddApplicationUnreadCount(): Promise<number>

无参数。

TypeScriptgetAddApplicationUnreadCount(): Promise<number>

无参数。

JavaNIMClient.getService(V2NIMFriendService.class).getAddApplicationUnreadCount(
new V2NIMSuccessCallback<Integer>() {
    @Override
    public void onSuccess(Integer count) {
        // 查询结果为 count
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        // 查询失败
    }
});

Objective-C[[[NIMSDK sharedSDK] v2FriendService] getAddApplicationUnreadCount:^(NSInteger count) {
    // 获取未读数，成功回调
} failure:^(V2NIMError * _Nonnull error) {
    // 取未读数，失败回调
}];

C++friendService.getAddApplicationUnreadCount(
   [](uint32_t count) {
       // get add application unread count success, handle count
   },
   [](V2NIMError error) {
       // get add application unread count failed, handle error
   });

TypeScripttry {
    const count = await nim.V2NIMFriendService.getAddApplicationUnreadCount()
} catch(err) {
    console.error('getAddApplicationUnreadCount Error:', err)
}

TypeScripttry {
    const count = await nim.V2NIMFriendService.getAddApplicationUnreadCount()
} catch(err) {
    console.error('getAddApplicationUnreadCount Error:', err)
}

TypeScripttry {
    const count = await nim.friendService.getAddApplicationUnreadCount()
} catch(err) {
    console.error('getAddApplicationUnreadCount Error:', err)
}

无返回值。

Promise<number> 未读的好友申请数量

• 请求成功，返回 V2NIMSuccessCallback 回调，包含未读的好友申请数量。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

• 请求成功，返回 V2NIMGetApplicationUnreadCountSuccess 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

无。

Javavoid setAddApplicationRead(V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)setAddApplicationRead:(nullable V2NIMSetApplicationReadSuccess)success
                      failure:(nullable V2NIMFailureCallback)failure;

C++virtual void setAddApplicationRead(V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

TypeScriptsetAddApplicationRead(): Promise<void>

无参数。

TypeScriptsetAddApplicationRead(): Promise<void>

无参数。

TypeScriptsetAddApplicationRead(): Promise<void>

无参数。

JavaNIMClient.getService(V2NIMFriendService.class).setAddApplicationRead(
new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {
        // 设置已读成功
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        // 设置已读失败
    }
});

Objective-C[[[NIMSDK sharedSDK] v2FriendService] setAddApplicationRead:^(BOOL success) {
    // 设置已读，成功回调
} failure:^(V2NIMError * _Nonnull error) {
    // 失败回调
}];

C++friendService.setAddApplicationRead(
    []() {
        // set add application read success
    },
    [](V2NIMError error) {
        // set add application read failed, handle error
    });

TypeScripttry {
    await nim.V2NIMFriendService.setAddApplicationRead()
} catch(err) {
    console.error('setAddApplicationRead Error:', err)
}

TypeScripttry {
    await v2.friendService.getAddApplicationUnreadCount()
} catch(err) {
    console.error('setAddApplicationRead Error:', err)
}

TypeScripttry {
    await nim.friendService.setAddApplicationRead()
} catch(err) {
    console.error('setAddApplicationRead Error:', err)
}

• 请求成功，返回 V2NIMSuccessCallback 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

• 请求成功，返回 V2NIMSetApplicationReadSuccess 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

无。

Javavoid setAddApplicationReadEx(V2NIMFriendAddApplication application,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)setAddApplicationReadEx:(nullable V2NIMFriendAddApplication *)application
                        success:(nullable V2NIMSuccessCallback)success
                        failure:(nullable V2NIMFailureCallback)failure;

C++virtual void setAddApplicationReadEx(const nstd::optional<V2NIMFriendAddApplication>& application,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptsetAddApplicationReadEx(application?: V2NIMFriendAddApplication): Promise<void>

TypeScriptsetAddApplicationReadEx(application: V2NIMFriendAddApplication): Promise<void>

TypeScriptsetAddApplicationReadEx(application: V2NIMFriendAddApplication): Promise<void>

Java/**
     * 标记特定好友申请为已读
     * 将指定的好友申请标记为已读状态
     */
    public void markSpecificApplicationAsRead(V2NIMFriendAddApplication application) {
        NIMClient.getService(V2NIMFriendService.class).setAddApplicationReadEx(
                application, // 传入具体的好友申请信息
                new V2NIMSuccessCallback<Void>() {
                    @Override
                    public void onSuccess(Void result) {
                        System.out.println("成功标记好友申请为已读");
                        // 更新UI，移除该申请的未读标识
                        onApplicationReadSuccess(application);
                    }
                },
                new V2NIMFailureCallback() {
                    @Override
                    public void onFailure(int code, String desc) {
                        System.err.println("标记好友申请已读失败，错误码: " + code + ", 错误描述: " + desc);
                        // 处理失败情况
                        onApplicationReadFailed(application, code, desc);
                    }
                }
        );
    }

Objective-C- (void)markApplicationAsRead:(V2NIMFriendAddApplication *)application {
    [[NIMSDK sharedSDK].V2NIMFriendService setAddApplicationReadEx:application 
                                                        success:^{
        NSLog(@"成功标记好友申请为已读");
    } failure:^(NSInteger code, NSString * _Nullable desc) {
        NSLog(@"标记好友申请已读失败，错误码: %ld, 错误描述: %@", (long)code, desc);
    }];
}

C++friendService.setAddApplicationReadEx(
    application,
    []() {
        // set add application read success
    },
    [](V2NIMError error) {
        // set add application read failed, handle error
    });

TypeScript// 全量已读
await nim.V2NIMFriendService.setAddApplicationReadEx(undefined)

// 单挑已读
const res: V2NIMFriendAddApplicationResult = await nim.V2NIMFriendService.getAddApplicationList({
  status: [] // means all status
})

if (res.infos.length > 0) {
  const lastAction = res.infos[0]
  await nim.V2NIMFriendService.setAddApplicationReadEx(lastAction)
}

TypeScriptawait v2.friendService.setAddApplicationReadEx(application)

TypeScript// 全量已读
await nim.friendService.setAddApplicationReadEx(undefined)

// 单挑已读
const res: V2NIMFriendAddApplicationResult = await nim.friendService.getAddApplicationList({
  status: [] // means all status
})

if (res.infos.length > 0) {
  const lastAction = res.infos[0]
  await friendService.setAddApplicationReadEx(lastAction)
}

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

无。

Javavoid searchFriendByOption(V2NIMFriendSearchOption friendSearchOption, V2NIMSuccessCallback<List<V2NIMFriend>> success, V2NIMFailureCallback failure);

Objective-C- (void)searchFriendByOption:(V2NIMFriendSearchOption *)friendSearchOption
                     success:(nullable V2NIMGetFirendListSuccess)success
                     failure:(nullable V2NIMFailureCallback)failure;

C++virtual void searchFriendByOption(const V2NIMFriendSearchOption& option,V2NIMSuccessCallback<nstd::vector<V2NIMFriend>> success,V2NIMFailureCallback failure) = 0;

TypeScriptsearchFriendByOption(option: V2NIMFriendSearchOption): Promise<V2NIMFriend[]>

TypeScriptsearchFriendByOption(option): Promise<V2NIMFriend[]>

TypeScriptsearchFriendByOption(option: V2NIMFriendSearchOption): Promise<V2NIMFriend[]>

Java// 按需配置
// .withSearchAccountId()
// .withSearchAlias()
.build();

NIMClient.getService(V2NIMFriendService.class).searchFriendByOption(option,
        new V2NIMSuccessCallback<List<V2NIMFriend>>() {
            @Override
            public void onSuccess(List<V2NIMFriend> v2NIMFriends) {

            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {

            }
        });

Objective-C// 按需配置
option.searchAlias = YES;
option.searchAccountId = YES;

[NIMSDK.sharedSDK.v2FriendService searchFriendByOption:option
                                               success:^(NSArray <V2NIMFriend *> *result)
{
    // 成功回调
}
                                               failure:^(V2NIMError *error)
{
    // 失败回调
}];

C++V2NIMFriendSearchOption option;
option.keyword = "keyword";
friendService.searchFriendByOption(
   option,
   [](nstd::vector<V2NIMFriend> friends) {
   // search friend success, handle friends
   },
   [](V2NIMError error) {
   // search friend failed, handle error
   });

TypeScripttry {
    const friends = await nim.V2NIMFriendService.searchFriendByOption({
        keyword: 'nick',
        searchAlias: true,
        searchAccountId: false
    });
} catch(err) {
    console.error('searchFriendByOption Error:', err);
}

TypeScripttry {
    const friends = await v2.friendService.searchFriendByOption({
        keyword: 'nick',
        searchAlias: true,
        searchAccountId: false
    });
} catch(err) {
    console.error('searchFriendByOption Error:', err);
}

TypeScripttry {
    const friends = await nim.friendService.searchFriendByOption({
        keyword: 'nick',
        searchAlias: true,
        searchAccountId: false    
    })
} catch(err) {
    console.error('searchFriendByOption Error:', err)
}

无返回值。

Promise<V2NIMFriend[]>

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMFriend 列表。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

• 请求成功，，返回 V2NIMGetFirendListSuccess 回调，可自定义设置。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

无。

Javavoid clearAllAddApplication(V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)clearAllAddApplication:(nullable V2NIMSuccessCallback)success
                       failure:(nullable V2NIMFailureCallback)failure;

C++virtual void clearAllAddApplication(const V2NIMSuccessCallback<void>& success, const V2NIMFailureCallback& failure) = 0;

TypeScriptclearAllAddApplication(): Promise<void>

无参数。

TypeScriptclearAllAddApplication(): Promise<void>

无参数。

TypeScriptclearAllAddApplication(): Promise<void>

无参数。

JavaNIMClient.getService(V2NIMFriendService.class).clearAllAddApplication(new V2NIMSuccessCallback<Void>() {
  @Override
  public void onSuccess(Void unused) {
   //success
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   //failed
  }
});

Objective-C[[NIMSDK sharedSDK].v2FriendService clearAllAddApplication:^() {
    //success
} failure:^(V2NIMError *error) {
    //failed
}];

C++friendService.clearAllAddApplication(
[]() {
    // clear all add application success
},
[](V2NIMError error) {
    // clear all add application failed, handle error
});

TypeScriptawait nim.V2NIMFriendService.clearAllAddApplication()

TypeScriptawait v2.friendService.clearAllAddApplication()

TypeScriptawait nim.friendService.clearAllAddApplication()

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

无。

Javavoid deleteAddApplication(V2NIMFriendAddApplication application, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)deleteAddApplication:(V2NIMFriendAddApplication *)application
                              success:(nullable V2NIMSuccessCallback)success
                              failure:(nullable V2NIMFailureCallback)failure;

C++virtual void deleteAddApplication(const V2NIMFriendAddApplication& application,
                                  const V2NIMSuccessCallback<void>& success,
                                  const V2NIMFailureCallback& failure) = 0;

TypeScriptdeleteAddApplication(applicationInfo: V2NIMFriendAddApplication): Promise<void>

TypeScriptdeleteAddApplication(application): Promise<void>

TypeScriptdeleteAddApplication(applicationInfo: V2NIMFriendAddApplication): Promise<void>

JavaNIMClient.getService(V2NIMFriendService.class).deleteAddApplication(application,new V2NIMSuccessCallback<Void>() {
  @Override
  public void onSuccess(Void unused) {
   //success
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   //failed
  }
});

Objective-C[NIMSDK sharedSDK].v2FriendService deleteAddApplication:application success:^() {
    //success
} failure:^(V2NIMError *error) {
    //failed
}];

C++V2NIMFriendAddApplication application;
// get application from listener or query
// ...
friendService.deleteAddApplication(
    application,
    []() {
        // delete add application success
    },
    [](V2NIMError error) {
        // delete add application failed, handle error
    });

TypeScriptawait nim.V2NIMFriendService.deleteAddApplication(applicationInfo)

TypeScriptawait v2.friendService.deleteAddApplication(application)

TypeScriptconst params = {
  applicantAccountId: 'a',
  recipientAccountId: 'b',
  operatorAccountId: 'c',
  postscript: 'd',
  status: V2NIMFriendAddApplicationStatus.V2NIM_FRIEND_ADD_APPLICATION_STATUS_INIT,
  timestamp: 1234567,
  read: true
} as V2NIMFriendAddApplication

await nimfriendService.deleteAddApplication(params)

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。
• 请求失败，返回 V2NIMFailureCallback 回调，包含好友信息相关错误码。

无。