Javavoid addConversationListener(@NonNull V2NIMLocalConversationListener listener);

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

C++virtual void addConversationListener(const V2NIMLocalConversationListener& listener) = 0;

JavaV2NIMLocalConversationListener listener = new V2NIMLocalConversationListener() {
  @Override
  public void onSyncStarted() {  
  }
  @Override
  public void onSyncFinished() {
  }
  @Override
  public void onSyncFailed(V2NIMError error) {
  }
  @Override
  public void onConversationCreated(V2NIMLocalConversation conversation) {
  }
  @Override
  public void onConversationDeleted(List<String> conversationIds) {
  }
  @Override
  public void onConversationChanged(List<V2NIMLocalConversation> conversationList) {
  }
  @Override
  public void onTotalUnreadCountChanged(int unreadCount) {
  }
  @Override
  public void onUnreadCountChangedByFilter(V2NIMLocalConversationFilter filter, int unreadCount) {
  }
  @Override
  public void onConversationReadTimeUpdated(String conversationId, long readTime) {
  }
};
NIMClient.getService(V2NIMLocalConversationService.class).addConversationListener(listener);

Objective-C@interface SampleCode : NSObject<V2NIMLocalConversationListener>
@end

@implementation SampleCode
- (void)onSyncStarted
{  
}
- (void)onSyncFinished
{
}
/**
 * @param error 会话数据云端同步失败，可能为如下原因：网络连接断开；服务异常。可以根据相应错误码确定相关错误原因
 */
- (void)onSyncFailed:(V2NIMError *)error
{
}
- (void)onConversationCreated:(V2NIMLocalConversation *)conversation
{
}
/**
 * @param conversationIds 被删除的会话ID列表，可以根据该ID列表移除界面上展示的会话数据
 */
- (void)onConversationDeleted:(NSArray<NSString *> *)conversationIds
{
}
- (void)onConversationChanged:(NSArray<V2NIMLocalConversation *> *)conversationList
{
}
- (void)onTotalUnreadCountChanged:(NSInteger)unreadCount
{ 
}
- (void)onUnreadCountChangedByFilter:(V2NIMLocalConversationFilter *)filter
                         unreadCount:(NSInteger)unreadCount
{  
}
- (void)onConversationReadTimeUpdated:(NSString *)conversationId
                             readTime:(NSTimeInterval)readTime
{ 
}
- (void)addListener
{
    [[NIMSDK sharedSDK].v2LocalConversationService addConversationListener:self];
}
- (void)removeListener
{
    [[NIMSDK sharedSDK].v2LocalConversationService removeConversationListener:self];
}
@end

C++V2NIMLocalConversationListener 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 = [](V2NIMLocalConversation conversation) {
    // handle conversation created event
};
listener.onConversationDeleted = [](nstd::vector<nstd::string> conversationIds) {
    // handle conversation deleted event
};
listener.onConversationChanged = [](nstd::vector<V2NIMLocalConversation> conversationList) {
    // handle conversation changed event
};
listener.onTotalUnreadCountChanged = [](uint32_t unreadCount) {
    // handle total unread count changed event
};
listener.onUnreadCountChangedByFilter = [](V2NIMLocalConversationFilter filter, uint32_t unreadCount) {
    // handle unread count changed by group event
};
localConversationService.addConversationListener(listener);

Javavoid removeConversationListener(@NonNull V2NIMLocalConversationListener listener);

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

C++virtual void removeConversationListener(const V2NIMLocalConversationListener& listener) = 0;

JavaNIMClient.getService(V2NIMLocalConversationService.class).removeConversationListener(listener);

Objective-Cid<V2NIMLocalConversationListener> listener;
[NIMSDK.sharedSDK.v2LocalConversationService removeConversationListener:listener];

