Javavoid addConversationListener(@NonNull V2NIMConversationListener listener);

Objective-C- (void)addConversationListener:(id<V2NIMConversationListener>)listener;

C++virtual void addConversationListener(V2NIMConversationListener listener) = 0;

JavaV2NIMConversationListener listener = new V2NIMConversationListener() {
    @Override
    public void onSyncStarted() {
        // TODO
    }

    @Override
    public void onSyncFinished() {
        // TODO
    }

    @Override
    public void onSyncFailed(V2NIMError error) {
        // TODO
    }

    @Override
    public void onConversationCreated(V2NIMConversation conversation) {
        // TODO
    }

    @Override
    public void onConversationDeleted(List<String> conversationIds) {
        // TODO
    }

    @Override
    public void onConversationChanged(List<V2NIMConversation> conversationList) {
        // TODO
    }

    @Override
    public void onTotalUnreadCountChanged(int unreadCount) {
        // TODO
    }

    @Override
    public void onUnreadCountChangedByFilter(V2NIMConversationFilter filter, int unreadCount) {
        // TODO
    }

    @Override
    public void onConversationReadTimeUpdated(String conversationId, long readTime){
        // TODO
    }
};
NIMClient.getService(V2NIMConversationService.class).addConversationListener(listener);

Objective-C@interface V2ConversationServiceSample : NSObject <V2NIMConversationListener>

@end

@implementation V2ConversationServiceSample

- (void)onSyncStarted
{
    // sync started
}

- (void)onSyncFinished
{
    // sync finished
}

- (void)onSyncFailed:(V2NIMError *)error
{
    // sync failed
}

- (void)onConversationCreated:(V2NIMConversation *)conversation
{
    // conversation created
}

- (void)onConversationDeleted:(NSArray<NSString *> *)conversationIds
{
    // conversations deleted
}

- (void)onConversationChanged:(NSArray<V2NIMConversation *> *)conversations
{
    // conversations changed
}

- (void)onTotalUnreadCountChanged:(NSInteger)unreadCount
{
    // total unread count changed
}

- (void)onUnreadCountChangedByFilter:(V2NIMConversationFilter *)filter
                         unreadCount:(NSInteger)unreadCount
{
    // filter unread count changed
}

- (void)onConversationReadTimeUpdated:(NSString *)conversationId
                             readTime:(NSTimeInterval)readTime
{
    // ReadTime changed
}                            
    
- (void)addConversationListener
{
    [NIMSDK.sharedSDK.v2ConversationService addConversationListener:self];
}

@end

C++V2NIMConversationListener listener;
listener.onSyncStarted = []() {
    // handle conversation sync start event
};
listener.onSyncFinished = []() {
    // handle conversation sync finish event
};
listener.onSyncFailed = [](V2NIMError error) {
    // handle conversation sync failed event
};
listener.onConversationCreated = [](V2NIMConversation conversation) {
    // handle conversation created event
};
listener.onConversationDeleted = [](nstd::vector<nstd::string> conversationIds) {
    // handle conversation deleted event
};
listener.onConversationChanged = [](nstd::vector<V2NIMConversation> conversationList) {
    // handle conversation changed event
};
listener.onTotalUnreadCountChanged = [](uint32_t unreadCount) {
    // handle total unread count changed event
};
listener.onUnreadCountChangedByFilter = [](V2NIMConversationFilter filter, uint32_t unreadCount) {
    // handle unread count changed by group event
};
listener.onConversationReadTimeUpdated = [](nstd::string& conversationId, time_t readTime) {
    // handle ReadTime changed by group event
};
conversationService.addConversationListener(listener);

Javavoid removeConversationListener(@NonNull V2NIMConversationListener listener);

Objective-C- (void)removeConversationListener:(id<V2NIMConversationListener>)listener;

C++virtual void removeConversationListener(V2NIMConversationListener listener) = 0;

JavaNIMClient.getV2NIMConversationServcie().removeConversationListener(listener);

Objective-Cid<V2NIMConversationListener> listener;
[NIMSDK.sharedSDK.v2ConversationService removeConversationListener:listener];

C++V2NIMConversationListener listener;
conversationService.removeConversationListener(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
}

TypeScriptnim.V2NIMConversationService.on("onSyncStarted", function () {})
nim.V2NIMConversationService.on("onSyncFinished", function () {})
nim.V2NIMConversationService.on("onSyncFailed", function (err) {})
nim.V2NIMConversationService.on("onConversationCreated", function (conversation: V2NIMConversation) {})
nim.V2NIMConversationService.on("onConversationDeleted", function (conversationIds: string[]) {})
nim.V2NIMConversationService.on("onConversationChanged", function (conversationList: V2NIMConversation[]) {})
nim.V2NIMConversationService.on("onTotalUnreadCountChanged", function (unreadCount: number) {})
nim.V2NIMConversationService.on("onUnreadCountChangedByFilter", function (filter: V2NIMConversationFilter & { equals: (filter: V2NIMConversationFilter) => boolean }, unreadCount: number) {
  // todo success
  // if filter.equals(TARGET_FILTER)
})

TypeScriptnim.conversationService.on("onSyncStarted", () => {})
nim.conversationService.on("onSyncFinished", () => {})
nim.conversationService.on("onSyncFailed", (err) => {})
nim.conversationService.on("onConversationCreated", (conversation: V2NIMConversation) => {})
nim.conversationService.on("onConversationDeleted", (conversationIds: string[]) => {})
nim.conversationService.on("onConversationChanged", (conversationList: V2NIMConversation[]) => {})
nim.conversationService.on("onTotalUnreadCountChanged", (unreadCount: number) => {})
nim.conversationService.on("onUnreadCountChangedByFilter", (filter: V2NIMConversationFilter, unreadCount: number) => {
  // todo success
  // if filter.equals(TARGET_FILTER)
})

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.V2NIMConversationService.off("onSyncStarted")
nim.V2NIMConversationService.off("onSyncFinished")
nim.V2NIMConversationService.off("onSyncFailed")
nim.V2NIMConversationService.off("onConversationCreated")
nim.V2NIMConversationService.off("onConversationDeleted")
nim.V2NIMConversationService.off("onConversationChanged")
nim.V2NIMConversationService.off("onTotalUnreadCountChanged")
nim.V2NIMConversationService.off("onUnreadCountChangedByFilter")

TypeScriptnim.conversationService.off("onSyncStarted", theListner)
nim.conversationService.off("onSyncFinished", theListner)
nim.conversationService.off("onSyncFailed", theListner)
nim.conversationService.off("onConversationCreated", theListner)
nim.conversationService.off("onConversationDeleted", theListner)
nim.conversationService.off("onConversationChanged", theListner)
nim.conversationService.off("onTotalUnreadCountChanged", theListner)
nim.conversationService.off("onUnreadCountChangedByFilter", theListner)
// remove all listeners
nim.conversationService.removeAllListeners()