C++V2NIMLocalConversationListener listener;
// ...
localConversationService.addConversationListener(listener);
// ...
localConversationService.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> {
  on<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void
  once<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void
  off<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void
  removeAllListeners<T extends keyof I>(eventName?: T): 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.V2NIMLocalConversationService.on("onSyncStarted", () => {});
nim.V2NIMLocalConversationService.on("onSyncFinished", () => {});
nim.V2NIMLocalConversationService.on("onSyncFailed", (err) => {});
nim.V2NIMLocalConversationService.on("onConversationCreated", (conversation: V2NIMLocalConversation) => {});
nim.V2NIMLocalConversationService.on("onConversationDeleted", (conversationIds: string[]) => {});
nim.V2NIMLocalConversationService.on("onConversationChanged", (conversationList: V2NIMLocalConversation[]) => {});
nim.V2NIMLocalConversationService.on("onTotalUnreadCountChanged", (unreadCount: number) => {});
nim.V2NIMLocalConversationService.on("onUnreadCountChangedByFilter", (filter: V2NIMLocalConversationFilter, unreadCount: number) => {});
nim.V2NIMLocalConversationService.on("onConversationReadTimeUpdated", (conversationId: string, readTime: number) => {});

TypeScriptv2.localConversationService.on("syncStarted", function () {});
v2.localConversationService.on("syncFinished", function () {});
v2.localConversationService.on("syncFailed", function (err) {});
v2.localConversationService.on("conversationCreated", function (conversation: V2NIMLocalConversation) {});
v2.localConversationService.on("conversationDeleted", function (conversationIds: string[]) {});
v2.localConversationService.on("conversationChanged", function (conversationList: V2NIMLocalConversation[]) {});
v2.localConversationService.on("totalUnreadCountChanged", function (unreadCount: number) {});
v2.localConversationService.on("unreadCountChangedByFilter", function (filter: V2NIMLocalConversationFilter, unreadCount: number) {});
v2.localConversationService.on("conversationReadTimeUpdated", function (conversationId: string, readTime: number) {});

TypeScriptnim.localConversationService.on("onSyncStarted", () => {});
nim.localConversationService.on("onSyncFinished", () => {});
nim.localConversationService.on("onSyncFailed", (err) => {});
nim.localConversationService.on("onConversationCreated", (conversation: V2NIMLocalConversation) => {});
nim.localConversationService.on("onConversationDeleted", (conversationIds: string[]) => {});
nim.localConversationService.on("onConversationChanged", (conversationList: V2NIMLocalConversation[]) => {});
nim.localConversationService.on("onTotalUnreadCountChanged", (unreadCount: number) => {});
nim.localConversationService.on("onUnreadCountChangedByFilter", (filter: V2NIMLocalConversationFilter, unreadCount: number) => {});
nim.localConversationService.on("onConversationReadTimeUpdated", (conversationId: string, readTime: number) => {});

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> {
  on<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void
  once<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void
  off<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void
  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.V2NIMLocalConversationService.off("onSyncStarted", theListner)
nim.V2NIMLocalConversationService.off("onSyncFinished", theListner)
nim.V2NIMLocalConversationService.off("onSyncFailed", theListner)
nim.V2NIMLocalConversationService.off("onConversationCreated", theListner)
nim.V2NIMLocalConversationService.off("onConversationDeleted", theListner)
nim.V2NIMLocalConversationService.off("onConversationChanged", theListner)
nim.V2NIMLocalConversationService.off("onTotalUnreadCountChanged", theListner)
nim.V2NIMLocalConversationService.off("onUnreadCountChangedByFilter", theListner)
nim.V2NIMLocalConversationService.off("onConversationReadTimeUpdated", theListner)
// remove all listeners
nim.localConversationService.removeAllListeners()

TypeScriptv2.localConversationService.off("syncStarted")
v2.localConversationService.off("syncFinished")
v2.localConversationService.off("syncFailed")
v2.localConversationService.off("conversationCreated")
v2.localConversationService.off("conversationDeleted")
v2.localConversationService.off("conversationChanged")
v2.localConversationService.off("totalUnreadCountChanged")
v2.localConversationService.off("unreadCountChangedByFilter")
v2.localConversationService.off("conversationReadTimeUpdated")

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

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

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

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

TypeScriptcreateConversation(conversationId: string): Promise<V2NIMLocalConversation>

TypeScriptcreateConversation(conversationId): Promise<V2NIMLocalConversation>

TypeScriptcreateConversation(conversationId: string): Promise<V2NIMLocalConversation>

JavaString conversationId = "cjl|1|cjl1";
NIMClient.getService(V2NIMLocalConversationService.class).createConversation(conversationId, new V2NIMSuccessCallback<V2NIMLocalConversation>() {
  @Override
  public void onSuccess(V2NIMLocalConversation result) {
   // 创建成功
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   // 创建失败
  }
});

Objective-CNSString *conversationId = @"cjl|1|cjl1";
[[NIMSDK sharedSDK].v2LocalConversationService createConversation:conversationId
                                                          success:^(V2NIMLocalConversation *result) {
    // 创建成功
} failure:^(V2NIMError *error) {
    // 创建失败
}];

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

TypeScriptconst datas = await nim.V2NIMLocalConversationService.createConversation("CONVERSATION_ID")

TypeScriptconst conversation = await v2.localConversationService.createConversation('conversation1')

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

无返回值。

Promise<V2NIMLocalConversation> 本地会话对象

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

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

创建成功，返回 onConversationCreated 回调。

创建成功，返回 conversationCreated 回调。

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

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

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

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

TypeScriptdeleteConversation(conversationId, clearMessage): Promise<void>

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

JavaString conversationId = "cjl|1|cjl1";
//是否清空消息记录
boolean clearMessage = true;
NIMClient.getService(V2NIMLocalConversationService.class).deleteConversation(conversationId, clearMessage, new V2NIMSuccessCallback<Void>() {
  @Override
  public void onSuccess(Void result) {
   // 删除成功
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   // 删除失败
  }
});

Objective-CNSString *conversationId = @"cjl|1|cjl1";
// 是否清空消息记录
BOOL clearMessage = YES;
[[NIMSDK sharedSDK].v2LocalConversationService deleteConversation:conversationId
                                                     clearMessage:clearMessage
                                                          success:^() {
    // 删除成功
} failure:^(V2NIMError *error) {
    // 删除失败
}];

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

TypeScriptawait nim.V2NIMLocalConversationService.deleteConversation("CONVERSATION_ID", true)

TypeScriptawait v2.localConversationService.deleteConversation('conversation1', true)

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

无返回值。

Promise<void>

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

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

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

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

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

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

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

TypeScriptdeleteConversationListByIds(conversationIds, clearMessage): Promise<V2NIMLocalConversationOperationResult[]>

TypeScriptdeleteConversationListByIds(conversationIds, clearMessage?): Promise<V2NIMLocalConversationOperationResult[]>

JavaList<String> conversationIds = new ArrayList<>();
conversationIds.add("cjl|1|cjl1");
conversationIds.add("cjl|2|43243253");
conversationIds.add("cjl|3|234323432");
//是否清空消息记录
boolean clearMessage = true;
NIMClient.getService(V2NIMLocalConversationService.class).deleteConversationListByIds(conversationIds, clearMessage, new V2NIMSuccessCallback<List<V2NIMLocalConversationOperationResult>>() {
  @Override
  public void onSuccess(List<V2NIMLocalConversationOperationResult> result) {
   // 删除成功,返回会话ID操作失败的列表
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   // 删除失败
  }
});

Objective-CNSMutableArray *conversationIds = [[NSMutableArray alloc] init];
[conversationIds addObject:@"cjl|1|cjl1"];
[conversationIds addObject:@"cjl|2|43243253"];
[conversationIds addObject:@"cjl|3|234323432"];
// 是否清空消息记录
BOOL clearMessage = YES;
[[NIMSDK sharedSDK].v2LocalConversationService deleteConversationListByIds:conversationIds 
                                                               clearMessage:clearMessage 
                                                                    success:^(NSArray<V2NIMLocalConversationOperationResult *> *result) {
    // 删除成功,返回会话ID操作失败的列表
} failure:^(V2NIMError *error) {
    // 删除失败
}];

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

TypeScriptawait nim.V2NIMLocalConversationService.deleteConversationListByIds(["CONVERSATION_ID1", "CONVERSATION_ID2"], true)

TypeScriptconst result = await v2.localConversationService.deleteConversationListByIds(['conversation1', 'conversation2'], true)

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

无返回值。

Promise<V2NIMLocalConversationOperationResult[]>

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

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

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

每一条本地会话删除成功，均返回 conversationDeleted 回调。可能返回 totalUnreadCountChanged 和 unreadCountChangedByFilter 回调。

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

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

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

TypeScriptgetConversation(conversationId: string): Promise<V2NIMLocalConversation>

TypeScriptgetConversation(conversationId): Promise<V2NIMLocalConversation>

TypeScriptgetConversation(conversationId): Promise<V2NIMLocalConversation>

JavaString conversationId = "cjl|1|cjl1";
NIMClient.getService(V2NIMLocalConversationService.class).getConversation(conversationId, new V2NIMSuccessCallback<V2NIMLocalConversation>() {
  @Override
  public void onSuccess(V2NIMLocalConversation result) {
    // 获取成功
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
    //获取失败   
  }
});

Objective-CNSString *conversationId = @"cjl|1|cjl1";

[[NIMSDK sharedSDK].v2LocalConversationService getConversation:conversationId
                                                      success:^(V2NIMLocalConversation *result) {
    // 获取成功
} failure:^(V2NIMError *error) {
    // 获取失败
}];

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

TypeScriptconst data = await nim.V2NIMLocalConversationService.getConversation("TARGET_CONVERSATION_ID")

TypeScriptconst conversation = await v2.localConversationService.getConversation('conversation1')

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

无返回值。

Promise<V2NIMLocalConversation> 本地会话对象

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

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

无。

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

Objective-C- (void)getConversationList:(NSInteger)offset
                      limit:(NSInteger)limit
                    success:(V2NIMLocalConversationResultCallback)success
                    failure:(V2NIMFailureCallback)failure;

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

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

TypeScriptgetConversationList(offset, limit): Promise<V2NIMLocalConversationResult>

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

Javaint offset = 0;
//分页拉取数量，不建议超过100
int limit = 100;
NIMClient.getService(V2NIMLocalConversationService.class).getConversationList(offset, limit, new V2NIMSuccessCallback<V2NIMLocalConversationResult>() {
    @Override
    public void onSuccess(V2NIMLocalConversationResult result) {
        // 获取成功
        //本地会话列表
        List<V2NIMLocalConversation> conversationList = result.getConversationList();
        //是否拉取完毕
        boolean finished = result.isFinished();
        //下一次拉取偏移量，首次传入的offset值，后续拉取采用上一次返回的offset值。如果finished为true，则返回0
        long nextOffset = result.getOffset();
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        //获取失败
    }
});

Objective-CNSInteger offset = 0;
// 分页拉取数量，不建议超过100
NSInteger limit = 100;
[[NIMSDK sharedSDK].v2LocalConversationService getConversationList:offset
                                                             limit:limit
                                                           success:^(V2NIMLocalConversationResult *result) {
    // 获取成功
    // 本地会话列表
    NSArray<V2NIMLocalConversation *> *conversationList = result.conversationList;
    // 是否拉取完毕
    BOOL finished = result.finished;
    // 下一次拉取偏移量，首次传入的offset值，后续拉取采用上一次返回的offset值。如果finished为true，则返回0
    NSInteger nextOffset = result.offset;
    } failure:^(V2NIMError *error) {
        // 获取失败
    }];

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

TypeScriptconst { offset, finished, conversationList } = await nim.V2NIMLocalConversationService.getConversationList(0, 100)

TypeScriptconst result = await v2.localConversationService.getConversationList(0, 10)

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

无返回值。

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

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

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

无。

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

Objective-C- (void)getConversationListByOption:(NSInteger)offset
                              limit:(NSInteger)limit
                             option:(nullable V2NIMLocalConversationOption *)option
                            success:(V2NIMLocalConversationResultCallback)success
                            failure:(V2NIMFailureCallback)failure;

C++virtual void getConversationListByOption(uint32_t offset,
    uint32_t limit,
    const V2NIMLocalConversationOption& option,
    const V2NIMSuccessCallback<const V2NIMLocalConversationResult&>& success,
    const V2NIMFailureCallback& failure) = 0;

TypeScriptgetConversationListByOption(offset: number, limit: number, option: V2NIMLocalConversationOption): Promise<V2NIMLocalConversationResult>

TypeScriptgetConversationListByOption(offset, limit, option): Promise<V2NIMLocalConversationResult>

TypeScriptgetConversationListByOption(offset: number, limit: number, option: V2NIMLocalConversationOption): Promise<V2NIMLocalConversationResult>

Javaint offset = 0;
//分页拉取数量，不建议超过100
int limit = 100;
//会话类型列表,为空表示查询所有类型，否则查询指定对话类型
List<V2NIMConversationType> conversationTypes = new ArrayList<>();
//是否只拉取未读会话，默认false
boolean onlyUnread = false;
V2NIMLocalConversationOption option = new V2NIMLocalConversationOption(conversationTypes, onlyUnread);
NIMClient.getService(V2NIMLocalConversationService.class).getConversationListByOption(offset, limit, option, new V2NIMSuccessCallback<V2NIMLocalConversationResult>() {
    @Override
    public void onSuccess(V2NIMLocalConversationResult result) {
        // 获取成功
        //本地会话列表
        List<V2NIMLocalConversation> conversationList = result.getConversationList();
        //是否拉取完毕
        boolean finished = result.isFinished();
        //下一次拉取偏移量，首次传入的offset值，后续拉取采用上一次返回的offset值。如果finished为true，则返回0
        long nextOffset = result.getOffset();
    }
}, new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
        //获取失败
    }
});

Objective-CNSInteger offset = 0;
// 分页拉取数量，不建议超过100
NSInteger limit = 100;
// 会话类型列表,为空表示查询所有类型，否则查询指定对话类型
NSArray<NSNumber *> *conversationTypes = @[];
// 是否只拉取未读会话，默认false
BOOL onlyUnread = NO;

V2NIMLocalConversationOption *option = [[V2NIMLocalConversationOption alloc] init];
option.conversationTypes = conversationTypes;
option.onlyUnread = onlyUnread;

[[NIMSDK sharedSDK].v2LocalConversationService getConversationListByOption:offset
                                                                     limit:limit
                                                                    option:option
                                                                   success:^(V2NIMLocalConversationResult *result) {
    // 获取成功
    // 本地会话列表
    NSArray<V2NIMLocalConversation *> *conversationList = result.conversationList;
    // 是否拉取完毕
    BOOL finished = result.finished;
    // 下一次拉取偏移量，首次传入的offset值，后续拉取采用上一次返回的offset值。如果finished为true，则返回0
    NSInteger nextOffset = result.offset;
} failure:^(V2NIMError *error) {
    // 获取失败
}];

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

TypeScriptconst { offset, finished, conversationList } = await nim.V2NIMLocalConversationService.getConversationListByOption(0, 100, {
  conversationTypes: [V2NIMConst.V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P]
  onlyUnread: true,
})