Javavoid createConversation(@NonNull String conversationId, V2NIMSuccessCallback<V2NIMConversation> success, V2NIMFailureCallback failure);

Objective-C- (void)createConversation:(NSString *)conversationId
                   success:(nullable V2NIMConversationCallback)success
                   failure:(nullable V2NIMFailureCallback)failure;

C++virtual void createConversation(nstd::string conversationId, V2NIMSuccessCallback<V2NIMConversation> success, V2NIMFailureCallback failure) = 0;

TypeScriptcreateConversation(conversationId: string): Promise<V2NIMConversation>

TypeScriptcreateConversation(conversationId: string): Promise<V2NIMConversation>

JavaString conversationId = V2NIMConversationIdUtil.p2pConversationId("accountId");
NIMClient.getService(V2NIMConversationService.class).createConversation(conversationId, new V2NIMSuccessCallback<V2NIMConversation>(){
    @Override
    public void onSuccess(V2NIMConversation conversation){
        // conversation created
    }
}, new V2NIMFailureCallback(){
    @Override
    public void onFailure(V2NIMError error){
        int code = error.getCode();
        String desc = error.getDesc();
        // create failed, handle error
    }
});

Objective-CNSString *conversationId = [V2NIMConversationIdUtil p2pConversationId:@"accountId"];
[NIMSDK.sharedSDK.v2ConversationService createConversation:conversationId success:^(V2NIMConversation *conversation) {
    // conversation created
} failure:^(V2NIMError *error) {
    // create failed, handle error
}];

C++auto conversationId = V2NIMConversationId::p2pConversationId("account1");
conversationService.createConversation(
    conversationId,
    [](V2NIMConversation conversation) {
        // create succeeded
    },
    [](V2NIMError error) {
        // create failed, handle error
    });

TypeScripttry {
  const data = await nim.V2NIMConversationService.createConversation("CONVERSATION_ID");
  // conversation created
} catch (err) {
  // create failed, handle error
}

TypeScriptlet conversationId: string = "cjl|1|cjl1";
try {
  let conv: V2NIMConversation = await this.conversationService.createConversation(conversationId)
  // success
} catch (e) {
  // fail
}

无返回值

Promise<V2NIMConversation> 会话相关信息

• 请求成功，返回 V2NIMSuccessCallback 回调。创建成功，返回 onConversationCreated 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

• 请求成功，返回 V2NIMConversationCallback 回调，可自定义设置。创建成功，返回 onConversationCreated 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

创建成功，返回 onConversationCreated 回调。

Javavoid deleteConversation(@NonNull String conversationId, boolean clearMessage, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)deleteConversation:(NSString *)conversationId
              clearMessage:(BOOL)clearMessage
                   success:(nullable V2NIMSuccessCallback)success
                   failure:(nullable V2NIMFailureCallback)failure;

C++virtual void deleteConversation(nstd::string conversationId,
    bool clearMessage,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptdeleteConversation(conversationId: string, clearMessage?: boolean): Promise<void>

TypeScriptdeleteConversation(conversationId: string, clearMessage?: boolean): Promise<void>

JavaNIMClient.getService(V2NIMConversationService.class).deleteConversation("会话 ID", false, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {
        // delete succeeded
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        int code = error.getCode();
        String desc = error.getDesc();
        // delete failed, handle error
    }
});

Objective-C[NIMSDK.sharedSDK.v2ConversationService deleteConversation:@"conversationId" clearMessage:NO success:^{
    // delete succeeded
} failure:^(V2NIMError *error) {
    // delete failed, handle error
}];

C++auto conversationId = V2NIMConversationId::p2pConversationId("account1");
conversationService.deleteConversation(
    conversationId,
    true,
    []() {
        // delete succeeded
    },
    [](V2NIMError error) {
        // delete failed, handle error
    });

TypeScripttry {
  await nim.V2NIMConversationService.deleteConversation("CONVERSATION_ID", true);
  // delete succeeded
} catch (err) {
  // delete failed, handle error
}

TypeScriptlet conversationId: string = "cjl|1|cjl1";
let clearMessage: boolean = true;
try {
  await this.conversationService.deleteConversation(conversationId, clearMessage)
  // success
} catch (e) {
  // fail
}

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。删除成功，返回 onConversationDeleted 回调。可能返回 onTotalUnreadCountChanged 和 onUnreadCountChangedByFilter 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

删除成功，返回 onConversationDeleted 回调。可能返回 onTotalUnreadCountChanged 和 onUnreadCountChangedByFilter 回调。

Javavoid deleteConversationListByIds(@NonNull List<String> conversationIds, boolean clearMessage, V2NIMSuccessCallback<List<V2NIMConversationOperationResult>> success,
        V2NIMFailureCallback failure);

Objective-C- (void)deleteConversationListByIds:(NSArray<NSString *> *)conversationIds
                       clearMessage:(BOOL)clearMessage
                            success:(nullable V2NIMConversationOperationResultListCallback)success
                            failure:(nullable V2NIMFailureCallback)failure;