TypeScriptconst result = await v2.localConversationService.getConversationListByOption(0, 10, {
  conversationTypes: [1, 2]
})

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

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

无返回值。

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

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

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

无。

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

Objective-C- (void)getConversationListByIds:(NSArray<NSString *> *)conversationIds
                         success:(V2NIMLocalConversationListCallback)success
                         failure:(V2NIMFailureCallback)failure;

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

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

TypeScriptgetConversationListByIds(conversationIds): Promise<V2NIMLocalConversation[]>

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

JavaList<String> conversationIds = new ArrayList<>();
conversationIds.add("cjl|1|cjl1");
conversationIds.add("cjl|2|43243253");
conversationIds.add("cjl|3|234323432");
NIMClient.getService(V2NIMLocalConversationService.class).getConversationListByIds(conversationIds, new V2NIMSuccessCallback<List<V2NIMLocalConversation>>() {
  @Override
  public void onSuccess(List<V2NIMLocalConversation> result) {
   // 获取成功
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   // 获取失败
  }
});

Objective-CNSMutableArray *conversationIds = [[NSMutableArray alloc] init];
[conversationIds addObject:@"cjl|1|cjl1"];
[conversationIds addObject:@"cjl|2|43243253"];
[conversationIds addObject:@"cjl|3|234323432"];

[[NIMSDK sharedSDK].v2LocalConversationService getConversationListByIds:conversationIds
                                                                success:^(NSArray<V2NIMLocalConversation *> *result) {
    // 获取成功
} failure:^(V2NIMError *error) {
    // 获取失败
}];

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

TypeScriptconst datas = await nim.V2NIMLocalConversationService.getConversationListByIds(["TARGET_CONVERSATION_ID", "TARGET_CONVERSATION_ID2"]])

TypeScriptconst list = await v2.localConversationService.getConversationListByIds(['conversation1', 'conversation2'])

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

无返回值。

Promise<V2NIMLocalConversation[]> 本地会话列表相关信息

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

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

无。

javavoid updateConversationLocalExtension(@NonNull String conversationId, String localExtension, V2NIMSuccessCallback<Void> success,
   V2NIMFailureCallback failure);

Objective-C- (void)updateConversationLocalExtension:(NSString *)conversationId
                          localExtension:(NSString *)localExtension
                                 success:(V2NIMSuccessCallback)success
                                 failure:(V2NIMFailureCallback)failure;

c++virtual void updateConversationLocalExtension(const nstd::string& conversationId,
    const nstd::string& localExtension,
    const V2NIMSuccessCallback<void>& success,
    const V2NIMFailureCallback& failure) = 0;

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

TypeScriptupdateConversationLocalExtension(conversationId, localExtension): Promise<void>

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

javaString conversationId = "cjl|1|cjl1";
//本地扩展字段
String localExtension = "localExtension";
NIMClient.getService(V2NIMLocalConversationService.class).updateConversationLocalExtension(conversationId, localExtension, new V2NIMSuccessCallback<Void>() {
  @Override
  public void onSuccess(Void result) {
   // 更新成功
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   // 更新失败
  }
});

Objective-CNSString *conversationId = @"cjl|1|cjl1";
// 本地扩展字段
NSString *localExtension = @"localExtension";
[[NIMSDK sharedSDK].v2LocalConversationService updateConversationLocalExtension:conversationId
                                                                 localExtension:localExtension
                                                                        success:^() {
    // 更新成功
} failure:^(V2NIMError *error) {
    // 更新失败
}];

c++auto conversationId = V2NIMConversationIdUtil::p2pConversationId("account1");
localConversationService.updateConversationLocalExtension(
    conversationId,
    "localExtension",
    []() {
        // update succeeded
    },
    [](V2NIMError error) {
        // update failed, handle error
    });

TypeScriptawait nim.V2NIMLocalConversationService.updateConversationLocalExtension("CONVERSATION_ID", 'newLocalExtension!'})

TypeScriptawait v2.localConversationService.updateConversationLocalExtension('conversation1', 'newExtension')

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

无返回值。

Promise<void>

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

更新成功，返回 onConversationChanged 回调。

更新成功，返回 conversationChanged 回调。

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

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

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

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

TypeScriptstickTopConversation(conversationId, stickTop): Promise<void>

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

JavaString conversationId = "cjl|1|cjl1";
//是否置顶,true：置顶, false：取消置顶
boolean stickTop = true;
NIMClient.getService(V2NIMLocalConversationService.class).stickTopConversation(conversationId, stickTop, new V2NIMSuccessCallback<Void>() {
  @Override
  public void onSuccess(Void result) {
   // 置顶成功
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   // 置顶失败
  }
});

Objective-CNSString *conversationId = @"cjl|1|cjl1";
// 是否置顶,YES：置顶, NO：取消置顶
BOOL stickTop = YES;
[[NIMSDK sharedSDK].v2LocalConversationService stickTopConversation:conversationId 
                                                           stickTop:stickTop 
                                                            success:^(id result) {
    // 置顶成功
} failure:^(V2NIMError *error) {
    // 置顶失败
}];

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

TypeScriptawait nim.V2NIMLocalConversationService.stickTopConversation("CONVERSATION_ID", true)

TypeScriptawait v2.localConversationService.stickTopConversation('conversation1', true)

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

无返回值。

Promise<void>

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

置顶成功，返回 onConversationChanged 回调。

置顶成功，返回 conversationChanged 回调。

Javaint getTotalUnreadCount();

无参数。

Objective-C- (NSInteger)getTotalUnreadCount;

无参数。

C++virtual uint32_t getTotalUnreadCount() = 0;

无参数。

TypeScriptgetTotalUnreadCount(): number

无参数。

TypeScriptgetTotalUnreadCount(): number

无参数。

TypeScriptgetTotalUnreadCount(): number

无参数。

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

Objective-CNSInteger totalUnreadCount = [[NIMSDK sharedSDK].v2LocalConversationService getTotalUnreadCount];

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

TypeScriptconst count = nim.V2NIMLocalConversationService.getTotalUnreadCount()

TypeScriptconst count = await v2.localConversationService.getTotalUnreadCount()

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

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

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

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

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

TypeScriptgetUnreadCountByIds(conversationIds): Promise<number>

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