C++virtual void deleteConversationListByIds(nstd::vector<nstd::string> conversationIds,
    bool clearMessage,
    V2NIMSuccessCallback<nstd::vector<V2NIMConversationOperationResult>> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptdeleteConversationListByIds(conversationIds: string[], clearMessage?: boolean): Promise<void>

TypeScriptdeleteConversationListByIds(conversationIds: string[], clearMessage?: boolean): Promise<V2NIMConversationOperationResult[]>

JavaNIMClient.getService(V2NIMConversationService.class).deleteConversationListByIds(ids, new V2NIMSuccessCallback<List<V2NIMConversationOperationResult>>() {
    @Override
    public void onSuccess(List<V2NIMConversationOperationResult> results) {
        // delete succeeded, check failed conversation
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        int code = error.getCode();
        String desc = error.getDesc();
        // delete failed, handle error
    }
});

Objective-C[NIMSDK.sharedSDK.v2ConversationService deleteConversationListByIds:@[@"conversationIdA", @"conversationIdB"] clearMessage:NO success:^(NSArray<V2NIMConversationOperationResult *> *resultList) {
    if (resultList.count > 0) {
        // delete succeeded, check failed conversation
    }
} failure:^(V2NIMError *error) {
    // handle error
}];

C++auto conversationIds = nstd::vector<nstd::string>();
conversationIds.emplace_back(V2NIMConversationId::p2pConversationId("account1"));
conversationIds.emplace_back(V2NIMConversationId::p2pConversationId("account2"));
conversationService.deleteConversationListByIds(
    conversationIds,
    true,
    [](nstd::vector<V2NIMConversationOperationResult> failedList) {
        // delete succeeded, check failed conversation
    },
    [](V2NIMError error) {
        // delete failed, handle error
    });

TypeScripttry {
  const ids = ["CONVERSATION_ID1", "CONVERSATION_ID2"]
  await nim.V2NIMConversationService.deleteConversationListByIds(ids, true)
  // delete succeeded, check failed conversation
} catch (err) {
  // delete failed, handle error
}

TypeScriptlet conversationIds: string[] = ["cjl|1|cjl1", "cjl|2|cjl2"];
let clearMessage: boolean = true;
try {
  let deleteFailedConversationList: V2NIMConversationOperationResult[] = await this.conversationService.deleteConversationListByIds(conversationIds, clearMessage)
  if (deleteFailedConversationList && deleteFailedConversationList.length > 0) {
    // partial success
  } else {
    // all success
  }
} catch (e) {
  // fail
}

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。每一条会话删除成功，均返回 onConversationDeleted 回调。可能返回 onTotalUnreadCountChanged 和 onUnreadCountChangedByFilter 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

• 请求成功，返回 V2NIMConversationOperationResultListCallback 回调。每一条会话删除成功，均返回 onConversationDeleted 回调。可能返回 onTotalUnreadCountChanged 和 onUnreadCountChangedByFilter 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

每一条会话删除成功，均返回 onConversationDeleted 回调。可能返回 onTotalUnreadCountChanged 和 onUnreadCountChangedByFilter 回调。

Javavoid getConversation(@NonNull String conversationId, V2NIMSuccessCallback<V2NIMConversation> success, V2NIMFailureCallback failure);

Objective-C- (void)getConversation:(NSString *)conversationId
                success:(nullable V2NIMConversationCallback)success
                failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getConversation(nstd::string conversationId, V2NIMSuccessCallback<V2NIMConversation> success, V2NIMFailureCallback failure) = 0;

TypeScriptgetConversation(conversationId: string): Promise<V2NIMConversation>

TypeScriptgetConversation(conversationId: string): Promise<V2NIMConversation>

JavaNIMClient.getV2NIMConversationServcie().getConversation("会话 ID", new V2NIMSuccessCallback<V2NIMConversation>(){
     @Override
     public void onSuccess(V2NIMConversation conversation){
         // success
     }
}, new V2NIMFailueCallback(){
     @Override
     public void onFailure(V2NIMError error){
         int code = error.getCode();
         String desc = error.getDesc();
         // handle error
     }
});

Objective-C[NIMSDK.sharedSDK.v2ConversationService getConversation:@"conversationId" success:^(V2NIMConversation *conversation) {
    // success
} failure:^(V2NIMError *error) {
    // handle error
}];

C++auto conversationId = V2NIMConversationId::p2pConversationId("account1");
conversationService.getConversation(
    conversationId,
    [](V2NIMConversation conversation) {
        // get conversation succeeded
    },
    [](V2NIMError error) {
        // get conversation failed, handle error
    });

TypeScripttry {
  const data = await nim.V2NIMConversationService.getConversation("TARGET_CONVERSATION_ID")
  // success
} catch (err) {
  // handle error
}

TypeScriptlet conversationId: string = "cjl|1|cjl1";
try {
  let conv: V2NIMConversation = await this.conversationService.getConversation(conversationId)
  // success
} catch (e) {
  // fail
}

无返回值

Promise<V2NIMConversation> 会话相关信息

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMConversation。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

• 请求成功，返回 V2NIMConversationCallback 回调，可自定义设置。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

无

Javavoid getConversationList(long offset, int limit, V2NIMSuccessCallback<V2NIMConversationResult> success, V2NIMFailureCallback failure);

Objective-C- (void)getConversationList:(long long)offset
                    limit:(NSInteger)limit
                    success:(nullable V2NIMConversationResultCallback)success
                    failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getConversationList(uint64_t offset,
    uint32_t limit,
    V2NIMSuccessCallback<V2NIMConversationResult> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptgetConversationList(offset: number, limit: number): Promise<V2NIMConversationResult>

TypeScriptgetConversationList(offset: number, limit: number): Promise<V2NIMConversationResult>

JavaNIMClient.getV2NIMConversationServcie().getConversionList(0, 100, new V2NIMSuccessCallback<V2NIMConversationResult>() {
    @Override
    public void onSuccess(V2NIMConversationResult result) {
        // success
    }
}, new V2NIMFailueCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        int code = error.code;
        String desc = error.desc;
        // handle error
    }
});

Objective-C[NIMSDK.sharedSDK.v2ConversationService getConversationList:0 limit:10 success:^(V2NIMConversationResult *result) {
    // receive result
} failure:^(V2NIMError *error) {
    // handle error
}];

C++conversationService.getConversationList(
    lastCursor,
    10,
    [](V2NIMConversationResult result) {
        // get conversation list succeeded
    },
    [](V2NIMError error) {
        // get conversation list failed, handle error
    });

TypeScripttry {
  const result = await nim.V2NIMConversationService.getConversationList(0, 100)
  // receive result
} catch (err) {
  // handle error
}

TypeScripttry {
  const result = await nim.conversationService.getConversationList(0, 100)
  // success
} catch (err) {
  // fail
}

无返回值

Promise<V2NIMConversationResult> 分页查询会话列表结果相关信息

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMConversationResult。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

• 请求成功，返回 V2NIMConversationResultCallback 回调，可自定义设置。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

无

Javavoid getConversationListByOption(long offset, int limit, V2NIMConversationOption option, V2NIMSuccessCallback<V2NIMConversationResult> success,
V2NIMFailureCallback failure);