JavaList<String> conversationIds = new ArrayList<>();
conversationIds.add("cjl|1|cjl1");
conversationIds.add("cjl|2|43243253");
NIMClient.getService(V2NIMLocalConversationService.class).getUnreadCountByIds(conversationIds, new V2NIMSuccessCallback<Integer>() {
  @Override
  public void onSuccess(Integer unreadCounts) {
   // 获取成功,返回总未读数为所有合法会话加和后的值
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   //获取失败
  }
});

Objective-CNSMutableArray *conversationIds = [[NSMutableArray alloc] init];
[conversationIds addObject:@"cjl|1|cjl1"];
[conversationIds addObject:@"cjl|2|43243253"];
[[NIMSDK sharedSDK].v2LocalConversationService getUnreadCountByIds:conversationIds 
                                                           success:^(NSInteger unreadCounts) {
    // 获取成功,返回总未读数为所有合法会话加和后的值
} failure:^(V2NIMError *error) {
    // 获取失败
}];

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

TypeScriptconst unreadCounts = await nim.V2NIMLocalConversationService.getUnreadCountByIds(["CONVERSATION_ID1,CONVERSATION_ID2"])

TypeScriptconst count = await v2.localConversationService.getUnreadCountByIds(['conversation1', 'conversation2'])

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

无返回值。

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

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

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

无。

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

Objective-C- (void)getUnreadCountByFilter:(V2NIMLocalConversationFilter *)filter
                       success:(V2NIMLocalConversationUnreadCountCallback)success
                       failure:(V2NIMFailureCallback)failure;

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

TypeScriptgetUnreadCountByFilter(filter: V2NIMLocalConversationFilter): Promise<number>

TypeScriptgetUnreadCountByFilter(filter): Promise<number>

TypeScriptgetUnreadCountByFilter(filter: V2NIMLocalConversationFilter): Promise<number>

JavaList<V2NIMConversationType> conversationTypes = new ArrayList<>();
//是否忽略免打扰
boolean ignoreMuted = true;
V2NIMLocalConversationFilter filter = new V2NIMLocalConversationFilter(conversationTypes, ignoreMuted);
NIMClient.getService(V2NIMLocalConversationService.class).getUnreadCountByFilter(filter, new V2NIMSuccessCallback<Integer>() {
  @Override
  public void onSuccess(Integer unreadCounts) {
   // 获取成功,返回总未读数为所有合法会话加和后的值
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   //获取失败
  }
});

Objective-CNSMutableArray *conversationTypes = [[NSMutableArray alloc] init];
// 是否忽略免打扰
BOOL ignoreMuted = YES;
V2NIMLocalConversationFilter *filter = [[V2NIMLocalConversationFilter alloc] init];
filter.conversationTypes = conversationTypes;
filter.ignoreMuted = ignoreMuted;
[[NIMSDK sharedSDK].v2LocalConversationService getUnreadCountByFilter:filter
                                                              success:^(NSInteger unreadCounts) {
    // 获取成功,返回总未读数为所有合法会话加和后的值
} failure:^(V2NIMError *error) {
    // 获取失败
}];

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

TypeScriptconst unreadCounts = await nim.V2NIMLocalConversationService.getUnreadCountByFilter({ ignoreMuted: true })

TypeScriptconst count = await v2.localConversationService.getUnreadCountByFilter({ conversationTypes: [1, 2] })

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

无返回值。

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

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

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

无。

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

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

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

TypeScriptclearTotalUnreadCount(): Promise<void>

无参数。

TypeScriptclearTotalUnreadCount(): Promise<void>

无参数。

TypeScriptclearTotalUnreadCount(): Promise<void>

无参数。

JavaNIMClient.getService(V2NIMLocalConversationService.class).clearTotalUnreadCount(new V2NIMSuccessCallback<Void>() {
  @Override
  public void onSuccess(Void unused) {
   // 清除成功
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   // 清除失败
  }
});

Objective-C[[NIMSDK sharedSDK].v2LocalConversationService clearTotalUnreadCount:^(void) {
        // 清除成功
    } failure:^(V2NIMError *error) {
        // 清除失败
    }];

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

TypeScriptawait nim.V2NIMLocalConversationService.clearTotalUnreadCount()

TypeScriptawait v2.localConversationService.clearTotalUnreadCount()

TypeScripttry {
  await this.localConversationService.clearTotalUnreadCount()
  // success
} catch (e) {
  // fail
}

无返回值。

Promise<void>

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

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

清零成功，返回 totalUnreadCountChanged、conversationChanged 和 unreadCountChangedByFilter 回调。

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

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

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

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

TypeScriptclearUnreadCountByIds(conversationIds): Promise<V2NIMLocalConversationOperationResult[]>

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

JavaList<String> conversationIds = new ArrayList<>();
conversationIds.add("cjl|1|cjl1");
conversationIds.add("cjl|2|43243253");
NIMClient.getService(V2NIMLocalConversationService.class).clearUnreadCountByIds(conversationIds, new V2NIMSuccessCallback<List<V2NIMLocalConversationOperationResult>>() {
  @Override
  public void onSuccess(List<V2NIMLocalConversationOperationResult> result) {
   // 清除成功,返回会话ID操作失败的列表
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   // 清除失败
  }
});

Objective-CNSMutableArray *conversationIds = [[NSMutableArray alloc] init];
[conversationIds addObject:@"cjl|1|cjl1"];
[conversationIds addObject:@"cjl|2|43243253"];

[[NIMSDK sharedSDK].v2LocalConversationService clearUnreadCountByIds:conversationIds success:^(NSArray<V2NIMLocalConversationOperationResult *> *result) {
    // 清除成功,返回会话ID操作失败的列表
} failure:^(V2NIMError *error) {
    // 清除失败
}];

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

TypeScriptconst results = await nim.V2NIMLocalConversationService.clearUnreadCountByIds(["CONVERSATION_ID1", "CONVERSATION_ID2"])

TypeScriptconst result = await v2.localConversationService.clearUnreadCountByIds(['conversation1', 'conversation2'])

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

无返回值。

Promise<V2NIMLocalConversationOperationResult []>

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

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

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

清零成功，返回 totalUnreadCountChanged、conversationChanged 和 unreadCountChangedByFilter 回调。

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

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

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

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

TypeScriptclearUnreadCountByTypes(conversationTypes): Promise<void>

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

JavaList<V2NIMConversationType> conversationTypes = new ArrayList<>();
conversationTypes.add(V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P);
NIMClient.getService(V2NIMLocalConversationService.class).clearUnreadCountByTypes(conversationTypes, new V2NIMSuccessCallback<Void>() {
  @Override
  public void onSuccess(Void unused) {
   // 清除成功
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   // 清除失败
  }
});

Objective-CNSMutableArray *conversationTypes = [[NSMutableArray alloc] init];
[conversationTypes addObject:@(V2NIMConversationTypeP2P)];

[[NIMSDK sharedSDK].v2LocalConversationService clearUnreadCountByTypes:conversationTypes success:^(id unused) {
    // 清除成功
} failure:^(V2NIMError *error) {
    // 清除失败
}];

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

TypeScriptawait nim.V2NIMLocalConversationService.clearUnreadCountByTypes([V2NIMConst.V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P])

TypeScriptawait v2.localConversationService.clearUnreadCountByTypes([1, 2])

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

无返回值。

Promise<void>

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

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

清零成功，返回 totalUnreadCountChanged、conversationChanged 和 unreadCountChangedByFilter 回调。

JavaV2NIMError subscribeUnreadCountByFilter(@NonNull V2NIMLocalConversationFilter filter);

Objective-C- (V2NIMError *)subscribeUnreadCountByFilter:(V2NIMLocalConversationFilter *)filter;

C++virtual nstd::optional<V2NIMError> subscribeUnreadCountByFilter(const V2NIMLocalConversationFilter& filter) = 0;

TypeScriptsubscribeUnreadCountByFilter(filter: V2NIMLocalConversationFilter): void

TypeScriptsubscribeUnreadCountByFilter(filter): null | V2NIMError

TypeScriptsubscribeUnreadCountByFilter(filter: V2NIMLocalConversationFilter): void

JavaList<V2NIMConversationType> conversationTypes = new ArrayList<>();
conversationTypes.add(V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P);
//是否忽略免打扰
boolean ignoreMuted = true;
V2NIMLocalConversationFilter filter = new V2NIMLocalConversationFilter(conversationTypes,ignoreMuted);
NIMClient.getService(V2NIMLocalConversationService.class).subscribeUnreadCountByFilter(filter);

Objective-CNSMutableArray<NSNumber *> *conversationTypes = [[NSMutableArray alloc] init];
[conversationTypes addObject:@(V2NIM_CONVERSATION_TYPE_P2P)];

// 是否忽略免打扰
BOOL ignoreMuted = YES;

V2NIMLocalConversationFilter *filter = [[V2NIMLocalConversationFilter alloc] init];
filter.conversationTypes = conversationTypes;
filter.ignoreMuted = ignoreMuted;

[[NIMSDK sharedSDK].v2LocalConversationService subscribeUnreadCountByFilter:filter];

C++V2NIMLocalConversationFilter filter;
filter.conversationTypes = {V2NIM_CONVERSATION_TYPE_P2P, V2NIM_CONVERSATION_TYPE_TEAM};
auto error = localConversationService.subscribeUnreadCountByFilter(filter);
if (error) {
    // subscribe failed, handle error
}

TypeScript// Eg. Subscribe to P2P conversation and ignore those muted conversation
nim.V2NIMLocalConversationService.subscribeUnreadCountByFilter({
  conversationTypes: [V2NIMConst.V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P];
  ignoreMuted: true;
})

TypeScriptawait v2.localConversationService.subscribeUnreadCountByFilter({ conversationTypes: [1, 2] })

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

JavaV2NIMError unsubscribeUnreadCountByFilter(@NonNull V2NIMLocalConversationFilter filter);

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

C++virtual nstd::optional<V2NIMError> unsubscribeUnreadCountByFilter(const V2NIMLocalConversationFilter& filter) = 0;

TypeScriptunsubscribeUnreadCountByFilter(filter: V2NIMLocalConversationFilter): void

TypeScriptunsubscribeUnreadCountByFilter(filter): null | V2NIMError

TypeScriptunsubscribeUnreadCountByFilter(filter: V2NIMLocalConversationFilter): void