Objective-C- (void)getConversationListByOption:(long long)offset
                            limit:(NSInteger)limit
                            option:(V2NIMConversationOption *)option
                            success:(nullable V2NIMConversationResultCallback)success
                            failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getConversationListByOption(uint64_t offset,
    uint32_t limit,
    V2NIMConversationOption option,
    V2NIMSuccessCallback<V2NIMConversationResult> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptgetConversationListByOption(offset: number, limit: number, option: V2NIMConversationOption): Promise<V2NIMConversationResult>

TypeScriptgetConversationListByOption(offset: number, limit: number, option: V2NIMConversationOption): Promise<V2NIMConversationResult>

JavaV2NIMConversationOption option = new V2NIMConversationOption();
List<Integer> conversionTypes = new ArrayList<Integer>();
conversionTypes.add(1);
options.setConversionTypes =conversionTypes;
option.onlyUnread = true;
NIMClient.getV2NIMConversationServcie().getConversionListByOption(0, 100,option, new V2NIMSuccessCallback<V2NIMConversationResult>>(){
    @Override
    public void onSuccess<V2NIMConversationResult>(V2NIMConversationResult result){
        // receive result
    }
}, new V2NIMFailueCallback(){
    @Override
    public void onFailure(V2NIMError error){
        int code = error.code;
        String desc = error.desc;
        // handle error
    }
});

Objective-CV2NIMConversationOption *option = [[V2NIMConversationOption alloc] init];
option.conversationTypes = @[
    @(V2NIM_CONVERSATION_TYPE_P2P),
    @(V2NIM_CONVERSATION_TYPE_TEAM),
];
option.conversationGroupIds = @[
    @"groupIdA",
    @"groupIdB",
];
option.onlyUnread = YES;
[NIMSDK.sharedSDK.v2ConversationService getConversationListByOption:0 limit:10 option:option success:^(V2NIMConversationResult * result) {
    // receive result
} failure:^(V2NIMError * error) {
    // handle error
}];

C++V2NIMConversationOption option;
option.onlyUnread = true;
option.conversationTypes = {V2NIM_CONVERSATION_TYPE_P2P, V2NIM_CONVERSATION_TYPE_TEAM};
conversationService.getConversationListByOption(
    lastCursor,
    10,
    option,
    [](V2NIMConversationResult result) {
        // get conversation list succeeded
    },
    [](V2NIMError error) {
        // get conversation list failed, handle error
    });

TypeScripttry {
  const list = await nim.V2NIMConversationService.getConversationListByOption(0, 100, {
    conversationTypes: [V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P]
    onlyUnread: true,
  })
  // Success
} catch (err) {
  // handle error
}

TypeScriptlet offset: number = 0;
let limit: number = 100;
let option: V2NIMConversationOption = {
  conversationTypes: [V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P]
}

try {
  let result: V2NIMConversationResult = await this.conversationService.getConversationListByOption(offset, limit, option)
  // success
} catch (e) {
  // fail
}

无返回值

Promise<V2NIMConversationResult> 分页查询会话列表结果相关信息

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMConversationResult。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

• 请求成功，返回 V2NIMConversationResultCallback 回调，可自定义设置。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

无

Javavoid getConversationListByIds(@NonNull List<String> conversationIds, V2NIMSuccessCallback<List<V2NIMConversation>> success,
V2NIMFailureCallback failure);

Objective-C- (void)getConversationListByIds:(NSString *)conversationIds
                         success:(nullable V2NIMConversationListCallback)success
                         failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getConversationListByIds(nstd::vector<nstd::string> conversationIds,
    V2NIMSuccessCallback<V2NIMConversationList> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptgetConversationListByIds(conversationIds: string[]): Promise<V2NIMConversation[]>

TypeScriptgetConversationListByIds(conversationIds: string[]): Promise<V2NIMConversation[]>

JavaNIMClient.getService(V2NIMConversationService.class).getConversationListByIds(ids, new V2NIMSuccessCallback<List<V2NIMConversation>>() {
    @Override
    public void onSuccess(List<V2NIMConversation> conversations) {
        // receive conversation list
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        int code = error.getCode();
        String desc = error.getDesc();
        // handle error
    }
});

Objective-C[NIMSDK.sharedSDK.v2ConversationService getConversationListByIds:@[@"conversationIdA", @"conversationIdB"] success:^(NSArray<V2NIMConversation *> *conversationList) {
    // receive conversation list
} failure:^(V2NIMError *error) {
    // handle error
}];

C++auto conversationIds = nstd::vector<nstd::string>();
conversationIds.emplace_back(V2NIMConversationId::p2pConversationId("account1"));
conversationIds.emplace_back(V2NIMConversationId::p2pConversationId("account2"));
conversationService.getConversationListByIds(
    conversationIds,
    [](V2NIMConversationList list) {
        // get conversation list succeeded
    },
    [](V2NIMError error) {
        // get conversation list failed, handle error
    });

TypeScripttry {
  const ids = ["ID1", "ID2"]
  const list = await nim.V2NIMConversationService.getConversationListByIds(ids)
  // receive conversation list
} catch (err) {
  // handle error
}

TypeScriptlet conversationIds: string[] = ["cjl|1|cjl1", "cjl|2|cjl2"];
try {
  let result: V2NIMConversation[] = await this.conversationService.getConversationListByIds(conversationIds)
  // success
} catch (e) {
  // fail
}

无返回值

Promise<V2NIMConversation[]> 会话列表相关信息

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 V2NIMConversation 列表。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

• 请求成功，返回 V2NIMConversationListCallback 回调，可自定义设置。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

无

Javavoid updateConversation(@NonNull String conversationId, V2NIMConversationUpdate updateInfo, V2NIMSuccessCallback<Void> success,
V2NIMFailureCallback failure);

Objective-C- (void)updateConversation:(NSString *)conversationId
                updateInfo:(V2NIMConversationUpdate *)updateInfo
                   success:(nullable V2NIMSuccessCallback)success
                   failure:(nullable V2NIMFailureCallback)failure;

C++virtual void updateConversation(nstd::string conversationId,
    V2NIMConversationUpdate updateInfo,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptupdateConversation(conversationId: string, updateInfo: V2NIMConversationUpdate): Promise<void>

TypeScriptupdateConversation(conversationId: string, updateInfo: V2NIMConversationUpdate): Promise<void>

JavaV2NIMConversationUpdate updateInfo = new V2NIMConversationUpdate();
updateInfo.setServerExtension("serverextension");
updateInfo.setLocalExtension("localextension");
NIMClient.getService(V2NIMConversationService.class).updateConversation("conversationId", updateInfo, new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {
        // success
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        int code = error.getCode();
        String desc = error.getDesc();
        // handle error
    }
});

Objective-CV2NIMConversationUpdate *info = [[V2NIMConversationUpdate alloc] init];
info.localExtension = @"localExtension";
info.serverExtension = @"serverExtension";
[NIMSDK.sharedSDK.v2ConversationService updateConversation:@"conversationId" updateInfo:info success:^{
    // success
} failure:^(V2NIMError *error) {
    // handle error
}];

C++auto conversationId = V2NIMConversationId::p2pConversationId("account1");
V2NIMConversationUpdate param;
param.extension = "extension";
conversationService.updateConversation(
    conversationId,
    param,
    []() {
        // update succeeded
    },
    [](V2NIMError error) {
        // update failed, handle error
    });

TypeScripttry {
  const params = { serverExtention: "This is a new text" }
  await nim.V2NIMConversationService.updateConversation("CONVERSATION_ID", params)
  // Success
} catch (err) {
  // handle error
}

TypeScriptlet conversationId: string = "cjl|1|cjl1"
let userInfo: V2NIMConversationUpdate = {
  serverExtension: "serverExtension"
}
try {
  await this.conversationService.updateConversation(conversationId, userInfo)
  // success
} catch (e) {
  // fail
}

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。更新成功，返回 onConversationChanged 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

更新成功，返回 onConversationChanged 回调。

参考 updateConversation。

参考 updateConversation。

参考 updateConversation。

TypeScriptupdateConversationLocalExtension(conversationId: string, localExtension: string): Promise<void>

TypeScriptupdateConversationLocalExtension(conversationId: string, localExtension: string): Promise<void>

参考 updateConversation。

参考 updateConversation。

参考 updateConversation。

TypeScripttry {
  await nim.V2NIMConversationService.updateConversationLocalExtension("CONVERSATION_ID", "newLocalExtension！")
  // todo Success.
} catch (err) {
  // todo err.code
}

TypeScriptlet conversationId: string = "cjl|1|cjl1"
let localExtension: string = "localExtension"
try {
  await this.conversationService.updateConversationLocalExtension(conversationId, localExtension)
  // success
} catch (e) {
  // fail
}

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。更新成功，返回 onConversationChanged 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

更新成功，返回 onConversationChanged 回调。

Javavoid stickTopConversation(@NonNull String conversationId, boolean stickTop, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)stickTopConversation:(NSString *)conversationId
                    stickTop:(BOOL)stickTop
                     success:(nullable V2NIMSuccessCallback)success
                     failure:(nullable V2NIMFailureCallback)failure;

C++virtual void stickTopConversation(nstd::string conversationId,
    bool stickTop,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptstickTopConversation(conversationId: string, stickTop: boolean): Promise<void>

TypeScriptstickTopConversation(conversationId: string, stickTop: boolean): Promise<void>

JavaNIMClient.getService(V2NIMConversationService.class).stickTopConversation("会话 ID", true, new V2NIMSuccessCallback<Void>() {
        @Override
        public void onSuccess(Void unused) {
            // success
        }
    }, new V2NIMFailureCallback() {
        @Override
        public void onFailure(V2NIMError error) {
            int code = error.getCode();
            String desc = error.getDesc();
            // handle error
        }
    });

Objective-C[NIMSDK.sharedSDK.v2ConversationService stickTopConversation:@"conversationId" stickTop:YES success:^{
    // success
} failure:^(V2NIMError *error) {
    // handle error
}];

C++auto conversationId = V2NIMConversationId::p2pConversationId("account1");
conversationService.stickTopConversation(
    conversationId,
    true,
    []() {
        // stick top succeeded
    },
    [](V2NIMError error) {
        // stick top failed, handle error
    });

TypeScripttry {
  await nim.V2NIMConversationService.stickTopConversation("CONVERSATION_ID", true)
  // Success
} catch (err) {
  // handle error
}

TypeScriptlet conversationId: string = "cjl|1|cjl1"
let stickTop: boolean = true;
try {
  await this.conversationService.stickTopConversation(conversationId, stickTop)
  // success
} catch (e) {
  // fail
}

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。置顶成功，返回 onConversationChanged 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

置顶成功，返回 onConversationChanged 回调。

Javaint getTotalUnreadCount();

无参数

Objective-C- (NSInteger)getTotalUnreadCount;

无参数

C++virtual uint32_t getTotalUnreadCount() = 0;

无参数

TypeScriptgetTotalUnreadCount(): number

无参数

TypeScriptgetTotalUnreadCount(): number

无参数

Javaint totalUnreadCount = NIMClient.getService(V2NIMConversationService.class).getTotalUnreadCount();

Objective-CNSInteger count = [NIMSDK.sharedSDK.v2ConversationService getTotalUnreadCount];

C++auto totalUnreadCount = conversationService.getTotalUnreadCount();

TypeScriptconst count = nim.V2NIMConversationService.getTotalUnreadCount()

TypeScriptconst unreadCount: number = this.conversationService.getTotalUnreadCount()

Javavoid getUnreadCountByIds(@NonNull List<String> conversationIds, V2NIMSuccessCallback<Integer> success, V2NIMFailureCallback failure);

Objective-C- (void)getUnreadCountByIds:(NSArray<NSString *> *)conversationIds
                    success:(nullable V2NIMConversationUnreadCountCallback)success
                    failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getUnreadCountByIds(nstd::vector<nstd::string> conversationIds,
    V2NIMSuccessCallback<uint32_t> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptgetUnreadCountByIds(conversationIds: string[]): Promise<number>

TypeScriptgetUnreadCountByIds(conversationIds: string[]): Promise<number>

JavaNIMClient.getService(V2NIMConversationService.class).getUnreadCountByIds(ids, new V2NIMSuccessCallback<Integer>(){
    @Override
    public void onSuccess(Integer count){
        // receive unread count
    }
},new V2NIMFailureCallback(){
    @Override
    public void onFailure(V2NIMError error){
        int code = error.getCode();
        String desc = error.getDesc();
        // handle error
    }
});

Objective-C[NIMSDK.sharedSDK.v2ConversationService getUnreadCountByIds:@[@"conversationIdA", @"conversationIdB"] success:^(NSInteger unreadCount) {
    // receive unread count
} failure:^(V2NIMError * _Nonnull error) {
    // handle error
}];

C++auto conversationIds = nstd::vector<nstd::string>();
conversationIds.emplace_back(V2NIMConversationId::p2pConversationId("account1"));
conversationIds.emplace_back(V2NIMConversationId::p2pConversationId("account2"));
conversationService.getUnreadCountByIds(
    conversationIds,
    [](uint32_t count) {
        // get unread count succeeded
    },
    [](V2NIMError error) {
        // get unread count failed, handle error
    });

TypeScripttry {
  const counts = await nim.V2NIMConversationService.getUnreadCountByIds(["CONVERSATION_ID1", "CONVERSATION_ID2"]);
} catch (err) {
    // Handle error
}

TypeScriptlet conversationIds: string[] = ["cjl|1|cjl1", "cjl|2|cjl2"];
try {
  const unreadCount: number = await this.conversationService.getUnreadCountByIds(conversationIds)
  // success
} catch (e) {
  // fail
}

无返回值

Promise<number> 指定的会话列表的总未读数。

• 请求成功，返回 V2NIMSuccessCallback 回调，包含指定的会话列表的总未读数。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

• 请求成功，返回 V2NIMConversationUnreadCountCallback 回调，可自定义设置。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

无

Javavoid getUnreadCountByFilter(V2NIMConversationFilter filter, V2NIMSuccessCallback<Integer> success, V2NIMFailureCallback failure);

Objective-C- (void)getUnreadCountByFilter:(V2NIMConversationFilter *)filter
                       success:(nullable V2NIMConversationUnreadCountCallback)success
                       failure:(nullable V2NIMFailureCallback)failure;

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

TypeScriptgetUnreadCountByFilter(filter: V2NIMConversationFilter): Promise<number>

TypeScriptgetUnreadCountByFilter(filter: V2NIMConversationFilter): Promise<number>

JavaV2NIMConversationFilter filter = new V2NIMConversationFilter();
List<V2NIMConversationType> conversionTypes = new ArrayList<>();
conversionTypes.add(V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P);
filter.setConversationTypes(conversionTypes);
filter.setConversationGroupId("会话分组 ID");
NIMClient.getService(V2NIMConversationService.class).getUnreadCountByFilter(filter, new V2NIMSuccessCallback<Integer>(){
    @Override
    public void onSuccess(Integer count){
        // receive unread count
    }
},new V2NIMFailureCallback(){
    @Override
    public void onFailure(V2NIMError error){
        int code = error.getCode();
        String desc = error.getDesc();
        // handle error
    }
});

Objective-CV2NIMConversationFilter *filter = [[V2NIMConversationFilter alloc] init];
filter.conversationTypes = @[
    @(V2NIM_CONVERSATION_TYPE_P2P),
    @(V2NIM_CONVERSATION_TYPE_TEAM)
];
filter.conversationGroupId = @"groupId";
filter.ignoreMuted = YES;

[NIMSDK.sharedSDK.v2ConversationService getUnreadCountByFilter:filter
    success:^(NSInteger unreadCount) {
        // receive unread count
    }
    failure:^(V2NIMError * _Nonnull error) {
        // handle error
    }];

C++V2NIMConversationFilter filter;
filter.conversationTypes = {V2NIM_CONVERSATION_TYPE_P2P, V2NIM_CONVERSATION_TYPE_TEAM};
conversationService.getUnreadCountByFilter(
    filter,
    [](uint32_t count) {
        // get unread count succeeded
    },
    [](V2NIMError error) {
        // get unread count failed, handle error
    });

TypeScripttry {
  // P2P type
  const filter = { conversationTypes: [1] }
  const counts = await nim.V2NIMConversationService.getUnreadCountByFilter(filter)
  // receive unread count
} catch (err) {
  // handle error
}

TypeScriptlet filter: V2NIMConversationFilter = {
  conversationTypes: [V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P]
}
try {
  let unreadCount: number = await this.conversationService.getUnreadCountByFilter(filter)
  // success
} catch (e) {
  // fail
}

无返回值

Promise<number> 过滤后的会话列表的消息总未读数。

• 请求成功，返回 V2NIMSuccessCallback 回调，包含过滤后的会话列表的消息总未读数。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

• 请求成功，返回 V2NIMConversationUnreadCountCallback 回调，可自定义设置。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

无

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

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

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

TypeScriptclearTotalUnreadCount(): Promise<void>

无参数

TypeScriptclearTotalUnreadCount(): Promise<void>

无参数

JavaNIMClient.getService(V2NIMConversationService.class).clearTotalUnreadCount(new V2NIMSuccessCallback<Void>(){
    @Override
    public void onSuccess(Void unused) {
        // success
    }
}, new V2NIMFailureCallback(){
    @Override
    public void onFailure(V2NIMError error){
        int code = error.getCode();
        String desc = error.getDesc();
        // handle error
    }
});

Objective-C[NIMSDK.sharedSDK.v2ConversationService clearTotalUnreadCount:^{

} failure:^(V2NIMError * _Nonnull error) {
    // handle error
}];

C++conversationService.clearTotalUnreadCount(
    []() {
        // clear total unread count succeeded
    },
    [](V2NIMError error) {
        // clear total unread count failed, handle error
    });

TypeScripttry {
  await nim.V2NIMConversationService.clearTotalUnreadCount()
  // Success
} catch (err) {
  // handle error
}

TypeScripttry {
  await nim.V2NIMConversationService.clearTotalUnreadCount()
  // Success
} catch (err) {
  // handle error
}

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。清零成功，返回 onTotalUnreadCountChanged、onConversationChanged 和 onUnreadCountChangedByFilter 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

清零成功，返回 onTotalUnreadCountChanged、onConversationChanged 和 onUnreadCountChangedByFilter 回调。

Javavoid clearUnreadCountByIds(@NonNull List<String> conversationIds, V2NIMSuccessCallback<List<V2NIMConversationOperationResult>> success, V2NIMFailureCallback failure);

Objective-C- (void)clearUnreadCountByIds:(NSArray<NSString *> *)conversationIds
                      success:(nullable V2NIMConversationOperationResultListCallback)success
                      failure:(nullable V2NIMFailureCallback)failure;

C++virtual void clearUnreadCountByIds(nstd::vector<nstd::string> conversationIds,
    V2NIMSuccessCallback<nstd::vector<V2NIMConversationOperationResult>> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptclearUnreadCountByIds(conversationIds: string[]): Promise<V2NIMConversationOperationResult[]>

TypeScriptclearUnreadCountByIds(conversationIds: string[]): Promise<V2NIMConversationOperationResult[]>

JavaNIMClient.getService(V2NIMConversationService.class).clearUnreadCountByIds(ids, new V2NIMSuccessCallback<List<V2NIMConversationOperationResult>>(){
    @Override
    public void onSuccess(List<V2NIMConversationOperationResult> results){
        // check failed conversation
    }
}, new V2NIMFailureCallback(){
    @Override
    public void onFailure(V2NIMError error){
        int code = error.getCode();
        String desc = error.getDesc();
        // handle error
    }
});

Objective-C[NIMSDK.sharedSDK.v2ConversationService clearUnreadCountByIds:@[@"conversationIdA", @"conversationIdB"] success:^(NSArray<V2NIMConversationOperationResult *> *resultList) {
    if (resultList.count > 0) {
        // check failed conversation
    }
} failure:^(V2NIMError * _Nonnull error) {
    // handle error
}];

C++auto conversationIds = nstd::vector<nstd::string>();
conversationIds.emplace_back(V2NIMConversationId::p2pConversationId("account1"));
conversationIds.emplace_back(V2NIMConversationId::p2pConversationId("account2"));
conversationService.clearUnreadCountByIds(
    conversationIds,
    [](nstd::vector<V2NIMConversationOperationResult> failedList) {
        // clear unread count succeeded
    },
    [](V2NIMError error) {
        // clear unread count failed, handle error
    });

TypeScripttry {
  await nim.V2NIMConversationService.clearUnreadCountByIds(["CONVERSATION_ID1", "CONVERSATION_ID2"])
  // Success
} catch (err) {
  // handle error
}

TypeScriptlet conversationIds: string[] = ["cjl|1|cjl1", "cjl|2|cjl2"];
try {
  const deleteFailedConversationList: V2NIMConversationOperationResult[] = await this.conversationService.clearUnreadCountByIds(conversationIds)
  if (deleteFailedConversationList && deleteFailedConversationList.length > 0) {
    // partial success
  } else {
    // all success
  }
} catch (e) {
  // fail
}

无返回值

Promise<V2NIMConversationOperationResult []>

• 请求成功，返回 V2NIMSuccessCallback 回调。清零成功，返回 onTotalUnreadCountChanged、onConversationChanged 和 onUnreadCountChangedByFilter 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

• 请求成功，返回 V2NIMConversationOperationResultListCallback 回调。清零成功，返回 onTotalUnreadCountChanged、onConversationChanged 和 onUnreadCountChangedByFilter 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

清零成功，返回 onTotalUnreadCountChanged、onConversationChanged 和 onUnreadCountChangedByFilter 回调。

Javavoid clearUnreadCountByGroupId(@NonNull String groupId, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)clearUnreadCountByGroupId:(NSString *)groupId
                          success:(nullable V2NIMSuccessCallback)success
                          failure:(nullable V2NIMFailureCallback)failure;

C++virtual void clearUnreadCountByGroupId(nstd::string groupId, V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

TypeScriptclearUnreadCountByGroupId(groupId: string): Promise<void>

TypeScriptclearUnreadCountByGroupId(groupId: string): Promise<void>

JavaNIMClient.getService(V2NIMConversationService.class).clearUnreadCountByGroupId("会话分组 ID",new V2NIMSuccessCallback<Void>(){
    @Override
    public void onSuccess(Void unused) {
        // success
    }
}, new V2NIMFailureCallback(){
    @Override
    public void onFailure(V2NIMError error){
        int code = error.getCode();
        String desc = error.getDesc();
        // handle error
    }
});

Objective-C[NIMSDK.sharedSDK.v2ConversationService clearUnreadCountByGroupId:@"groupId" success:^{

        } failure:^(V2NIMError * _Nonnull error) {
            // handle error
        }];

C++conversationService.clearUnreadCountByGroupId(
    "groupId",
    []() {
        // clear unread count succeeded
    },
    [](V2NIMError error) {
        // clear unread count failed, handle error
    });

TypeScripttry {
  await nim.V2NIMConversationService.clearUnreadCountByGroupId('GROUP_ID')
  // Success
} catch (err) {
  // handle error
}

TypeScriptlet groupId: string = "0123456789"
try {
  await this.conversationService.clearUnreadCountByGroupId(groupId)
  // success
} catch (e) {
  // fail
}

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。清零成功，返回 onTotalUnreadCountChanged、onConversationChanged 和 onUnreadCountChangedByFilter 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

清零成功，返回 onTotalUnreadCountChanged、onConversationChanged 和 onUnreadCountChangedByFilter 回调。

Javavoid clearUnreadCountByTypes(@NonNull List<V2NIMConversationType> conversationTypes, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)clearUnreadCountByTypes:(NSArray<NSNumber *> *)conversationTypes
                        success:(nullable V2NIMSuccessCallback)success
                        failure:(nullable V2NIMFailureCallback)failure;

C++virtual void clearUnreadCountByTypes(nstd::vector<V2NIMConversationType> conversationTypes,
    V2NIMSuccessCallback<void> success,
    V2NIMFailureCallback failure) = 0;

TypeScriptclearUnreadCountByTypes(types: V2NIMConversationType[]): Promise<void>

TypeScriptclearUnreadCountByTypes(types: V2NIMConversationType[]): Promise<void>

JavaList<V2NIMConversationType> conversionTypes = new ArrayList<>();
conversionTypes.add(V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P);
NIMClient.getService(V2NIMConversationService.class).clearUnreadCountByTypes(conversionTypes,new V2NIMSuccessCallback<Void>(){
    @Override
    public void onSuccess(Void unused) {
        // TODO
    }
}, new V2NIMFailureCallback(){
    @Override
    public void onFailure(V2NIMError error){
        int code = error.getCode();
        String desc = error.getDesc();
        // TODO
    }
});

Objective-C[NIMSDK.sharedSDK.v2ConversationService clearUnreadCountByTypes:@[
    @(V2NIM_CONVERSATION_TYPE_P2P),
    @(V2NIM_CONVERSATION_TYPE_TEAM),
] success:^{

    } failure:^(V2NIMError * _Nonnull error) {
        // handle error
    }];

C++conversationService.clearUnreadCountByTypes(
    {V2NIM_CONVERSATION_TYPE_P2P, V2NIM_CONVERSATION_TYPE_TEAM},
    []() {
        // clear unread count succeeded
    },
    [](V2NIMError error) {
        // clear unread count failed, handle error
    });

TypeScripttry {
  await nim.V2NIMConversationService.clearUnreadCountByTypes([1])
  // todo Success.
} catch (err) {
  // todo err.code
}

TypeScriptlet conversationTypes:V2NIMConversationType[] = [V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P]
try {
  await this.conversationService.clearUnreadCountByTypes(conversationTypes)
  // success
} catch (e) {
  // fail
}

无返回值

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。清零成功，返回 onTotalUnreadCountChanged、onConversationChanged 和 onUnreadCountChangedByFilter 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

清零成功，返回 onTotalUnreadCountChanged、onConversationChanged 和 onUnreadCountChangedByFilter 回调。

Javavoid subscribeUnreadCountByFilter(@NonNull V2NIMConversationFilter filter);

Objective-C- (void)subscribeUnreadCountByFilter:(V2NIMConversationFilter *)filter;

C++virtual void subscribeUnreadCountByFilter(V2NIMConversationFilter filter) = 0;

TypeScriptsubscribeUnreadCountByFilter(filter: V2NIMConversationFilter): void

TypeScriptsubscribeUnreadCountByFilter(filter: V2NIMConversationFilter): void

JavaV2NIMConversationFilter filter = new V2NIMConversationFilter();
List<V2NIMConversationType> conversionTypes = new ArrayList<>();
conversionTypes.add(V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P);
filter.setConversationTypes(conversionTypes);
filter.setConversationGroupId("会话分组 ID");
filter.setIgnoreMuted(true);
V2NIMError result = NIMClient.getService(V2NIMConversationService.class).subscribeUnreadCountByFilter(filter);
if(result == null){
    // success
}else{
    int code = result.getCode();
    String desc = result.getDesc();
    // handle error
}

Objective-CV2NIMConversationFilter *filter = [[V2NIMConversationFilter alloc] init];
filter.conversationTypes = @[
    @(V2NIM_CONVERSATION_TYPE_P2P),
    @(V2NIM_CONVERSATION_TYPE_TEAM),
];
filter.conversationGroupId = @"groupId";
filter.ignoreMuted = YES;
[NIMSDK.sharedSDK.v2ConversationService subscribeUnreadCountByFilter:filter];

C++V2NIMConversationFilter filter;
filter.conversationTypes = {V2NIM_CONVERSATION_TYPE_P2P, V2NIM_CONVERSATION_TYPE_TEAM};
conversationService.subscribeUnreadCountByFilter(filter);

TypeScriptconst filter = {
    conversationTypes: [1]
}
nim.V2NIMConversationService.subscribeUnreadCountByFilter(filter)

TypeScriptconst filter: V2NIMConversationFilter = {
  conversationTypes: [V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P]
}
try {
  this.conversationService.subscribeUnreadCountByFilter(filter)
  // success
} catch (e) {
  // fail
}

Javavoid unsubscribeUnreadCountByFilter(@NonNull V2NIMConversationFilter filter);

Objective-C- (void)unsubscribeUnreadCountByFilter:(V2NIMConversationFilter *)filter;

C++virtual void unsubscribeUnreadCountByFilter(V2NIMConversationFilter filter) = 0;

TypeScriptunsubscribeUnreadCountByFilter(filter: V2NIMConversationFilter): void

TypeScriptunsubscribeUnreadCountByFilter(filter: V2NIMConversationFilter): void

JavaV2NIMError result = NIMClient.getService(V2NIMConversationService.class).unsubscribeUnreadCountByFilter(filter);
if(result == null){
    // success
}else{
    int code = result.getCode();
    String desc = result.getDesc();
    // handle error
}

Objective-CV2NIMConversationFilter *filter = [[V2NIMConversationFilter alloc] init];
filter.conversationTypes = @[
    @(V2NIM_CONVERSATION_TYPE_P2P),
    @(V2NIM_CONVERSATION_TYPE_TEAM),
];
filter.conversationGroupId = @"groupId";
filter.ignoreMuted = YES;
[NIMSDK.sharedSDK.v2ConversationService unsubscribeUnreadCountByFilter:filter];

C++V2NIMConversationFilter filter;
filter.conversationTypes = {V2NIM_CONVERSATION_TYPE_P2P, V2NIM_CONVERSATION_TYPE_TEAM};
conversationService.unsubscribeUnreadCountByFilter(filter);

TypeScriptconst filter = {
    conversationTypes: [1]
}
nim.V2NIMConversationService.unsubscribeUnreadCountByFilter(filter)

TypeScriptconst filter: V2NIMConversationFilter = {
  conversationTypes: [V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P]
}
try {
  this.conversationService.unsubscribeUnreadCountByFilter(filter)
  // success
} catch (e) {
  // fail
}

Java/**
 * 标记会话已读时间戳
 * 当前只支持 P2P，高级群，超大群
 * @param conversationId 会话 ID
 * @param success 查询成功回调
 * @param failure 查询失败回调
 */
void markConversationRead(String conversationId, V2NIMSuccessCallback<Long> success, V2NIMFailureCallback failure);

Objective-C/// 成功接收标记会话已读时间戳
typedef void (^V2NIMMarkConversationReadCallback)(NSTimeInterval timestamp);

/**
 * 标记会话已读时间戳
 *
 * @param conversationId 会话 ID
 * @param success 成功回调
 * @param failure 失败回调
 */
- (void)markConversationRead:(NSString *)conversationId
                     success:(nullable V2NIMMarkConversationReadCallback)success
                     failure:(nullable V2NIMFailureCallback)failure;

C++virtual void v2::V2NIMConversationService::markConversationRead    (    nstd::string     conversationId,
V2NIMSuccessCallback< time_t >     success,
V2NIMFailureCallback     failure
)

TypeScript  /**
   * 标记会话已读时间戳
   *
   * 注: 当该方法调用后，SDK 可能给多端账户抛出以下的事件
   *
   * {@link V2NIMConversationListener.onConversationReadTimeUpdated | V2NIMConversationListener.onConversationReadTimeUpdated} <br/>
   *
   */
markConversationRead(conversationId: string): Promise<number>

JavaString sessionId = "会话对象 ID";
V2NIMConversationType conversationType = V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P;
String conversationId = V2NIMConversationIdUtil.conversationId(sessionId, conversationType);
NIMClient.getService(V2NIMConversationService.class).markConversationRead(conversationId,
        new V2NIMSuccessCallback<Long>() {
            @Override
            public void onSuccess(Long aLong) {

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

            }
        });

Objective-C- (void)markRead
{
    [NIMSDK.sharedSDK.v2ConversationService markConversationRead:@"conversationId" success:^(NSTimeInterval timestamp) {
        // result
    } failure:^(V2NIMError * _Nonnull error) {
        // error
    }];
}

C++conversationService.markConversationRead(
    "conversationId",
    []() {
        // mark conversation read succeeded
    },
    [](V2NIMError error) {
        // mark conversation read failed, handle error
    )};

TypeScriptawait nim.V2NIMConversationService.markConversationRead('sender|1|receiver')

无返回值

Promise<number>

• 请求成功，返回 V2NIMSuccessCallback 回调。标记成功，返回 readTime。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

• 请求成功，返回 V2NIMMarkConversationReadCallback 回调，可自定义。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

无

Java/**
 * 获取会话已读时间戳
 * 当前只支持 P2P，高级群，超大群
 * @param conversationId 会话 ID
 * @param success 查询成功回调
 * @param failure 查询失败回调
 */
void getConversationReadTime(String conversationId, V2NIMSuccessCallback<Long> success, V2NIMFailureCallback failure);

Objective-C/// 成功接收已读时间戳
typedef void (^V2NIMConversationReadTimeCallback)(NSTimeInterval timestamp);

/**
 * 获取会话已读时间戳
 *
 * @param conversationId 会话 ID
 * @param success 成功回调
 * @param failure 失败回调
 */
- (void)getConversationReadTime:(NSString *)conversationId
                        success:(nullable V2NIMConversationReadTimeCallback)success
                        failure:(nullable V2NIMFailureCallback)failure;

C++virtual void v2::V2NIMConversationService::getConversationReadTime    (    nstd::string     conversationId,
V2NIMSuccessCallback< time_t >     success,
V2NIMFailureCallback     failure
)

TypeScript  /**
   * 获取会话已读时间戳。该时间包含多端已读时间戳
   */
getConversationReadTime(conversationId: string): Promise<number>

JavaString sessionId = "会话对象 ID";
V2NIMConversationType conversationType = V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P;
String conversationId = V2NIMConversationIdUtil.conversationId(sessionId, conversationType);
NIMClient.getService(V2NIMConversationService.class).getConversationReadTime(conversationId,
        new V2NIMSuccessCallback<Long>() {
            @Override
            public void onSuccess(Long aLong) {

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

            }
        });

Objective-C- (void)getReadTime
{
    [NIMSDK.sharedSDK.v2ConversationService getConversationReadTime:@"conversationId" success:^(NSTimeInterval timestamp) {
        // result
    } failure:^(V2NIMError * _Nonnull error) {
        // error
    }];
}

C++conversationService.getConversationReadTime(
    "conversationId",
    [](time_t readTime) {
        // get conversation read time succeeded
    },
    [](V2NIMError error) {
        // get conversation read time failed, handle error
    )};

TypeScriptconst readTime = await nim.V2NIMConversationService.getConversationReadTime('sender|1|receiver')

无返回值

Promise<number>

• 请求成功，返回 V2NIMSuccessCallback 回调。标记成功，返回 readTime。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

• 请求成功，返回 V2NIMConversationReadTimeCallback 回调，可自定义。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含会话相关错误码。

无