JavaList<V2NIMConversationType> conversationTypes = new ArrayList<>();
conversationTypes.add(V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P);
//是否忽略免打扰
boolean ignoreMuted = true;
V2NIMLocalConversationFilter filter = new V2NIMLocalConversationFilter(conversationTypes,ignoreMuted);
NIMClient.getService(V2NIMLocalConversationService.class).unsubscribeUnreadCountByFilter(filter);

Objective-CNSMutableArray *conversationTypes = [[NSMutableArray alloc] init];
[conversationTypes addObject:@(V2NIM_CONVERSATION_TYPE_P2P)];

// 是否忽略免打扰
BOOL ignoreMuted = YES;

V2NIMLocalConversationFilter *filter = [[V2NIMLocalConversationFilter alloc] init];
filter.conversationTypes = conversationTypes;
filter.ignoreMuted = ignoreMuted;

[[NIMSDK sharedSDK].v2LocalConversationService unsubscribeUnreadCountByFilter:filter];

C++auto error = localConversationService.unsubscribeUnreadCountByFilter(filter);
if (error) {
    // unsubscribe failed, handle error
}

TypeScript// Eg. Subscribe to P2P conversation and ignore those muted conversation
const filter = {
  conversationTypes: [V2NIMConst.V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P];
  ignoreMuted: true;
}
nim.V2NIMLocalConversationService.subscribeUnreadCountByFilter(filter)
nim.V2NIMLocalConversationService.unsubscribeUnreadCountByFilter(filter)

TypeScriptawait v2.localConversationService.unsubscribeUnreadCountByFilter({ conversationTypes: [1, 2] })

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

Javavoid markConversationRead(String conversationId, V2NIMSuccessCallback<Long> success, V2NIMFailureCallback failure);

Objective-C- (void)markConversationRead:(NSString *)conversationId
                     success:(V2NIMLocalConversationReadTimeCallback)success
                     failure:(V2NIMFailureCallback)failure;

C++virtual void markConversationRead(const nstd::string& conversationId,
    const V2NIMSuccessCallback<time_t>& success,
    const V2NIMFailureCallback& failure) = 0;

TypeScriptmarkConversationRead(conversationId: string): Promise<number>

TypeScriptmarkConversationRead(conversationId): Promise<number>

TypeScriptmarkConversationRead(conversationId: string): Promise<void>

JavaString conversationId = "cjl|1|cjl1";
NIMClient.getService(V2NIMLocalConversationService.class).markConversationRead(conversationId, new V2NIMSuccessCallback<Long>() {
  @Override
  public void onSuccess(Long result) {
   // 标记成功,返回会话已读时间戳，单位毫秒
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {
   // 标记失败
  }
});

Objective-CNSString *conversationId = @"cjl|1|cjl1";
[[NIMSDK sharedSDK].v2LocalConversationService markConversationRead:conversationId success:^(NSTimeInterval result) {
    // 标记成功,返回会话已读时间戳，单位毫秒
} failure:^(V2NIMError *error) {
    // 标记失败
}];

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

TypeScriptconst readTime = await nim.V2NIMLocalConversationService.markConversationRead("CONVERSATION_ID")

TypeScriptconst time = await v2.localConversationService.markConversationRead('conversation1')

TypeScriptawait this.localConversationService.markConversationRead('me|1|you')

无返回值。

Promise<number> 标记时间

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

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

无。

Javavoid getConversationReadTime(String conversationId, V2NIMSuccessCallback<Long> success, V2NIMFailureCallback failure);

Objective-C- (void)getConversationReadTime:(NSString *)conversationId
                        success:(V2NIMLocalConversationReadTimeCallback)success
                        failure:(V2NIMFailureCallback)failure;

C++virtual void getConversationReadTime(const nstd::string& conversationId,
    const V2NIMSuccessCallback<time_t>& success,
    const V2NIMFailureCallback& failure) = 0;

TypeScriptgetConversationReadTime(conversationId: string): Promise<number>

TypeScriptgetConversationReadTime(conversationId): Promise<number>

TypeScriptgetConversationReadTime(conversationId: string): Promise<number>

JavaString conversationId = "cjl|1|cjl1";
NIMClient.getService(V2NIMLocalConversationService.class).getConversationReadTime(conversationId, new V2NIMSuccessCallback<Long>() {
  @Override
  public void onSuccess(Long result) {
   // 获取成功,返回会话已读时间戳，单位毫秒
  }
}, new V2NIMFailureCallback() {
  @Override
  public void onFailure(V2NIMError error) {

  }
});

Objective-CNSString *conversationId = @"cjl|1|cjl1";
[[NIMSDK sharedSDK].v2LocalConversationService getConversationReadTime:conversationId success:^(NSTimeInterval result) {
    // 获取成功,返回会话已读时间戳，单位秒
} failure:^(V2NIMError *error) {
    
}];

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

TypeScriptconst readTime = await nim.V2NIMLocalConversationService.getConversationReadTime("CONVERSATION_ID")

TypeScriptconst time = await v2.localConversationService.getConversationReadTime('conversation1')

TypeScriptawait this.localConversationService.getConversationReadTime('me|1|you')

无返回值。

Promise<number> 时间戳

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

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

无。